def define_frozen_set_strategy(specifier, settings): if not specifier: return st.frozensets(max_size=0) else: with settings: return st.frozensets( st.one_of(*[self(s, settings) for s in specifier]))
def test_nested_set_complexity(): strat = frozensets(frozensets(complex_numbers())) rnd = Random(0) template = ( ((float('inf'), 1.0), (-1.0325215252103651e-149, 1.0)), ((-1.677443578786644e-309, -1.0), (-2.2250738585072014e-308, 0.0)) ) simplifiers = list(strat.simplifiers(rnd, template)) rnd.shuffle(simplifiers) simplifiers = simplifiers[:10] for simplify in simplifiers: for s in islice(simplify(rnd, template), 50): assert not strat.strictly_simpler(template, s)
def test_can_use_recursive_data_in_sets(rnd): nested_sets = st.recursive( st.booleans(), lambda js: st.frozensets(js, average_size=2.0), max_leaves=10 ) nested_sets.example(rnd) def flatten(x): if isinstance(x, bool): return frozenset((x,)) else: result = frozenset() for t in x: result |= flatten(t) if len(result) == 2: break return result assert rnd is not None x = find( nested_sets, lambda x: len(flatten(x)) == 2, random=rnd, settings=settings(database=None, max_shrinks=1000, max_examples=1000)) assert x in ( frozenset((False, True)), frozenset((False, frozenset((True,)))), frozenset((frozenset((False, True)),)) )
def test_minimize_list_of_sets_on_large_structure(): def test_list_in_range(xs): assume(len(xs) >= 50) return len(list(filter(None, xs))) >= 50 x = minimal(lists(frozensets(integers())), test_list_in_range, timeout_after=20) assert len(x) == 50 assert len(set(x)) == 1
def test_tuple_strategy_too_large_to_fit(): x = frozensets(integers(0, 5)) assert not math.isinf(x.template_upper_bound) x = tuples(x, x) assert not math.isinf(x.template_upper_bound) assert math.isinf(tuples(x, x).template_upper_bound) assert math.isinf( tuples(integers(), x).template_upper_bound)
def test_minimize_sets_of_sets(): elements = integers(1, 100) size = 15 set_of_sets = minimal(sets(frozensets(elements)), lambda s: len(s) >= size) assert frozenset() in set_of_sets assert len(set_of_sets) == size for s in set_of_sets: if len(s) > 1: assert any(s != t and t.issubset(s) for t in set_of_sets)
def test_minimize_list_of_sets_on_large_structure(): def test_list_in_range(xs): return len(list(filter(None, xs))) >= 30 x = minimal( lists(frozensets(integers()), min_size=30), test_list_in_range, timeout_after=20, ) assert x == [frozenset([0])] * 30
def test_minimize_list_of_sets_on_large_structure(): def test_list_in_range(xs): assume(len(xs) >= 50) return len(list(filter(None, xs))) >= 50 x = minimal( lists(frozensets(integers())), test_list_in_range, timeout_after=20, ) assert len(x) == 50 assert len(set(x)) == 1
def st_hashable(): x = st.deferred(lambda: st.text() | st.binary() | st.integers() | st.floats(allow_nan=False) | st.decimals(allow_nan=False) | st.fractions() | st.datetimes() | st.tuples(x) | st.frozensets(x)) return x
def test_minimize_sets_of_sets(): elements = integers(1, 100) size = 8 set_of_sets = minimal(sets(frozensets(elements), min_size=size)) assert frozenset() in set_of_sets assert len(set_of_sets) == size for s in set_of_sets: if len(s) > 1: assert any( s != t and t.issubset(s) for t in set_of_sets )
def topologies(draw, elements=frozensets(integers()), number_of_rounds=5) -> AbstractTopology[int]: """ :param draw: A function provided by the hypothesis library that knows how to sample from a generator :param elements: A generator of sets of elements from which the topology is to be built :param number_of_rounds: The number of randomization rounds for which the topology is to be built :return: A random topology """ return RandomTopology(draw(elements), number_of_rounds)
def frozenset_typed_attrs(draw, defaults=None): """ Generate a tuple of an attribute and a strategy that yields frozensets for that attribute. The frozensets contain integers. """ default = attr.NOTHING val_strat = frozensets(integers()) if defaults is True or (defaults is None and draw(booleans())): default = draw(val_strat) return ( attr.ib( type=frozenset[int], default=default, ), val_strat, )
def test_can_use_recursive_data_in_sets(rnd): nested_sets = st.recursive(st.booleans(), lambda js: st.frozensets(js), max_leaves=10) nested_sets.example() def flatten(x): if isinstance(x, bool): return frozenset((x,)) else: result = frozenset() for t in x: result |= flatten(t) if len(result) == 2: break return result x = find(nested_sets, lambda x: len(flatten(x)) == 2, random=rnd, settings=Settings(database=None)) assert x == frozenset((False, True))
def pickles_container(values): max_size = 10 def hashable(value): try: hash(value) return True except TypeError: return False return st.one_of( n_tuples(values, max_size), st.lists(values, max_size=max_size), st.sets(values.filter(hashable), max_size=max_size), st.frozensets(values.filter(hashable), max_size=max_size), st.dictionaries(st.text(string.printable), values, max_size=max_size), )
class TargetSelectorMachine(RuleBasedStateMachine): def __init__(self): super(TargetSelectorMachine, self).__init__() self.target_selector = None self.data = [] self.tags = set() self.tag_intersections = None @precondition(lambda self: self.target_selector is None) @rule(rnd=fake_randoms()) def initialize(self, rnd): self.target_selector = TargetSelector(rnd) @precondition(lambda self: self.target_selector is not None) @rule(data=st.builds(FakeConjectureData, st.frozensets(st.integers(0, 10)))) def add_data(self, data): self.target_selector.add(data) self.data.append(data) self.tags.update(data.tags) if self.tag_intersections is None: self.tag_intersections = data.tags else: self.tag_intersections &= data.tags @precondition(lambda self: self.data) @rule() def select_target(self): tag, data = self.target_selector.select() assert self.target_selector.has_tag(tag, data) if self.tags != self.tag_intersections: assert tag != universal @precondition(lambda self: self.data) @rule() def cycle_through_tags(self): seen = set() for _ in hrange((2 * len(self.tags) + 1) * (1 + self.target_selector.mutation_counts)): _, data = self.target_selector.select() seen.update(data.tags) if seen == self.tags: break else: assert False
def test_can_use_recursive_data_in_sets(rnd): nested_sets = st.recursive(st.booleans(), lambda js: st.frozensets(js), max_leaves=10) nested_sets.example() def flatten(x): if isinstance(x, bool): return frozenset((x, )) else: result = frozenset() for t in x: result |= flatten(t) if len(result) == 2: break return result x = find(nested_sets, lambda x: len(flatten(x)) == 2, random=rnd, settings=Settings(database=None)) assert x == frozenset((False, True))
def signal_arg_strategy(*, min_children=0, max_children=None, dbus_signature_args=None): """ Build a strategy to generate data for an introspection arg for signals. :param min_children: the minimum number of child elements :type min_children: non-negative int :param max_children: the maximum number of child elements :type max_children: non-negative int or None :param dbus_signature_args: to override dbus_signatures defaults :type dbus_signature_args: dict of str * object or NoneType """ return builds( Arg, fixed_dictionaries( { "name": _TEXT_STRATEGY, "type": dbus_signatures( **({} if dbus_signature_args is None else dbus_signature_args) ), } ), frozensets(annotation_strategy(), min_size=min_children, max_size=max_children), )
import pytest from flaky import flaky from hypothesis import find, given, settings from hypothesis.strategies import sets, text, lists, builds, tuples, \ booleans, integers, frozensets, dictionaries, fixed_dictionaries from hypothesis.internal.debug import minimal from hypothesis.internal.compat import OrderedDict @pytest.mark.parametrize((u'col', u'strat'), [ ((), tuples()), ([], lists(max_size=0)), (set(), sets(max_size=0)), (frozenset(), frozensets(max_size=0)), ({}, fixed_dictionaries({})), ]) def test_find_empty_collection_gives_empty(col, strat): assert find(strat, lambda x: True) == col @pytest.mark.parametrize((u'coltype', u'strat'), [ (list, lists), (set, sets), (frozenset, frozensets), ]) def test_find_non_empty_collection_gives_single_zero(coltype, strat): assert find( strat(integers()), bool ) == coltype((0,))
class DataStoreIncidentTests(DataStoreTests): """ Tests for :class:`DataStore` incident access. """ @given(incidentLists(maxNumber=SQLITE_MAX_INT, averageSize=3, maxSize=10)) @settings(max_examples=100) def test_incidents(self, incidents: Iterable[Incident]) -> None: """ :meth:`DataStore.incidents` returns all incidents. """ incidents = tuple(incidents) events: Dict[Event, Dict[int, Incident]] = defaultdict(defaultdict) store = self.store() for incident in incidents: assume(incident.number not in events[incident.event]) self.storeIncident(store, incident) events[incident.event][incident.number] = incident found: Set[Tuple[Event, int]] = set() for event in events: for retrieved in self.successResultOf(store.incidents(event)): self.assertIncidentsEqual(retrieved, events[event][retrieved.number]) found.add((event, retrieved.number)) self.assertEqual(found, set(((i.event, i.number) for i in incidents))) @given( incidentLists( event=anEvent, maxNumber=SQLITE_MAX_INT, minSize=2, averageSize=3, ), ) @settings(max_examples=100) def test_incidents_sameEvent(self, incidents: Iterable[Incident]) -> None: """ :meth:`DataStore.incidents` returns all incidents. """ incidents = frozenset(incidents) store = self.store() event: Optional[Event] = None for incident in incidents: event = incident.event self.storeIncident(store, incident) assert event is not None retrieved = self.successResultOf(store.incidents(event)) for r, i in zip(sorted(retrieved), sorted(incidents)): self.assertIncidentsEqual(r, i) def test_incidents_error(self) -> None: """ :meth:`DataStore.incidents` raises :exc:`StorageError` when SQLite raises an exception. """ store = self.store() self.successResultOf(store.createEvent(anEvent)) store.bringThePain() f = self.failureResultOf(store.incidents(anEvent)) self.assertEqual(f.type, StorageError) @given(incidents(maxNumber=SQLITE_MAX_INT)) @settings(max_examples=200) def test_incidentWithNumber(self, incident: Incident) -> None: """ :meth:`DataStore.incidentWithNumber` returns the specified incident. """ store = self.store() self.storeIncident(store, incident) retrieved = self.successResultOf( store.incidentWithNumber(incident.event, incident.number)) self.assertIncidentsEqual(retrieved, incident) def test_incidentWithNumber_notFound(self) -> None: """ :meth:`DataStore.incidentWithNumber` raises :exc:`NoSuchIncidentError` when the given incident number is not found. """ store = self.store() self.successResultOf(store.createEvent(anEvent)) f = self.failureResultOf(store.incidentWithNumber(anEvent, 1)) self.assertEqual(f.type, NoSuchIncidentError) def test_incidentWithNumber_tooBig(self) -> None: """ :meth:`DataStore.incidentWithNumber` raises :exc:`NoSuchIncidentError` when the given incident number is too large for SQLite. """ store = self.store() self.successResultOf(store.createEvent(anEvent)) f = self.failureResultOf( store.incidentWithNumber(anEvent, SQLITE_MAX_INT + 1)) f.printTraceback() self.assertEqual(f.type, NoSuchIncidentError) def test_incidentWithNumber_error(self) -> None: """ :meth:`DataStore.incidentWithNumber` raises :exc:`StorageError` when SQLite raises an exception. """ store = self.store() self.successResultOf(store.createEvent(anEvent)) store.bringThePain() f = self.failureResultOf(store.incidentWithNumber(anEvent, 1)) self.assertEqual(f.type, StorageError) @given(lists(tuples(incidents(new=True), rangerHandles()), average_size=2)) @settings(max_examples=200) def test_createIncident(self, data: Iterable[Tuple[Incident, str]]) -> None: """ :meth:`DataStore.createIncident` creates the given incident. """ store = self.store() createdEvents: Set[Event] = set() createdIncidentTypes: Set[str] = set() createdConcentricStreets: Dict[Event, Set[str]] = defaultdict(set) expectedStoredIncidents: Set[Incident] = set() nextNumbers: Dict[Event, int] = {} for incident, author in data: event = incident.event if event not in createdEvents: self.successResultOf(store.createEvent(event)) createdEvents.add(event) for incidentType in incident.incidentTypes: if incidentType not in createdIncidentTypes: self.successResultOf( store.createIncidentType(incidentType)) createdIncidentTypes.add(incidentType) address = incident.location.address if isinstance(address, RodGarettAddress): concentric = address.concentric if (concentric is not None and concentric not in createdConcentricStreets[event]): self.successResultOf( store.createConcentricStreet(event, concentric, "Sesame Street")) createdConcentricStreets[event].add(concentric) retrieved = self.successResultOf( store.createIncident(incident=incident, author=author)) # The returned incident should be the same, except for modified # number expectedStoredIncident = incident.replace( number=nextNumbers.setdefault(event, 1)) self.assertIncidentsEqual(retrieved, expectedStoredIncident, ignoreAutomatic=True) # Add to set of stored incidents expectedStoredIncidents.add(expectedStoredIncident) nextNumbers[event] += 1 # Stored incidents should be contain incidents stored above for event in createdEvents: expectedIncidents = sorted(i for i in expectedStoredIncidents if i.event == event) storedIncidents = sorted( self.successResultOf(store.incidents(event=event))) self.assertEqual(len(storedIncidents), len(expectedIncidents), f"{storedIncidents} != {expectedIncidents}") for stored, expected in zip(storedIncidents, expectedIncidents): self.assertIncidentsEqual(stored, expected, ignoreAutomatic=True) def test_createIncident_error(self) -> None: """ :meth:`DataStore.createIncident` raises :exc:`StorageError` when SQLite raises an exception. """ store = self.store() self.successResultOf(store.createEvent(anIncident.event)) store.bringThePain() f = self.failureResultOf(store.createIncident(anIncident, "Hubcap")) self.assertEqual(f.type, StorageError) def test_setIncident_priority_error(self) -> None: """ :meth:`DataStore.setIncident_priority` raises :exc:`StorageError` when SQLite raises an exception. """ store = self.store() self.successResultOf(store.createEvent(anIncident.event)) incident = self.successResultOf( store.createIncident(anIncident, "Hubcap")) store.bringThePain() f = self.failureResultOf( store.setIncident_priority( incident.event, incident.number, IncidentPriority.high, "Bucket", )) self.assertEqual(f.type, StorageError) def _test_setIncidentAttribute(self, incident: Incident, methodName: str, attributeName: str, value: Any) -> None: store = self.store() self.storeIncident(store, incident) setter = getattr(store, methodName) # For concentric streets, we need to make sure they exist first. if attributeName == "location.address.concentric": storeConcentricStreet( store._db, incident.event, value, "Concentric Street", ignoreDuplicates=True, ) # For incident types, we need to make sure they exist first. if attributeName == "incidentTypes": for incidentType in (frozenset(value) - frozenset(incident.incidentTypes)): self.successResultOf(store.createIncidentType(incidentType)) self.successResultOf( setter(incident.event, incident.number, value, "Hubcap")) retrieved = self.successResultOf( store.incidentWithNumber(incident.event, incident.number)) # Normalize location if we're updating the address. # Don't normalize before calling the setter; we want to test that # giving it un-normalized data works. if attributeName.startswith("location.address."): incident = normalizeAddress(incident) # Replace the specified incident attribute with the given value. # This is a bit complex because we're recursing into sub-attributes. attrPath = attributeName.split(".") values = [incident] for a in attrPath[:-1]: values.append(getattr(values[-1], a)) values.append(value) for a in reversed(attrPath): v = values.pop() values[-1] = values[-1].replace(**{a: v}) incident = values[0] self.assertIncidentsEqual(retrieved, incident, ignoreAutomatic=True) @given(incidents(new=True), incidentPriorities()) @settings(max_examples=200) def test_setIncident_priority(self, incident: Incident, priority: IncidentPriority) -> None: """ :meth:`DataStore.setIncident_priority` updates the priority for the given incident in the data store. """ self._test_setIncidentAttribute(incident, "setIncident_priority", "priority", priority) @given(incidents(new=True), incidentStates()) @settings(max_examples=200) def test_setIncident_state(self, incident: Incident, state: IncidentState) -> None: """ :meth:`DataStore.setIncident_state` updates the state for the incident with the given number in the data store. """ self._test_setIncidentAttribute(incident, "setIncident_state", "state", state) @given(incidents(new=True), incidentSummaries()) @settings(max_examples=200) def test_setIncident_summary(self, incident: Incident, summary: str) -> None: """ :meth:`DataStore.setIncident_summary` updates the summary for the given incident in the data store. """ self._test_setIncidentAttribute(incident, "setIncident_summary", "summary", summary) @given(incidents(new=True), locationNames()) @settings(max_examples=200) def test_setIncident_locationName(self, incident: Incident, name: str) -> None: """ :meth:`DataStore.setIncident_locationName` updates the location name for the given incident in the data store. """ self._test_setIncidentAttribute(incident, "setIncident_locationName", "location.name", name) @given(incidents(new=True), concentricStreetIDs()) @settings(max_examples=200) def test_setIncident_locationConcentricStreet(self, incident: Incident, streetID: str) -> None: """ :meth:`DataStore.setIncident_locationConcentricStreet` updates the location concentric street for the given incident in the data store. """ self._test_setIncidentAttribute( incident, "setIncident_locationConcentricStreet", "location.address.concentric", streetID, ) @given(incidents(new=True), radialHours()) @settings(max_examples=200) def test_setIncident_locationRadialHour(self, incident: Incident, radialHour: int) -> None: """ :meth:`DataStore.setIncident_locationRadialHour` updates the location radial hour for the given incident in the data store. """ self._test_setIncidentAttribute( incident, "setIncident_locationRadialHour", "location.address.radialHour", radialHour, ) @given(incidents(new=True), radialMinutes()) @settings(max_examples=200) def test_setIncident_locationRadialMinute(self, incident: Incident, radialMinute: int) -> None: """ :meth:`DataStore.setIncident_locationRadialMinute` updates the location radial minute for the given incident in the data store. """ self._test_setIncidentAttribute( incident, "setIncident_locationRadialMinute", "location.address.radialMinute", radialMinute, ) @given(incidents(new=True), text()) @settings(max_examples=200) def test_setIncident_locationDescription(self, incident: Incident, description: str) -> None: """ :meth:`DataStore.setIncident_locationDescription` updates the location description for the given incident in the data store. """ self._test_setIncidentAttribute( incident, "setIncident_locationDescription", "location.address.description", description, ) @given(incidents(new=True), lists(rangerHandles(), average_size=2)) @settings(max_examples=200) def test_setIncident_rangers(self, incident: Incident, rangerHandles: Iterable[str]) -> None: """ :meth:`DataStore.setIncident_rangers` updates the ranger handles for the given incident in the data store. """ self._test_setIncidentAttribute( incident, "setIncident_rangers", "rangerHandles", rangerHandles, ) def test_setIncident_rangers_error(self) -> None: """ :meth:`DataStore.setIncident_rangers` raises :exc:`StorageError` when SQLite raises an exception. """ store = self.store() self.successResultOf(store.createEvent(anIncident.event)) incident = self.successResultOf( store.createIncident(anIncident, "Hubcap")) store.bringThePain() f = self.failureResultOf( store.setIncident_rangers(incident.event, incident.number, ("Hubcap", "Dingle"), "Bucket")) self.assertEqual(f.type, StorageError) @given(incidents(new=True), lists(incidentTypesText(), average_size=2)) @settings(max_examples=200) def test_setIncident_incidentTypes(self, incident: Incident, incidentTypes: Iterable[str]) -> None: """ :meth:`DataStore.setIncident_rangers` updates the ranger handles for the given incident in the data store. """ self._test_setIncidentAttribute( incident, "setIncident_incidentTypes", "incidentTypes", incidentTypes, ) def test_setIncident_incidentTypes_error(self) -> None: """ :meth:`DataStore.setIncident_incidentTypes` raises :exc:`StorageError` when SQLite raises an exception. """ store = self.store() self.successResultOf(store.createEvent(anEvent)) incident = self.successResultOf( store.createIncident(anIncident, "Hubcap")) store.bringThePain() f = self.failureResultOf( store.setIncident_incidentTypes(anEvent, incident.number, ("Fun", "Boring"), "Bucket")) self.assertEqual(f.type, StorageError) @given( incidents(new=True), frozensets(reportEntries(automatic=False), average_size=2), rangerHandles(), ) @settings(max_examples=200) def test_addReportEntriesToIncident(self, incident: Incident, reportEntries: FrozenSet[ReportEntry], author: str) -> None: """ :meth:`DataStore.addReportEntriesToIncident` adds the given report entries to the given incident in the data store. """ # Change author in report entries to match the author so we will use to # add them reportEntries = frozenset( r.replace(author=author) for r in reportEntries) # Store test data store = self.store() self.successResultOf(store.createEvent(incident.event)) self.storeIncident(store, incident) # Fetch incident back so we have the version from the DB incident = self.successResultOf( store.incidentWithNumber(incident.event, incident.number)) originalEntries = frozenset(incident.reportEntries) # Add report entries self.successResultOf( store.addReportEntriesToIncident(incident.event, incident.number, reportEntries, author)) # Get the updated incident with the new report entries updated = self.successResultOf( store.incidentWithNumber(incident.event, incident.number)) updatedEntries = frozenset(updated.reportEntries) # Updated entries minus the original entries == the added entries updatedNewEntries = updatedEntries - originalEntries self.assertTrue( reportEntriesEqualish(sorted(updatedNewEntries), sorted(reportEntries))) def test_addReportEntriesToIncident_automatic(self) -> None: """ :meth:`DataStore.addReportEntriesToIncident` raises :exc:`ValueError` when given automatic report entries. """ store = self.store() self.successResultOf(store.createEvent(anIncident.event)) incident = self.successResultOf( store.createIncident(anIncident, "Hubcap")) reportEntry = aReportEntry.replace(automatic=True) f = self.failureResultOf( store.addReportEntriesToIncident( incident.event, incident.number, (reportEntry, ), reportEntry.author, )) self.assertEqual(f.type, ValueError) self.assertIn(" may not be created by user ", f.getErrorMessage()) def test_addReportEntriesToIncident_wrongAuthor(self) -> None: """ :meth:`DataStore.addReportEntriesToIncident` raises :exc:`ValueError` when given report entries with an author that does not match the author that is adding the entries. """ store = self.store() self.successResultOf(store.createEvent(anIncident.event)) incident = self.successResultOf( store.createIncident(anIncident, "Hubcap")) otherAuthor = f"not{aReportEntry.author}" f = self.failureResultOf( store.addReportEntriesToIncident(incident.event, incident.number, (aReportEntry, ), otherAuthor)) self.assertEqual(f.type, ValueError) self.assertEndsWith( f.getErrorMessage(), f" has author != {otherAuthor}", ) def test_addReportEntriesToIncident_error(self) -> None: """ :meth:`DataStore.addReportEntriesToIncident` raises :exc:`StorageError` when SQLite raises an exception. """ store = self.store() self.successResultOf(store.createEvent(anIncident.event)) incident = self.successResultOf( store.createIncident(anIncident, "Hubcap")) store.bringThePain() f = self.failureResultOf( store.addReportEntriesToIncident( incident.event, incident.number, (aReportEntry, ), aReportEntry.author, )) self.assertEqual(f.type, StorageError) def assertIncidentsEqual( self, incidentA: Incident, incidentB: Incident, ignoreAutomatic: bool = False, ) -> None: if incidentA != incidentB: messages = [] for attribute in attrFields(Incident): name = attribute.name valueA = getattr(incidentA, name) valueB = getattr(incidentB, name) if name == "created": if dateTimesEqualish(valueA, valueB): continue else: messages.append(f"{name} delta: {valueA - valueB}") elif name == "reportEntries": if reportEntriesEqualish(valueA, valueB, ignoreAutomatic): continue if valueA != valueB: messages.append(f"{name} {valueA!r} != {valueB!r}") if messages: self.fail("Incidents do not match:\n" + "\n".join(messages))
TestTemplates = strategy_test_suite(templates_for(sets(integers()))) TestEmptyString = strategy_test_suite(text(alphabet='')) TestSingleString = strategy_test_suite( strategy(text(alphabet='a'), Settings(average_list_length=10.0))) TestManyString = strategy_test_suite(text(alphabet='abcdef☃')) Stuff = namedtuple('Stuff', ('a', 'b')) TestNamedTuple = strategy_test_suite(builds(Stuff, integers(), integers())) TestTrees = strategy_test_suite( n_ary_tree(integers(), integers(), integers())) TestMixedSets = strategy_test_suite( sets(one_of(integers(), booleans(), floats()))) TestFrozenSets = strategy_test_suite(frozensets(booleans())) TestNestedSets = strategy_test_suite( frozensets(frozensets(complex_numbers(), max_size=2))) TestMisc1 = strategy_test_suite( fixed_dictionaries({(2, -374): frozensets(none())})) TestMisc2 = strategy_test_suite( fixed_dictionaries({b'': frozensets(integers())})) TestMisc3 = strategy_test_suite(tuples(sets(none() | text()))) TestEmptyTuple = strategy_test_suite(tuples()) TestEmptyList = strategy_test_suite(lists(max_size=0)) TestEmptySet = strategy_test_suite(sets(max_size=0)) TestEmptyFrozenSet = strategy_test_suite(frozensets(max_size=0)) TestEmptyDict = strategy_test_suite(fixed_dictionaries({}))
"""A test of the generic_test.built_in_tests using the built-in container types.""" import unittest import collections import types from hypothesis import strategies as st from generic_testing_test_context import generic_testing element_st = st.integers() @generic_testing.Given({ generic_testing.ClassUnderTest: st.frozensets(element_st), generic_testing.ElementT: element_st, }) class Test_frozenset(generic_testing.frozensetTests): pass element_st = st.integers() @generic_testing.Given({ generic_testing.ClassUnderTest: st.sets(element_st), generic_testing.ElementT: element_st, }) class Test_set(generic_testing.setTests):
def extend(base): return st.one_of( st.frozensets(base), st.lists(base).map(tuple), )
def test_can_test_sets_sampled_from(xs): assert all(isinstance(x, int) for x in xs) assert all(0 <= x < 10 for x in xs) mix = one_of(sampled_from([1, 2, 3]), text()) @fails @given(mix, mix) def test_can_mix_sampling_with_generating(x, y): assert type(x) == type(y) @fails @given(frozensets(integers())) def test_can_find_large_sum_frozenset(xs): assert sum(xs) < 100 def test_prints_on_failure_by_default(): @given(integers(), integers()) @settings(max_examples=100) def test_ints_are_sorted(balthazar, evans): assume(evans >= 0) assert balthazar <= evans with raises(AssertionError): with capture_out() as out: with reporting.with_reporter(reporting.default): test_ints_are_sorted()
TestEmptyString = strategy_test_suite(text(alphabet='')) TestSingleString = strategy_test_suite(strategy( text(alphabet='a'), Settings(average_list_length=10.0))) TestManyString = strategy_test_suite(text(alphabet='abcdef☃')) Stuff = namedtuple('Stuff', ('a', 'b')) TestNamedTuple = strategy_test_suite( builds(Stuff, integers(), integers())) TestTrees = strategy_test_suite( n_ary_tree(integers(), integers(), integers())) TestMixedSets = strategy_test_suite(sets( one_of(integers(), booleans(), floats()))) TestFrozenSets = strategy_test_suite(frozensets(booleans())) TestNestedSets = strategy_test_suite( frozensets(frozensets(complex_numbers(), max_size=2))) TestMisc1 = strategy_test_suite(fixed_dictionaries( {(2, -374): frozensets(none())})) TestMisc2 = strategy_test_suite(fixed_dictionaries( {b'': frozensets(integers())})) TestMisc3 = strategy_test_suite(tuples(sets(none() | text()))) TestEmptyTuple = strategy_test_suite(tuples()) TestEmptyList = strategy_test_suite(lists(max_size=0)) TestEmptySet = strategy_test_suite(sets(max_size=0)) TestEmptyFrozenSet = strategy_test_suite(frozensets(max_size=0)) TestEmptyDict = strategy_test_suite(fixed_dictionaries({}))
import pytest from flaky import flaky from hypothesis import find, given, settings from tests.common.debug import minimal from hypothesis.strategies import sets, text, lists, builds, tuples, \ booleans, integers, frozensets, dictionaries, fixed_dictionaries from hypothesis.internal.compat import OrderedDict @pytest.mark.parametrize((u'col', u'strat'), [ ((), tuples()), ([], lists(max_size=0)), (set(), sets(max_size=0)), (frozenset(), frozensets(max_size=0)), ({}, fixed_dictionaries({})), ]) def test_find_empty_collection_gives_empty(col, strat): assert find(strat, lambda x: True) == col @pytest.mark.parametrize((u'coltype', u'strat'), [ (list, lists), (set, sets), (frozenset, frozensets), ]) def test_find_non_empty_collection_gives_single_zero(coltype, strat): assert find(strat(integers()), bool) == coltype((0, ))
def everythings( draw, min_int=None, max_int=None, allow_inf=True, allow_null_bytes_in_keys=True, allow_quotes_in_keys=True, allow_control_characters_in_values=True, min_key_length=0, allow_datetime_microseconds=True, ): key_text = text( characters( blacklist_categories=("Cs", ) if allow_null_bytes_in_keys else ("Cs", "Cc"), blacklist_characters='"' if not allow_quotes_in_keys else None, ), min_size=min_key_length, ) strings = text( characters(blacklist_categories=( "Cs", ) if allow_control_characters_in_values else ("Cs", "Cc")), ) dts = datetimes( min_value=datetime(1900, 1, 1), max_value=datetime(2200, 1, 1), timezones=just(timezone.utc), ) if not allow_datetime_microseconds: dts = dts.map(lambda d: datetime( d.year, d.month, d.day, d.hour, d.minute, d.second, tzinfo=d.tzinfo, )) return Everything( draw(strings), draw(binary()), draw(integers(min_value=min_int, max_value=max_int)), draw(floats(allow_nan=False, allow_infinity=allow_inf)), draw( dictionaries(key_text, integers(min_value=min_int, max_value=max_int))), draw(lists(integers(min_value=min_int, max_value=max_int))), tuple(draw(lists(integers(min_value=min_int, max_value=max_int)))), ( draw(strings), draw(integers(min_value=min_int, max_value=max_int)), draw(floats(allow_nan=False, allow_infinity=allow_inf)), ), Counter( draw( dictionaries(key_text, integers(min_value=min_int, max_value=max_int)))), draw( dictionaries( integers(min_value=min_int, max_value=max_int), floats(allow_nan=False, allow_infinity=allow_inf), )), draw( dictionaries(floats(allow_nan=False, allow_infinity=allow_inf), strings)), draw(lists(floats(allow_nan=False, allow_infinity=allow_inf))), draw(lists(strings)), draw(sets(floats(allow_nan=False, allow_infinity=allow_inf))), draw(sets(integers(min_value=min_int, max_value=max_int))), draw(frozensets(strings)), Everything.AnIntEnum.A, Everything.AStringEnum.A, draw(dts), )
class ListSM(RuleBasedStateMachine): def __init__(self): self._var = ffi.new('struct list*') self._model = deque() self._model_contents = deque() super().__init__() first = alias_property() last = alias_property() def teardown(self): lib.list_clear(self._var) class Iterator(typing.Iterator[None]): cur = alias_property() prev = alias_property() def _make_iter(self, reverse: bool = False) -> ListSM.Iterator: var = ffi.new('struct list_it*') var.cur = self.last if reverse else self.first def it(): while var.cur != ffi.NULL: yield # yield None because we're mutable lib.list_step(var) it = it() class _It(ListSM.Iterator): _var = var def __next__(self) -> None: return next(it) return _It() def __iter__(self) -> ListSM.Iterator: return self._make_iter() def __reversed__(self) -> ListSM.Iterator: return self._make_iter(reverse=True) nodes = Bundle('Nodes') @rule(new_value=elements(), target=nodes) def insert_front(self, new_value): self._model_contents.appendleft(new_value) lib.list_insert_front(self._var, new_value) new_node = self.first assert new_node.value == new_value self._model.appendleft(new_node) return new_node @rule(new_value=elements(), target=nodes) def insert_back(self, new_value): self._model_contents.append(new_value) lib.list_insert_back(self._var, new_value) new_node = self.last assert new_node.value == new_value self._model.append(new_node) return new_node @rule(nodes=strategies.frozensets(consumes(nodes)), reverse=strategies.booleans()) def remove_thru_iter(self, nodes, reverse): it = reversed(self) if reverse else iter(self) for _ in it: if it.cur in nodes: lib.list_remove(self._var, it._var) for n in nodes: i = self._model.index(n) del self._model_contents[i] del self._model[i] @invariant() def nodes_as_model(self): it = iter(self) nodes = [it.cur for _ in it] assert nodes == list(self._model) @invariant() def contents_as_model(self): it = iter(self) contents = [it.cur.value for _ in it] assert contents == list(self._model_contents)
def test_does_not_error_if_min_size_is_bigger_than_default_size(): lists(integers(), min_size=50) sets(integers(), min_size=50) frozensets(integers(), min_size=50) lists(integers(), min_size=50, unique_by=lambda x: x)
def interface_strategy( # pylint: disable=too-many-locals draw, *, min_children=0, max_children=None, min_annotations=0, max_annotations=None, min_methods=0, max_methods=None, min_properties=0, max_properties=None, min_signals=0, max_signals=None, dbus_signature_args=None, ): """ Build a strategy to generate data for an introspection interface. :param min_children: minimum value for component strategies :type min_children: non-negative int :param max_children: maximum value for component strategies :type max_children: non-negative int or None :param min annotations: minimum number of annotations :type max_annotations: non-negative int :param max_annotations: maximum number of annotations :type max_annotations: non-negative int or None :param min methods: minimum number of methods :type max_methods: non-negative int :param max_methods: maximum number of methods :type max_methods: non-negative int or None :param min properties: minimum number of properties :type max_properties: non-negative int :param max_properties: maximum number of properties :type max_properties: non-negative int or None :param min signals: minimum number of signals :type max_signals: non-negative int :param max_signals: maximum number of signals :type max_signals: non-negative int or None :param dbus_signature_args: to override dbus_signatures defaults :type dbus_signature_args: dict of str * object or NoneType """ annotations = draw( frozensets( annotation_strategy(), min_size=min_annotations, max_size=max_annotations ) ) methods = draw( frozensets( method_strategy( # pylint: disable=no-value-for-parameter min_children=min_children, max_children=max_children, min_annotations=min_children, max_annotations=max_children, min_args=min_children, max_args=max_children, dbus_signature_args=dbus_signature_args, ), min_size=min_methods, max_size=max_methods, ) ) properties = draw( frozensets( property_strategy( min_children=min_children, max_children=max_children, dbus_signature_args=dbus_signature_args, ), min_size=min_properties, max_size=max_properties, ) ) signals = draw( frozensets( signal_strategy( # pylint: disable=no-value-for-parameter min_children=min_children, max_children=max_children, min_annotations=min_children, max_annotations=max_children, min_signal_args=min_children, max_signal_args=max_children, dbus_signature_args=dbus_signature_args, ), min_size=min_signals, max_size=max_signals, ) ) attrs = draw(fixed_dictionaries({"name": _TEXT_STRATEGY})) return Interface(attrs, annotations | methods | properties | signals)
TestEmptyString = strategy_test_suite(text(alphabet='')) TestSingleString = strategy_test_suite(strategy( text(alphabet='a'), Settings(average_list_length=10.0))) TestManyString = strategy_test_suite(text(alphabet='abcdef☃')) Stuff = namedtuple('Stuff', ('a', 'b')) TestNamedTuple = strategy_test_suite( builds(Stuff, integers(), integers())) TestTrees = strategy_test_suite( n_ary_tree(integers(), integers(), integers())) TestMixedSets = strategy_test_suite(sets( one_of(integers(), booleans(), floats()))) TestFrozenSets = strategy_test_suite(frozensets(booleans())) TestNestedSets = strategy_test_suite( frozensets(frozensets(integers(), max_size=2))) TestMisc1 = strategy_test_suite(fixed_dictionaries( {(2, -374): frozensets(none())})) TestMisc2 = strategy_test_suite(fixed_dictionaries( {b'': frozensets(integers())})) TestMisc3 = strategy_test_suite(tuples(sets(none() | text()))) TestEmptyTuple = strategy_test_suite(tuples()) TestEmptyList = strategy_test_suite(lists(max_size=0)) TestEmptySet = strategy_test_suite(sets(max_size=0)) TestEmptyFrozenSet = strategy_test_suite(frozensets(max_size=0)) TestEmptyDict = strategy_test_suite(fixed_dictionaries({}))
class DataStoreEventTests(DataStoreTests): """ Tests for :class:`DataStore` event access. """ def test_events(self, broken: bool = False) -> None: """ :meth:`DataStore.events` returns all events. """ store = self.store() store._db.executescript( dedent(""" insert into EVENT (NAME) values ('Event A'); insert into EVENT (NAME) values ('Event B'); """)) if broken: store.bringThePain() events = frozenset(self.successResultOf(store.events())) self.assertEqual(events, {Event(id="Event A"), Event(id="Event B")}) def test_events_error(self) -> None: """ :meth:`DataStore.events` raises `StorageError` if SQLite raises. """ e = self.assertRaises(StorageError, self.test_events, broken=True) self.assertEqual(str(e), TestDataStore.brokenErrorMessage) @given(events()) def test_createEvent(self, event: Event) -> None: """ :meth:`DataStore.createEvent` creates the given event. """ store = self.store() self.successResultOf(store.createEvent(event)) stored = frozenset(self.successResultOf(store.events())) self.assertEqual(stored, frozenset((event, ))) def test_createEvent_error(self) -> None: """ :meth:`DataStore.createEvent` raises `StorageError` if SQLite raises. """ store = self.store() store.bringThePain() f = self.failureResultOf(store.createEvent(Event(id="x"))) f.printTraceback() self.assertEqual(f.type, StorageError) def test_createEvent_duplicate(self) -> None: """ :meth:`DataStore.createEvent` raises :exc:`StorageError` when given an event that already exists in the data store. """ event = Event(id="foo") store = self.store() self.successResultOf(store.createEvent(event)) f = self.failureResultOf(store.createEvent(event)) self.assertEqual(f.type, StorageError) @given(events(), frozensets(text())) def test_setReaders(self, event: Event, readers: Iterable[str]) -> None: """ :meth:`DataStore.setReaders` sets the read ACL for an event. """ store = self.store() self.successResultOf(store.createEvent(event)) self.successResultOf(store.setReaders(event, readers)) result = frozenset(self.successResultOf(store.readers(event))) self.assertEqual(result, readers) def test_setReaders_error(self) -> None: """ :meth:`DataStore.setReaders` raises :exc:`StorageError` when SQLite raises an exception. """ event = Event(id="foo") store = self.store() self.successResultOf(store.createEvent(event)) store.bringThePain() f = self.failureResultOf(store.setReaders(event, ())) self.assertEqual(f.type, StorageError) @given(events(), frozensets(text())) def test_setWriters(self, event: Event, writers: Iterable[str]) -> None: """ :meth:`DataStore.setWriters` sets the write ACL for an event. """ store = self.store() self.successResultOf(store.createEvent(event)) self.successResultOf(store.setWriters(event, writers)) result = frozenset(self.successResultOf(store.writers(event))) self.assertEqual(result, writers) def test_setWriters_error(self) -> None: """ :meth:`DataStore.setWriters` raises :exc:`StorageError` when SQLite raises an exception. """ event = Event(id="foo") store = self.store() self.successResultOf(store.createEvent(event)) store.bringThePain() f = self.failureResultOf(store.setWriters(event, ())) self.assertEqual(f.type, StorageError)
def test_can_clone_same_length_items(): ls = find( lists(frozensets(integers(), min_size=10, max_size=10)), lambda x: len(x) >= 20 ) assert len(set(ls)) == 1
def eq_nan(a, b): return a == b or both_nan(a, b) mutating_methods_by_arity = { 0: (bidict.clear, bidict.popitem, orderedbidict.popitem,), 1: (bidict.__delitem__, bidict.pop, bidict.setdefault, orderedbidict.move_to_end,), 2: (bidict.__setitem__, bidict.pop, bidict.put, bidict.forceput, bidict.setdefault,), -1: (bidict.update, bidict.forceupdate,), } immu_atom = none() | booleans() | integers() | floats() | text() | binary() immutable = recursive(immu_atom, lambda e: frozensets(e) | lists(e).map(tuple)) d = dictionaries(immutable, immutable).map(prune_dup_vals) @given(d) def test_len(d): b = bidict(d) assert len(b) == len(b.inv) == len(d) @given(d) def test_bidirectional_mappings(d): b = bidict(d) for k, v in b.items(): assert eq_nan(k, b.inv[v])
def eq_nan(a, b): return a == b or both_nan(a, b) mutating_methods_by_arity = { 0: (bidict.clear, bidict.popitem, orderedbidict.popitem,), 1: (bidict.__delitem__, bidict.pop, bidict.setdefault, orderedbidict.move_to_end,), 2: (bidict.__setitem__, bidict.pop, bidict.put, bidict.forceput, bidict.setdefault,), -1: (bidict.update, bidict.forceupdate,), } # otherwise data gen. in hypothesis>=1.19 is so slow the health checks fail: kw = dict(average_size=2) immu_atom = none() | booleans() | integers() | floats() | text(**kw) | binary(**kw) immu_coll = lambda e: frozensets(e, **kw) | lists(e, **kw).map(tuple) immutable = recursive(immu_atom, immu_coll) d = dictionaries(immutable, immutable, average_size=5).map(prune_dup_vals) @given(d) def test_len(d): b = bidict(d) assert len(b) == len(b.inv) == len(d) @given(d) def test_bidirectional_mappings(d): b = bidict(d) for k, v in b.items(): assert eq_nan(k, b.inv[v])
def test_does_not_error_if_min_size_is_bigger_than_default_size(): lists(integers(), min_size=50).example() sets(integers(), min_size=50).example() frozensets(integers(), min_size=50).example() lists(integers(), min_size=50, unique=True).example()
) EvalledIntStream = streaming(integers()).map(lambda x: list(x[:10]) and x) ABC = namedtuple('ABC', ('a', 'b', 'c')) def abc(x, y, z): return builds(ABC, x, y, z) with Settings(average_list_length=10.0): standard_types = [ basic(Bitfields), EvalledIntStream, lists(max_size=0), tuples(), sets(max_size=0), frozensets(max_size=0), fixed_dictionaries({}), n_ary_tree(booleans(), booleans(), booleans()), n_ary_tree(integers(), integers(), integers()), abc(booleans(), booleans(), booleans()), abc(booleans(), booleans(), integers()), templates_for(one_of(*map(just, hrange(10)))), fixed_dictionaries({'a': integers(), 'b': booleans()}), dictionaries(booleans(), integers()), dictionaries(text(), booleans()), one_of(integers(), tuples(booleans())), sampled_from(range(10)), one_of(just('a'), just('b'), just('c')), sampled_from(('a', 'b', 'c')), integers(), integers(min_value=3),
from __future__ import division, print_function, absolute_import, \ unicode_literals import hashlib from random import Random import pytest import hypothesis.strategies as s from hypothesis.utils.size import clamp from hypothesis.internal.compat import hrange finite = [ s.booleans(), s.sets(s.booleans()), s.integers(-10, 10), s.integers(0, 10) | s.integers(0, 1), s.tuples(s.booleans(), s.booleans()), s.frozensets(s.booleans()), s.sets(s.integers(0, 3)), ] @pytest.mark.parametrize('strat', finite, ids=list(map(repr, finite))) def test_covers_entire_finite_space(strat): assert strat.template_upper_bound <= 100 random = Random(hashlib.md5( (repr(strat) + ':test_covers_entire_finite_space').encode('utf-8') ).digest()) s = set() for _ in hrange(2000): s.add(strat.draw_and_produce(random))
def test_can_test_sets_sampled_from(xs): assert all(isinstance(x, int) for x in xs) assert all(0 <= x < 10 for x in xs) mix = one_of(sampled_from([1, 2, 3]), text()) @fails @given(mix, mix) def test_can_mix_sampling_with_generating(x, y): assert type(x) == type(y) @fails @given(frozensets(integers())) def test_can_find_large_sum_frozenset(xs): assert sum(xs) < 100 def test_prints_on_failure_by_default(): @given(integers(), integers(), settings=Settings( max_examples=200, timeout=-1 )) def test_ints_are_sorted(balthazar, evans): assume(evans >= 0) assert balthazar <= evans with raises(AssertionError): with capture_out() as out: with reporting.with_reporter(reporting.default): test_ints_are_sorted()
TestComplex = strategy_test_suite(complex_numbers()) TestJust = strategy_test_suite(just(u'hi')) TestTemplates = strategy_test_suite(templates_for(sets(integers()))) TestEmptyString = strategy_test_suite(text(alphabet=u'')) TestSingleString = strategy_test_suite( text(alphabet=u'a', average_size=10.0)) TestManyString = strategy_test_suite(text(alphabet=u'abcdef☃')) Stuff = namedtuple(u'Stuff', (u'a', u'b')) TestNamedTuple = strategy_test_suite( builds(Stuff, integers(), integers())) TestMixedSets = strategy_test_suite(sets( one_of(integers(), booleans(), floats()))) TestFrozenSets = strategy_test_suite(frozensets(booleans())) TestNestedSets = strategy_test_suite( frozensets(frozensets(integers(), max_size=2))) TestMisc1 = strategy_test_suite(fixed_dictionaries( {(2, -374): frozensets(none())})) TestMisc2 = strategy_test_suite(fixed_dictionaries( {b'': frozensets(integers())})) TestMisc3 = strategy_test_suite(tuples(sets(none() | text()))) TestEmptyTuple = strategy_test_suite(tuples()) TestEmptyList = strategy_test_suite(lists(max_size=0)) TestEmptySet = strategy_test_suite(sets(max_size=0)) TestEmptyFrozenSet = strategy_test_suite(frozensets(max_size=0)) TestEmptyDict = strategy_test_suite(fixed_dictionaries({}))
def extend(base): return st.one_of( st.frozensets(base, average_size=10, max_size=50), st.lists(base, average_size=10, max_size=50).map(tuple), )
def resolve_FrozenSet(thing): return st.frozensets(st.from_type(thing.__args__[0]))
return strat.flatmap(lambda v: lists(just(v), average_size=10), ) ABC = namedtuple('ABC', ('a', 'b', 'c')) def abc(x, y, z): return builds(ABC, x, y, z) with settings(strict=False): standard_types = [ lists(max_size=0), tuples(), sets(max_size=0), frozensets(max_size=0), fixed_dictionaries({}), abc(booleans(), booleans(), booleans()), abc(booleans(), booleans(), integers()), fixed_dictionaries({ 'a': integers(), 'b': booleans() }), dictionaries(booleans(), integers()), dictionaries(text(), booleans()), one_of(integers(), tuples(booleans())), sampled_from(range(10)), one_of(just('a'), just('b'), just('c')), sampled_from(('a', 'b', 'c')), integers(), integers(min_value=3),
ABC = namedtuple(u"ABC", (u"a", u"b", u"c")) def abc(x, y, z): return builds(ABC, x, y, z) with Settings(average_list_length=10.0): standard_types = [ basic(Bitfields), EvalledIntStream, lists(max_size=0), tuples(), sets(max_size=0), frozensets(max_size=0), fixed_dictionaries({}), n_ary_tree(booleans(), booleans(), booleans()), n_ary_tree(integers(), integers(), integers()), abc(booleans(), booleans(), booleans()), abc(booleans(), booleans(), integers()), templates_for(one_of(*map(just, hrange(10)))), fixed_dictionaries({u"a": integers(), u"b": booleans()}), dictionaries(booleans(), integers()), dictionaries(text(), booleans()), one_of(integers(), tuples(booleans())), sampled_from(range(10)), one_of(just(u"a"), just(u"b"), just(u"c")), sampled_from((u"a", u"b", u"c")), integers(), integers(min_value=3),
(binary(), frozenset()), (fixed_dictionaries({True: sets(integers())}), []), (randoms(), []), (integers(), ''), (integers(), [0, '']), (text(), 'kittens'), (tuples(integers(), integers(), integers()), (1, 2)), (sampled_from((1, 2, 3)), 'fish'), (sampled_from((1, 2, 3)), 5), (sampled_from((1, 2, 3)), -2), (one_of(integers(), floats()), 1), (one_of(integers(), floats()), 'tv'), (one_of(integers(), floats()), [-2, 0]), (binary(), '1'), (floats(), -1), (lists(one_of(frozensets(floats()), frozensets(floats()))), [[8, 0], []]), (floats(), 252010555201342071294067021251680995120), (tuples(integers(), integers()), 10), (n_ary_tree(integers(), integers(), integers()), []), (n_ary_tree(integers(), integers(), integers()), [1, 2, 3, 4, 5]), (floats(1, 2), (0, floats().to_basic(float('nan')))), (floats(1, 2), floats().to_basic(float('nan'))), (floats(1), [0, floats().to_basic(float('nan'))]), (floats(1), [0, floats().to_basic(0.0)]), (floats(max_value=1), [0, floats().to_basic(float('nan'))]), (floats(max_value=1), [0, floats().to_basic(2.0)]), ]) def test_simple_data_validation(specifier, data): converter = strategy(specifier) with pytest.raises(BadData): converter.from_basic(data)
from random import Random import pytest from hypothesis import given, settings from tests.common.debug import minimal, find_any from hypothesis.strategies import none, sets, text, lists, tuples, \ booleans, integers, frozensets, dictionaries, fixed_dictionaries from hypothesis.internal.compat import OrderedDict @pytest.mark.parametrize((u'col', u'strat'), [ ((), tuples()), ([], lists(none(), max_size=0)), (set(), sets(none(), max_size=0)), (frozenset(), frozensets(none(), max_size=0)), ({}, fixed_dictionaries({})), ]) def test_find_empty_collection_gives_empty(col, strat): assert minimal(strat, lambda x: True) == col @pytest.mark.parametrize((u'coltype', u'strat'), [ (list, lists), (set, sets), (frozenset, frozensets), ]) def test_find_non_empty_collection_gives_single_zero(coltype, strat): assert minimal( strat(integers()), bool ) == coltype((0,))
BinaryString = strategy_test_suite(binary()) TestIntBool = strategy_test_suite(tuples(integers(), booleans())) TestFloats = strategy_test_suite(floats()) TestComplex = strategy_test_suite(complex_numbers()) TestJust = strategy_test_suite(just(u'hi')) TestEmptyString = strategy_test_suite(text(alphabet=u'')) TestSingleString = strategy_test_suite(text(alphabet=u'a', average_size=10.0)) TestManyString = strategy_test_suite(text(alphabet=u'abcdef☃')) Stuff = namedtuple(u'Stuff', (u'a', u'b')) TestNamedTuple = strategy_test_suite(builds(Stuff, integers(), integers())) TestMixedSets = strategy_test_suite( sets(one_of(integers(), booleans(), floats()))) TestFrozenSets = strategy_test_suite(frozensets(booleans())) TestNestedSets = strategy_test_suite( frozensets(frozensets(integers(), max_size=2))) TestMisc1 = strategy_test_suite( fixed_dictionaries({(2, -374): frozensets(none())})) TestMisc2 = strategy_test_suite( fixed_dictionaries({b'': frozensets(integers())})) TestMisc3 = strategy_test_suite(tuples(sets(none() | text()))) TestEmptyTuple = strategy_test_suite(tuples()) TestEmptyList = strategy_test_suite(lists(max_size=0)) TestEmptySet = strategy_test_suite(sets(max_size=0)) TestEmptyFrozenSet = strategy_test_suite(frozensets(max_size=0)) TestEmptyDict = strategy_test_suite(fixed_dictionaries({}))
def create_generic_type(generic_types, param_type): """Create a strategy for generating parameterized generic types.""" return one_of( generic_types, generic_types.map(lambda t: t[Any]), generic_types.map(lambda t: t[param_type]), ) mut_sets_of_primitives = primitive_strategies.flatmap( lambda e: tuples(sets(e[0]), create_generic_type(mut_set_types, e[1]))) frozen_sets_of_primitives = primitive_strategies.flatmap(lambda e: tuples( frozensets(e[0]), create_generic_type(just(FrozenSet), e[1]))) sets_of_primitives = one_of(mut_sets_of_primitives, frozen_sets_of_primitives) @given(primitives_and_type) def test_structuring_primitives(converter, primitive_and_type): # type: (Converter, Any) -> None """Test just structuring a primitive value.""" val, t = primitive_and_type assert converter.structure(val, t) == val assert converter.structure(val, Any) == val @given(seqs_of_primitives) def test_structuring_seqs(seq_and_type):
sets, text, tuples, ) from tests.common.debug import find_any, minimal from tests.common.utils import flaky @pytest.mark.parametrize( ("col", "strat"), [ ((), tuples()), ([], lists(none(), max_size=0)), (set(), sets(none(), max_size=0)), (frozenset(), frozensets(none(), max_size=0)), ({}, fixed_dictionaries({})), ({}, fixed_dictionaries({}, optional={})), (OrderedDict(), fixed_dictionaries(OrderedDict(), optional=OrderedDict())), ({}, fixed_dictionaries({}, optional={1: booleans()})), ({0: False}, fixed_dictionaries({0: booleans()}, optional={1: booleans()})), ({}, fixed_dictionaries({}, optional={(): booleans(), 0: booleans()})), ([], lists(nothing())), ([], lists(nothing(), unique=True)), ], ) def test_find_empty_collection_gives_empty(col, strat): assert minimal(strat, lambda x: True) == col @pytest.mark.parametrize(
TestFloats = strategy_test_suite(floats()) TestComplex = strategy_test_suite(complex_numbers()) TestJust = strategy_test_suite(just("hi")) TestTemplates = strategy_test_suite(templates_for(sets(integers()))) TestEmptyString = strategy_test_suite(text(alphabet="")) TestSingleString = strategy_test_suite(strategy(text(alphabet="a"), Settings(average_list_length=10.0))) TestManyString = strategy_test_suite(text(alphabet="abcdef☃")) Stuff = namedtuple("Stuff", ("a", "b")) TestNamedTuple = strategy_test_suite(builds(Stuff, integers(), integers())) TestTrees = strategy_test_suite(n_ary_tree(integers(), integers(), integers())) TestMixedSets = strategy_test_suite(sets(one_of(integers(), booleans(), floats()))) TestFrozenSets = strategy_test_suite(frozensets(booleans())) TestNestedSets = strategy_test_suite(frozensets(frozensets(integers(), max_size=2))) TestMisc1 = strategy_test_suite(fixed_dictionaries({(2, -374): frozensets(none())})) TestMisc2 = strategy_test_suite(fixed_dictionaries({b"": frozensets(integers())})) TestMisc3 = strategy_test_suite(tuples(sets(none() | text()))) TestEmptyTuple = strategy_test_suite(tuples()) TestEmptyList = strategy_test_suite(lists(max_size=0)) TestEmptySet = strategy_test_suite(sets(max_size=0)) TestEmptyFrozenSet = strategy_test_suite(frozensets(max_size=0)) TestEmptyDict = strategy_test_suite(fixed_dictionaries({})) TestDecimal = strategy_test_suite(decimals()) TestFraction = strategy_test_suite(fractions())