def test_round_tripping_lists_via_the_database(spec):
random = Random(hashlib.md5(
(show(spec) + ':test_round_tripping_via_the_database').encode('utf-8')
).digest())
strat = lists(spec)
template = some_template(strat, random)
template_via_db = via_database(spec, strat, template)
assert show(strat.reify(template)) == show(strat.reify(template_via_db))
def test_round_tripping_lists_via_the_database(spec):
random = Random(
hashlib.md5((
show(spec) +
':test_round_tripping_via_the_database').encode('utf-8')).digest())
strat = lists(spec)
template = some_template(strat, random)
template_via_db = via_database(spec, strat, template)
assert show(strat.reify(template)) == show(strat.reify(template_via_db))
def test_all_minimal_elements_round_trip_via_the_database(spec):
random = Random(hashlib.md5((
show(spec) + ':test_all_minimal_elements_round_trip_via_the_database'
).encode('utf-8')).digest())
strat = strategy(spec, Settings(average_list_length=2))
for elt in minimal_elements(strat, random):
elt_via_db = via_database(spec, strat, elt)
assert show(strat.reify(elt)) == show(strat.reify(elt_via_db))
elt_via_db_2 = via_database(spec, strat, elt_via_db)
assert elt_via_db == elt_via_db_2
def test_all_minimal_elements_round_trip_via_the_database(spec):
random = Random(
hashlib.md5((show(spec) +
':test_all_minimal_elements_round_trip_via_the_database'
).encode('utf-8')).digest())
strat = strategy(spec, Settings(average_list_length=2))
for elt in minimal_elements(strat, random):
elt_via_db = via_database(spec, strat, elt)
assert show(strat.reify(elt)) == show(strat.reify(elt_via_db))
elt_via_db_2 = via_database(spec, strat, elt_via_db)
assert elt_via_db == elt_via_db_2
def test_round_tripping_via_the_database(spec):
random = Random(
hashlib.md5((show(spec) + u':test_round_tripping_via_the_database'
).encode(u'utf-8')).digest())
strat = spec
template = some_template(strat, random)
strat.from_basic(strat.to_basic(template))
template_via_db = via_database(spec, strat, template)
with BuildContext():
assert show(strat.reify(template)) == show(
strat.reify(template_via_db))
def test_all_minimal_elements_round_trip_via_the_database(spec):
random = Random(hashlib.md5((
show(spec) + u':test_all_minimal_elements_round_trip_via_the_database'
).encode(u'utf-8')).digest())
strat = spec
for elt in minimal_elements(strat, random):
elt_via_db = via_database(spec, strat, elt)
with BuildContext():
assert show(strat.reify(elt)) == show(strat.reify(elt_via_db))
elt_via_db_2 = via_database(spec, strat, elt_via_db)
assert elt_via_db == elt_via_db_2
def test_round_tripping_via_the_database(spec):
random = Random(hashlib.md5((
show(spec) + u':test_round_tripping_via_the_database'
).encode(u'utf-8')).digest())
strat = strategy(spec)
template = some_template(strat, random)
strat.from_basic(strat.to_basic(template))
template_via_db = via_database(spec, strat, template)
with BuildContext():
assert show(strat.reify(template)) == show(
strat.reify(template_via_db))
def test_all_minimal_elements_round_trip_via_the_database(spec):
random = Random(
hashlib.md5((show(spec) +
u':test_all_minimal_elements_round_trip_via_the_database'
).encode(u'utf-8')).digest())
strat = spec
for elt in minimal_elements(strat, random):
elt_via_db = via_database(spec, strat, elt)
with BuildContext():
assert show(strat.reify(elt)) == show(strat.reify(elt_via_db))
elt_via_db_2 = via_database(spec, strat, elt_via_db)
assert elt_via_db == elt_via_db_2
def arg_string(f, args, kwargs):
from hypothesis.utils.show import show
args, kwargs = convert_positional_arguments(f, args, kwargs)
argspec = inspect.getargspec(f)
bits = []
for a in argspec.args:
if a in kwargs:
bits.append('%s=%s' % (a, show(kwargs.pop(a))))
if kwargs:
for a in sorted(kwargs):
bits.append('%s=%s' % (a, show(kwargs[a])))
return ', '.join([show(x) for x in args] + bits)
def __init__(self, backend, specifier, strategy, format, database):
self.database = database
self.backend = backend
self.specifier = specifier
self.format = format
self.strategy = strategy
self.key = show(specifier)
def test_all_minimal_elements_reify(strat):
random = Random(hashlib.md5((
show(strat) + u':test_all_minimal_elements_round_trip_via_the_database'
).encode(u'utf-8')).digest())
for elt in minimal_elements(strat, random):
with BuildContext():
strat.reify(elt)
def do_map(value):
rep = show(value)
random = Random(hashlib.md5((mixer + rep).encode("utf-8")).digest())
if random.random() <= p:
return result1
else:
return result2
def __repr__(self):
return (
'DescriptorWithValue(specifier=%s, template=%r, '
'value=%r, random=%r)'
) % (
show(self.specifier), self.template, self.value,
self.random,
)
def test_all_minimal_elements_reify(spec):
random = Random(hashlib.md5((
show(spec) + ':test_all_minimal_elements_round_trip_via_the_database'
).encode('utf-8')).digest())
strat = strategy(spec, Settings(average_list_length=2))
for elt in minimal_elements(strat, random):
with BuildContext():
strat.reify(elt)
def do_map(value):
rep = show(value)
random = Random(
hashlib.md5((mixer + rep).encode(u'utf-8')).digest())
if random.random() <= p:
return result1
else:
return result2
def test_all_minimal_elements_reify(spec):
random = Random(hashlib.md5((
show(spec) + u':test_all_minimal_elements_round_trip_via_the_database'
).encode(u'utf-8')).digest())
strat = strategy(spec, Settings(average_list_length=2))
for elt in minimal_elements(strat, random):
with BuildContext():
strat.reify(elt)
def test_all_minimal_elements_reify(spec):
random = Random(hashlib.md5((
show(spec) + u':test_all_minimal_elements_round_trip_via_the_database'
).encode(u'utf-8')).digest())
strat = spec
for elt in minimal_elements(strat, random):
with BuildContext():
strat.reify(elt)
def template_condition(template):
result = search.reify(template)
success = condition(result)
if success:
successful_examples[0] += 1
if not successful_examples[0]:
verbose_report(lambda: 'Trying example %s' % (show(result), ))
elif success:
if successful_examples[0] == 1:
verbose_report(lambda: 'Found satisfying example %s' %
(show(result), ))
else:
verbose_report(lambda: 'Shrunk example to %s' %
(show(result), ))
return assume(success)
def __repr__(self):
return (
'DescriptorWithValue(specifier=%s, template=%r, '
'value=%r, random=%r)'
) % (
show(self.specifier), self.template, self.value,
self.random,
)
def test_just_show_should_respect_its_values_reprs():
class Stuff(object):
def __repr__(self):
return u'Things()'
assert show(
specifiers.Just(Stuff())
) == u'Just(value=Things())'
def print_step(self, step):
"""Print a step to the current reporter.
This is called right before a step is executed.
"""
self.step_count = getattr(self, 'step_count', 0) + 1
report('Step #%d: %s' % (self.step_count, show(step)))
def test_just_show_should_respect_its_values_reprs():
class Stuff(object):
def __repr__(self):
return 'Things()'
assert show(
specifiers.Just(Stuff())
) == 'Just(value=Things())'
def do_map(value):
rep = show(value)
try:
return deepcopy(cache[rep])
except KeyError:
pass
random = Random(hashlib.md5((mixer + rep).encode("utf-8")).digest())
outcome_template = result.draw_and_produce(random)
cache[rep] = result.reify(outcome_template)
return deepcopy(cache[rep])
def test_can_handle_recursion():
x = []
x.append(x)
assert show(x) == u'[(...)]'
d = {}
d[1] = d
assert show(d) == u'{1: (...)}'
t = ([], )
t[0].append(t)
assert show(t) == u'([(...)],)'
class Foo(object):
pass
f = Foo()
f.stuff = f
assert show(f) == u'Foo(stuff=(...))'
def __init__(
self, backend, specifier, strategy, format,
database
):
self.database = database
self.backend = backend
self.specifier = specifier
self.format = format
self.strategy = strategy
self.key = show(specifier)
def test_can_handle_recursion():
x = []
x.append(x)
assert show(x) == u'[(...)]'
d = {}
d[1] = d
assert show(d) == u'{1: (...)}'
t = ([],)
t[0].append(t)
assert show(t) == u'([(...)],)'
class Foo(object):
pass
f = Foo()
f.stuff = f
assert show(f) == u'Foo(stuff=(...))'
def test_can_handle_recursion():
x = []
x.append(x)
assert show(x) == "[(...)]"
d = {}
d[1] = d
assert show(d) == "{1: (...)}"
t = ([],)
t[0].append(t)
assert show(t) == "([(...)],)"
class Foo(object):
pass
f = Foo()
f.stuff = f
assert show(f) == "Foo(stuff=(...))"
def arg_string(f, args, kwargs):
from hypothesis.utils.show import show
args, kwargs = convert_positional_arguments(f, args, kwargs)
argspec = inspect.getargspec(f)
bits = []
for a in argspec.args:
if a in kwargs:
bits.append('%s=%s' % (a, show(kwargs.pop(a))))
if kwargs:
for a in sorted(kwargs):
bits.append('%s=%s' % (a, show(kwargs[a])))
return ', '.join(
[show(x) for x in args] +
bits
)
def do_map(value):
rep = show(value)
try:
return deepcopy(cache[rep])
except KeyError:
pass
random = Random(
hashlib.md5((mixer + rep).encode(u'utf-8')).digest())
outcome_template = result.draw_and_produce(random)
cache[rep] = result.reify(outcome_template)
return deepcopy(cache[rep])
def template_condition(template):
result = search.reify(template)
success = condition(result)
if success:
successful_examples[0] += 1
if not successful_examples[0]:
verbose_report(lambda: 'Trying example %s' % (
show(result),
))
elif success:
if successful_examples[0] == 1:
verbose_report(lambda: 'Found satisfying example %s' % (
show(result),
))
else:
verbose_report(lambda: 'Shrunk example to %s' % (
show(result),
))
return success
def print_step(self, step):
rule, data = step
data_repr = {}
for k, v in data.items():
if isinstance(v, VarReference):
data_repr[k] = v.name
else:
data_repr[k] = show(v)
self.step_count = getattr(self, 'step_count', 0) + 1
report('Step #%d: %s%s(%s)' % (
self.step_count,
'%s = ' % (self.upcoming_name(),) if rule.targets else '',
rule.function.__name__,
', '.join('%s=%s' % kv for kv in data_repr.items())
))
def test_nice_strint_for_nice_floats():
assert show(0.5) == repr(0.5)
def test_show_for_nice_complex():
assert show(1 + 1j) == u'(1+1j)'
def test_show_evals_as_specifier(desc):
s = show(desc)
read_desc = eval(s)
assert show(read_desc) == s
def test_uses_binary_literals_for_binary_type():
assert show(b'foo') == u"b'foo'"
def test_show_for_nasty_in_just():
assert show(specifiers.just(
complex(u'inf+1.9j'))) == u"Just(value=complex('inf+1.9j'))"
def test_uses_show_inside_unnamed_tuples():
assert show((1, float(u'nan'))) == u"(1, float('nan'))"
def test_can_nicely_display_things_without_repr():
assert show(X(1)) == u'X(x=1)'
def test_show_for_sets_is_not_a_dict():
assert show(set()) == repr(set())
assert show(frozenset()) == repr(frozenset())
def nope(x):
if hash(show(specifier)) % 2:
raise Rejected()
def test_does_not_strip_brackets_when_not_present():
assert show(complex(u'nanj')) == u"complex('nanj')"
def test_show_for_nasty_complex():
assert show(complex(float(u'inf'), 0.0)) == u"complex('inf+0j')"
def test_uses_show_inside_unnamed_tuples():
assert show((1, float(u'nan'))) == u"(1, float('nan'))"
def from_basic(self, data):
if data is not None:
raise BadData('Expected None but got %s' % (show(data,)))
return None
def test_show_for_nasty_complex():
assert show(
complex(float(u'inf'), 0.0)) == u"complex('inf+0j')"
def test_can_nicely_display_things_without_repr():
assert show(X(1)) == u'X(x=1)'
def test_show_for_nasty_in_just():
assert show(
specifiers.just(complex(u'inf+1.9j'))
) == u"Just(value=complex('inf+1.9j'))"
def test(x):
assert Random(
hashlib.md5(show(x).encode(u'utf-8')).digest()
).random() <= p
def test_non_empty_frozensets_should_use_set_representation():
assert show(frozenset([int])) == u'frozenset({int})'
def is_good(x):
return bool(Random(
hashlib.md5((mixer + show(x)).encode(u'utf-8')).digest()
).randint(0, level))
def test_uses_show_inside_named_tuples():
Foo = namedtuple(u'Foo', (u'b', u'a'))
assert show(
Foo(1, float(u'nan'))
) == u"Foo(b=1, a=float('nan'))"
def test_uses_text_literals_for_text_type():
assert show(u'foo') == u"'foo'"
def test_does_not_strip_brackets_when_not_present():
assert show(complex(u'nanj')) == u"complex('nanj')"
def test_copies_all_its_values_correctly(desc, random):
strat = strategy(desc, settings)
value = strat.produce_template(
BuildContext(random), strat.draw_parameter(random))
assert show(strat.reify(value)) == show(strat.reify(value))
def test_fetched_repr_is_in_stream_repr(s):
assert repr(s) == u'Stream(...)'
assert show(next(iter(s))) in show(s)
def test_uses_show_inside_named_tuples():
Foo = namedtuple(u'Foo', (u'b', u'a'))
assert show(Foo(1, float(u'nan'))) == u"Foo(b=1, a=float('nan'))"
def check_serialization(self, st):
strat, template = st
as_basic = strat.to_basic(template)
assert show(strat.reify(template)) == show(strat.reify(
strat.from_basic(as_basic)))
assert as_basic == strat.to_basic(strat.from_basic(as_basic))
def test_non_empty_frozensets_should_use_set_representation():
assert show(frozenset([int])) == u'frozenset({int})'
def __repr__(self):
return 'strategy_test_suite(%s)' % (show(specifier), )
def test_show_for_sets_is_not_a_dict():
assert show(set()) == repr(set())
assert show(frozenset()) == repr(frozenset())