def define_list_converter(converters, descriptor):
element_converter = converters.specification_for(one_of(descriptor))
if isinstance(element_converter, GenericConverter):
return GenericConverter(
converters.strategy_table.specification_for(descriptor))
else:
return ListConverter(element_converter)
def __init__(self, strategies):
SearchStrategy.__init__(self)
flattened_strategies = []
for s in strategies:
if isinstance(s, OneOfStrategy):
flattened_strategies += s.element_strategies
else:
flattened_strategies.append(s)
strategies = tuple(flattened_strategies)
if len(strategies) <= 1:
raise ValueError('Need at least 2 strategies to choose amongst')
descriptor = descriptors.one_of(
_unique(s.descriptor for s in strategies))
self.descriptor = descriptor
self.element_strategies = list(strategies)
n = len(self.element_strategies)
self.parameter = params.CompositeParameter(
enabled_children=params.NonEmptySubset(range(n)),
child_parameters=params.CompositeParameter(
e.parameter for e in self.element_strategies))
self.has_immutable_data = all(s.has_immutable_data
for s in self.element_strategies)
def test_one_of_descriptor_distinguishes_sets_and_frozensets():
d = descriptors.one_of(({int}, frozenset({int})))
s = strategy(d)
assert s.descriptor == d
def alternating(*args):
return strategy(descriptors.one_of(args))
def test_one_of_mutable_and_immutable_is_mutable():
assert not strategy(descriptors.one_of([int, [float]])).has_immutable_data
def test_one_of_immutable_is_immutable():
assert strategy(descriptors.one_of([int, text_type, float,
complex])).has_immutable_data
def test_falsifies_sets_of_union_types():
assert falsify(always_false,
{one_of([text_type, binary_type])})[0] == set()
def test_can_falsify_alternating_types():
falsify(lambda x: isinstance(x, int), one_of([int, text_type]))[0] == ''
def test_puts_branches_of_one_of_in_database():
database = ExampleDatabase(backend=SQLiteBackend(':memory:'))
verifier = Verifier(settings=Settings(database=database))
verifier.falsify(lambda x: isinstance(x, bool), one_of((int, bool)))
assert list(database.storage_for(int).fetch()) == [0]
assert list(database.storage_for(bool).fetch()) == []
(AB(int, int), AB(1, 2)),
(int, 1),
((int, ), (1, )),
(complex, complex(1, 1)),
({int}, {1}),
(text_type, ''),
(binary_type, b''),
(Random, RandomWithSeed(1)),
(Just(frozenset({False})), frozenset({False})),
(({str}, bool), (set(), True)),
({
'\x9aLLLL\x1c': {bool}
}, {
'\x9aLLLL\x1c': {False}
}),
(one_of([int, str]), 1),
([[{int}], [[{int}]]], [[[]]]),
(sampled_from(elements=(1, )), 1),
(one_of(({
1: int
}, {
1: bool
})), {
1: 2
}),
(one_of(({
1: int
}, {
1: bool
})), {
1: False
def test_returns_just_a_single_element():
assert descriptors.one_of([1]) == 1
def test_errors_on_empty_one_of():
with pytest.raises(ValueError):
descriptors.one_of([])
def test_slow_failing_test_3(x):
time.sleep(0.05)
assert not calls[2]
calls[2] = 1
@fails
@given(int, verifier=Verifier(settings=timeout_settings))
def test_slow_failing_test_4(x):
time.sleep(0.05)
assert not calls[3]
calls[3] = 1
@fails
@given(one_of([int, str]), one_of([int, str]))
def test_one_of_produces_different_values(x, y):
assert type(x) == type(y)
@given(just(42))
def test_is_the_answer(x):
assert x == 42
@fails
@given(text_type, text_type)
def test_text_addition_is_not_commutative(x, y):
assert x + y == y + x
storage.save(value)
saved = list(storage.fetch())
assert saved == [value]
data_examples = (
(int, 1),
((int,), (1,)),
(complex, complex(1, 1)),
({int}, {1}),
(text_type, ''),
(binary_type, b''),
(Random, RandomWithSeed(1)),
(Just(frozenset({False})), frozenset({False})),
(({str}, bool), (set(), True)),
({'\x9aLLLL\x1c': {bool}}, {'\x9aLLLL\x1c': {False}}),
(one_of([int, str]), 1),
([
[{int}],
[[{int}]]],
[[[]]]),
(sampled_from(elements=(1,)), 1),
(one_of(({1: int}, {1: bool})), {1: 2}),
(one_of(({1: int}, {1: bool})), {1: False}),
)
class InMemoryBackend(Backend):
def __init__(self):
self.data = {}