def test_can_falsify_types_without_default_productions():
strategies = StrategyTable()
strategies.define_specification_for(
Bar, lambda s, d: BarStrategy(
s.strategy(descriptors.integers_in_range(0, 100))))
with pytest.raises(MissingSpecification):
StrategyTable.default().strategy(Bar)
verifier = Verifier(strategy_table=strategies)
assert verifier.falsify(
lambda x: False,
Bar,
)[0] == Bar()
assert verifier.falsify(lambda x: x.size() < 3, Bar)[0] == Bar(Bar(Bar()))
def test_can_grow_the_set_of_available_parameters_if_doing_badly():
runs = 10
number_grown = 0
number_grown_large = 0
for _ in hrange(runs):
source = ExampleSource(
random=random.Random(),
strategy=StrategyTable.default().strategy(int),
storage=None,
min_parameters=1,
)
i = 0
for example in source:
if example < 0:
source.mark_bad()
i += 1
if i >= 100:
break
if len(source.parameters) > 1:
number_grown += 1
if len(source.parameters) > 10:
number_grown_large += 1
assert number_grown >= 0.5 * runs
assert number_grown_large <= 0.5 * runs
def test_example_source_needs_random():
with pytest.raises(ValueError):
ExampleSource(
random=None,
strategy=StrategyTable.default().strategy(int),
storage=None,
)
def test_errors_if_you_mark_bad_before_fetching():
storage = None
if hs.default.database is not None:
storage = hs.default.database.storage_for(int)
source = ExampleSource(
random=random.Random(),
strategy=StrategyTable.default().strategy(int),
storage=storage,
)
with pytest.raises(ValueError):
source.mark_bad()
def test_tries_each_parameter_at_least_min_index_times():
source = ExampleSource(random=random.Random(),
strategy=StrategyTable.default().strategy(int),
storage=None,
min_tries=5)
i = 0
for x in source:
i += 1
if i > 500:
break
if i % 2:
source.mark_bad()
# The last index may not have been fully populated
assert all(c >= 5 for c in source.counts[:-1])
def test_negative_is_not_too_far_off_mean():
source = ExampleSource(
random=random.Random(),
strategy=StrategyTable.default().strategy(int),
storage=None,
)
positive = 0
i = 0
for example in source:
if example >= 0:
positive += 1
i += 1
if i >= N_EXAMPLES:
break
assert 0.3 <= float(positive) / N_EXAMPLES <= 0.7
def test_marking_negative_avoids_similar_examples():
source = ExampleSource(
random=random.Random(),
strategy=StrategyTable.default().strategy(int),
storage=None,
)
positive = 0
i = 0
for example in source:
if example >= 0:
positive += 1
else:
source.mark_bad()
i += 1
if i >= N_EXAMPLES:
break
assert float(positive) / N_EXAMPLES >= 0.8
def run_test():
if condition is None:
_condition = lambda x: True
condition_string = ''
else:
_condition = condition
condition_string = strip_lambda(
reflection.get_pretty_function_description(condition))
count = 0
successful_runs = 0
strategy = StrategyTable.default().strategy(descriptor)
for _ in hrange(MAX_RUNS):
pv = strategy.parameter.draw(random)
x = strategy.produce(random, pv)
if not _condition(x):
continue
successful_runs += 1
if predicate(x):
count += 1
if successful_runs < MIN_RUNS:
raise ConditionTooHard(
('Unable to find enough examples satisfying predicate %s '
'only found %d but required at least %d for validity') %
(condition_string, successful_runs, MIN_RUNS))
result = Result(
count,
successful_runs,
q,
predicate,
condition_string,
)
p = cumulative_binomial_probability(successful_runs, q, count)
run_test.test_result = result
# The test passes if we fail to reject the null hypothesis that
# the probability is at least q
if p < REQUIRED_P:
result.failed = True
raise HypothesisFalsified(result.description() + ' rejected')
def test_minimizes_to_empty(desc):
x = falsify(always_false, desc)[0]
s = StrategyTable.default().strategy(desc)
assert not list(s.simplify(x))
def __init__(self, strategy_table=None):
super(ConverterTable, self).__init__()
self.strategy_table = strategy_table or StrategyTable.default()
steps=steps,
init_args=init_args,
init_kwargs=init_kwargs
)
return TestRun(self.descriptor, steps)
def unpack(self, x):
steps = x.steps
if self.requires_init:
return ((x.init_args, x.init_kwargs), steps)
else:
return steps
def simplify(self, x):
pruned = x.prune()
if pruned:
yield pruned
for y in super(StatefulStrategy, self).simplify(x):
yield y
StrategyTable.default().define_specification_for_classes(
define_stateful_strategy,
subclasses_of=StatefulTest
)
ConverterTable.default().define_specification_for_classes(
StatefulConverter,
subclasses_of=StatefulTest
)
class Awkward(str):
pass
ConverterTable.default().mark_not_serializeable(Awkward)
class AwkwardStrategy(SearchStrategy):
descriptor = Awkward
parameter = params.CompositeParameter()
def produce(self, random, pv):
return Awkward()
StrategyTable.default().define_specification_for(
Awkward, lambda s, d: AwkwardStrategy())
def test_can_verify_a_non_serializale_type():
verifier = Verifier(settings=hs.Settings(database=ExampleDatabase()))
verifier.falsify(lambda x: len(x) > 0, Awkward)
def test_verifier_deduplicates_on_coming_out_of_the_database():
db = ExampleDatabase()
storage = db.storage_for((frozenset({int}), ))
db.backend.save(storage.key, '[1, 2, 3]')
db.backend.save(storage.key, '[3, 2, 1]')
counter = Counter()
calls = []
good = frozenset({1, 2, 3})
def load():
StrategyTable.default().define_specification_for(
datetime, lambda s, d: DatetimeStrategy())