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()
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)
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),
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()
(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 resolve_FrozenSet(thing):
return st.frozensets(st.from_type(thing.__args__[0]))
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())
