test_can_produce_floats_near_right = define_test(
descriptors.floats_in_range(0, 1), 0.1, lambda t: t > 0.8)
test_can_produce_floats_in_middle = define_test(
descriptors.floats_in_range(0, 1), 0.3, lambda t: 0.2 <= t <= 0.8)
test_can_produce_long_lists = define_test([int], 0.5, long_list)
test_can_produce_short_lists = define_test([int], 0.2, lambda x: len(x) <= 10)
test_can_produce_lists_bunched_near_left = define_test(
[descriptors.floats_in_range(0, 1)],
0.1,
lambda ts: all(t < 0.2 for t in ts),
condition=long_list,
)
test_can_produce_lists_bunched_near_right = define_test(
[descriptors.floats_in_range(0, 1)],
0.1,
lambda ts: all(t > 0.8 for t in ts),
condition=long_list,
)
test_can_produce_the_same_int_twice = define_test(
([int], int), 0.05, lambda t: len([x for x in t[0] if x == t[1]]) > 1)
test_non_empty_subset_of_two_is_usually_large = define_test(
{descriptors.sampled_from((1, 2))}, 0.6, lambda t: len(t) == 2)
((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
}),
({float}, {0.0460563451184767, -0.19420794805570227}),
assume(y in xs)
xs.remove(y)
assert y not in xs
def test_errors_even_if_does_not_error_on_final_call():
@given(int)
def rude(x):
assert not any(t[3] == 'falsify'
for t in inspect.getouterframes(inspect.currentframe()))
with pytest.raises(Flaky):
rude()
@given(set([sampled_from(list(range(10)))]))
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]), str))
@fails
@given(mix, mix)
def test_can_mix_sampling_with_generating(x, y):
assert type(x) == type(y)
@fails
all_test_classes = [
A, AA, AAA, AAB, AB, ABA, ABB, B, BA, BAA, BAB, BB, BBA, BBB
]
def find_most_specific(x, classes):
best = None
for c in classes:
if isinstance(x, c):
if best is None or issubclass(c, best):
best = c
return best
@given({sampled_from(all_test_classes)}, random.Random)
def test_chooses_most_specific_subclass(classes, r):
classes = list(classes)
random.shuffle(classes)
classes = tuple(classes)
mapper = SpecificationMapper()
for i in hrange(len(classes)):
mapper.define_specification_for_instances(
classes[i],
const(i),
)
for c in all_test_classes:
if issubclass(c, classes):
x = c()
correct_choice = find_most_specific(x, classes)
i = mapper.specification_for(x)
def test_has_strategy_for_samples():
table = st.StrategyTable.default()
sampling = descriptors.sampled_from([1, 2, 3])
assert table.has_specification_for(sampling)
assert table.has_specification_for([sampling])
assert table.has_specification_for(set([sampling]))