def run(data):
with self.settings:
with BuildContext(data, is_final=is_final):
import random as rnd_module
rnd_module.seed(0)
args, kwargs = data.draw(self.search_strategy)
if expected_failure is not None:
text_repr[0] = arg_string(test, args, kwargs)
if print_example:
report(
lambda: 'Falsifying example: %s(%s)' % (
test.__name__, arg_string(test, args, kwargs)))
elif current_verbosity() >= Verbosity.verbose:
report(
lambda: 'Trying example: %s(%s)' % (
test.__name__, arg_string(test, args, kwargs)))
if self.collector is None or not collect:
return test(*args, **kwargs)
else: # pragma: no cover
try:
self.collector.start()
return test(*args, **kwargs)
finally:
self.collector.stop()
def run(data):
if not hasattr(data, "can_reproduce_example_from_repr"):
data.can_reproduce_example_from_repr = True
with local_settings(self.settings):
with deterministic_PRNG():
with BuildContext(data, is_final=is_final):
args, kwargs = data.draw(self.search_strategy)
if expected_failure is not None:
text_repr[0] = arg_string(test, args, kwargs)
if print_example:
example = "%s(%s)" % (
test.__name__,
arg_string(test, args, kwargs),
)
try:
ast.parse(example)
except SyntaxError:
data.can_reproduce_example_from_repr = False
report("Falsifying example: %s" % (example,))
elif current_verbosity() >= Verbosity.verbose:
report(
lambda: "Trying example: %s(%s)"
% (test.__name__, arg_string(test, args, kwargs))
)
return test(*args, **kwargs)
def test_can_handle_unicode_repr():
def foo(x):
pass
from hypothesis import settings
with settings(strict=False):
assert arg_string(foo, [Snowman()], {}) == 'x=☃'
assert arg_string(foo, [], {'x': Snowman()}) == 'x=☃'
def test_arg_strings_are_bad_repr_safe(recwarn):
assert arg_string(varargs, (Frosty,), {}) == u'☃'
if PY2:
recwarn.pop(HypothesisDeprecationWarning)
assert arg_string(varargs, (), {u'x': Frosty}) == u'x=☃'
if PY2:
recwarn.pop(HypothesisDeprecationWarning)
def run(data):
if not hasattr(data, 'can_reproduce_example_from_repr'):
data.can_reproduce_example_from_repr = True
with local_settings(self.settings):
with BuildContext(data, is_final=is_final):
with deterministic_PRNG():
args, kwargs = data.draw(self.search_strategy)
if expected_failure is not None:
text_repr[0] = arg_string(test, args, kwargs)
if print_example:
example = '%s(%s)' % (
test.__name__, arg_string(test, args, kwargs))
try:
ast.parse(example)
except SyntaxError:
data.can_reproduce_example_from_repr = False
report('Falsifying example: %s' % (example,))
elif current_verbosity() >= Verbosity.verbose:
report(
lambda: 'Trying example: %s(%s)' % (
test.__name__, arg_string(test, args, kwargs)))
with deterministic_PRNG():
return test(*args, **kwargs)
def run(data):
if not hasattr(data, 'can_reproduce_example_from_repr'):
data.can_reproduce_example_from_repr = True
with self.settings:
with BuildContext(data, is_final=is_final):
with deterministic_PRNG():
args, kwargs = data.draw(self.search_strategy)
if expected_failure is not None:
text_repr[0] = arg_string(test, args, kwargs)
if print_example:
example = '%s(%s)' % (test.__name__,
arg_string(test, args, kwargs))
try:
ast.parse(example)
except SyntaxError:
data.can_reproduce_example_from_repr = False
report('Falsifying example: %s' % (example, ))
elif current_verbosity() >= Verbosity.verbose:
report(lambda: 'Trying example: %s(%s)' %
(test.__name__, arg_string(test, args, kwargs)))
if self.collector is None or not collect:
with deterministic_PRNG():
return test(*args, **kwargs)
else: # pragma: no cover
try:
self.collector.start()
with deterministic_PRNG():
return test(*args, **kwargs)
finally:
self.collector.stop()
def test_can_handle_unicode_repr():
def foo(x):
pass
from hypothesis import settings
with settings(strict=False):
assert arg_string(foo, [Snowman()], {}) == 'x=☃'
assert arg_string(foo, [], {'x': Snowman()}) == 'x=☃'
def test_arg_string_is_in_order():
def foo(c, a, b, f, a1):
pass
assert arg_string(foo, (1, 2, 3, 4, 5), {}) == "c=1, a=2, b=3, f=4, a1=5"
assert (
arg_string(foo, (1, 2), {"b": 3, "f": 4, "a1": 5}) == "c=1, a=2, b=3, f=4, a1=5"
)
def test_arg_string_is_in_order():
def foo(c, a, b, f, a1):
pass
assert arg_string(foo, (1, 2, 3, 4, 5), {}) == 'c=1, a=2, b=3, f=4, a1=5'
assert arg_string(
foo, (1, 2),
{'b': 3, 'f': 4, 'a1': 5}) == 'c=1, a=2, b=3, f=4, a1=5'
def test_arg_string_is_in_order():
def foo(c, a, b, f, a1):
pass
assert arg_string(foo, (1, 2, 3, 4, 5), {}) == 'c=1, a=2, b=3, f=4, a1=5'
assert arg_string(
foo, (1, 2),
{'b': 3, 'f': 4, 'a1': 5}) == 'c=1, a=2, b=3, f=4, a1=5'
def run():
args, kwargs = search_strategy.reify(template)
if print_example:
report(lambda: 'Falsifying example: %s(%s)' %
(test.__name__, arg_string(test, args, kwargs)))
else:
verbose_report(lambda: 'Trying example: %s(%s)' %
(test.__name__, arg_string(test, args, kwargs)))
return test(*args, **kwargs)
def run(data):
with BuildContext(is_final=is_final):
args, kwargs = data.draw(search_strategy)
if print_example:
report(lambda: 'Falsifying example: %s(%s)' %
(test.__name__, arg_string(test, args, kwargs)))
elif current_verbosity() >= Verbosity.verbose:
report(lambda: 'Trying example: %s(%s)' %
(test.__name__, arg_string(test, args, kwargs)))
return test(*args, **kwargs)
def run(data):
with BuildContext(is_final=is_final):
args, kwargs = data.draw(search_strategy)
if print_example:
report(
lambda: 'Falsifying example: %s(%s)' % (
test.__name__, arg_string(test, args, kwargs)))
elif current_verbosity() >= Verbosity.verbose:
report(
lambda: 'Trying example: %s(%s)' % (
test.__name__, arg_string(test, args, kwargs)))
return test(*args, **kwargs)
def run(data):
from hypothesis.control import note
with BuildContext(is_final=is_final):
seed = data.draw(random_module()).seed
if seed != 0:
note("random.seed(%d)" % (seed,))
args, kwargs = data.draw(search_strategy)
if print_example:
report(lambda: "Falsifying example: %s(%s)" % (test.__name__, arg_string(test, args, kwargs)))
elif current_verbosity() >= Verbosity.verbose:
report(lambda: "Trying example: %s(%s)" % (test.__name__, arg_string(test, args, kwargs)))
return test(*args, **kwargs)
def __repr__(self):
if self.__representation is None:
_args = self.__args
_kwargs = self.__kwargs
argspec = getargspec(self.__function)
defaults = {}
if argspec.defaults is not None:
for k in hrange(1, len(argspec.defaults) + 1):
defaults[argspec.args[-k]] = argspec.defaults[-k]
if len(argspec.args) > 1 or argspec.defaults:
_args, _kwargs = convert_positional_arguments(
self.__function, _args, _kwargs)
else:
_args, _kwargs = convert_keyword_arguments(
self.__function, _args, _kwargs)
kwargs_for_repr = dict(_kwargs)
for k, v in defaults.items():
if k in kwargs_for_repr and kwargs_for_repr[k] is defaults[k]:
del kwargs_for_repr[k]
self.__representation = '%s(%s)' % (
self.__function.__name__,
arg_string(
self.__function, _args, kwargs_for_repr, reorder=False),
)
return self.__representation
def __repr__(self):
if self.__representation is None:
_args = self.__args
_kwargs = self.__kwargs
argspec = getfullargspec(self.__function)
defaults = dict(argspec.kwonlydefaults or {})
if argspec.defaults is not None:
for name, value in zip(reversed(argspec.args),
reversed(argspec.defaults)):
defaults[name] = value
if len(argspec.args) > 1 or argspec.defaults:
_args, _kwargs = convert_positional_arguments(
self.__function, _args, _kwargs)
else:
_args, _kwargs = convert_keyword_arguments(
self.__function, _args, _kwargs)
kwargs_for_repr = dict(_kwargs)
for k, v in defaults.items():
if k in kwargs_for_repr and kwargs_for_repr[k] is defaults[k]:
del kwargs_for_repr[k]
self.__representation = '%s(%s)' % (
self.__function.__name__,
arg_string(
self.__function, _args, kwargs_for_repr, reorder=False),
)
return self.__representation
def test_varkwargs_are_sorted_and_after_real_kwargs():
def foo(d, e, f, **kwargs):
pass
assert arg_string(
foo, (), {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}
) == 'd=4, e=5, f=6, a=1, b=2, c=3'
def test_can_mix_varargs_and_varkwargs():
def foo(*args, **kwargs):
pass
assert arg_string(
foo, (1, 2, 3), {'c': 7}
) == '1, 2, 3, c=7'
def test_can_mix_varargs_and_varkwargs():
def foo(*args, **kwargs):
pass
assert arg_string(
foo, (1, 2, 3), {'c': 7}
) == '1, 2, 3, c=7'
def test_varkwargs_are_sorted_and_after_real_kwargs():
def foo(d, e, f, **kwargs):
pass
assert (
arg_string(foo, (), {u"a": 1, u"b": 2, u"c": 3, u"d": 4, u"e": 5, u"f": 6}) == u"d=4, e=5, f=6, a=1, b=2, c=3"
)
def test_varkwargs_are_sorted_and_after_real_kwargs():
def foo(d, e, f, **kwargs):
pass
assert arg_string(
foo, (), {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}
) == 'd=4, e=5, f=6, a=1, b=2, c=3'
def test_or_flaky(*args, **kwargs):
text_repr = arg_string(test, args, kwargs)
raise Flaky(('Hypothesis %s(%s) produces unreliable results: Falsified'
' on the first call but did not on a subsequent one') % (
test.__name__,
text_repr,
))
def __repr__(self):
if self.__representation is None:
_args = self.__args
_kwargs = self.__kwargs
argspec = getargspec(self.__function)
defaults = {}
if argspec.defaults is not None:
for k in hrange(1, len(argspec.defaults) + 1):
defaults[argspec.args[-k]] = argspec.defaults[-k]
if len(argspec.args) > 1 or argspec.defaults:
_args, _kwargs = convert_positional_arguments(
self.__function, _args, _kwargs)
else:
_args, _kwargs = convert_keyword_arguments(
self.__function, _args, _kwargs)
kwargs_for_repr = dict(_kwargs)
for k, v in defaults.items():
if k in kwargs_for_repr and kwargs_for_repr[k] is defaults[k]:
del kwargs_for_repr[k]
self.__representation = '%s(%s)' % (
self.__function.__name__,
arg_string(
self.__function, _args, kwargs_for_repr, reorder=False),
)
return self.__representation
def execute_explicit_examples(test_runner, test, wrapped_test, settings,
arguments, kwargs):
original_argspec = getargspec(test)
for example in reversed(
getattr(wrapped_test, 'hypothesis_explicit_examples', ())):
if example.args:
if len(example.args) > len(original_argspec.args):
raise InvalidArgument(
'example has too many arguments for test. '
'Expected at most %d but got %d' %
(len(original_argspec.args), len(example.args)))
example_kwargs = dict(
zip(original_argspec.args[-len(example.args):], example.args))
else:
example_kwargs = example.kwargs
if Phase.explicit not in settings.phases:
continue
example_kwargs.update(kwargs)
# Note: Test may mutate arguments and we can't rerun explicit
# examples, so we have to calculate the failure message at this
# point rather than than later.
message_on_failure = 'Falsifying example: %s(%s)' % (
test.__name__, arg_string(test, arguments, example_kwargs))
try:
with BuildContext(None) as b:
test_runner(None,
lambda data: test(*arguments, **example_kwargs))
except BaseException:
traceback.print_exc()
report(message_on_failure)
for n in b.notes:
report(n)
raise
def test_or_flaky(*args, **kwargs):
text_repr = arg_string(test, args, kwargs)
raise Flaky(
(
'Hypothesis %s(%s) produces unreliable results: Falsified'
' on the first call but did not on a subsequent one'
) % (test.__name__, text_repr,))
def __repr__(self):
if self.__representation is None:
_args = self.__args
_kwargs = self.__kwargs
argspec = getfullargspec(self.__function)
defaults = dict(argspec.kwonlydefaults or {})
if argspec.defaults is not None:
for name, value in zip(reversed(argspec.args),
reversed(argspec.defaults)):
defaults[name] = value
if len(argspec.args) > 1 or argspec.defaults:
_args, _kwargs = convert_positional_arguments(
self.__function, _args, _kwargs)
else:
_args, _kwargs = convert_keyword_arguments(
self.__function, _args, _kwargs)
kwargs_for_repr = dict(_kwargs)
for k, v in defaults.items():
if k in kwargs_for_repr and kwargs_for_repr[k] is defaults[k]:
del kwargs_for_repr[k]
self.__representation = '%s(%s)' % (
self.__function.__name__,
arg_string(
self.__function, _args, kwargs_for_repr, reorder=False),
)
return self.__representation
def __repr__(self):
if self.__representation is None:
sig = signature(self.function)
pos = [
p for p in sig.parameters.values()
if "POSITIONAL" in p.kind.name
]
if len(pos) > 1 or any(p.default is not sig.empty for p in pos):
_args, _kwargs = convert_positional_arguments(
self.function, self.__args, self.__kwargs)
else:
_args, _kwargs = convert_keyword_arguments(
self.function, self.__args, self.__kwargs)
kwargs_for_repr = {
k: v
for k, v in _kwargs.items() if k not in sig.parameters
or v is not sig.parameters[k].default
}
self.__representation = "{}({}){}".format(
self.function.__name__,
arg_string(self.function,
_args,
kwargs_for_repr,
reorder=False),
"".join(map(_repr_filter, self.__filters)),
)
return self.__representation
def run(data):
from hypothesis.control import note
with BuildContext(is_final=is_final):
seed = data.draw(random_module()).seed
if seed != 0:
note('random.seed(%d)' % (seed, ))
args, kwargs = data.draw(search_strategy)
if print_example:
report(lambda: 'Falsifying example: %s(%s)' %
(test.__name__, arg_string(test, args, kwargs)))
elif current_verbosity() >= Verbosity.verbose:
report(lambda: 'Trying example: %s(%s)' %
(test.__name__, arg_string(test, args, kwargs)))
return test(*args, **kwargs)
def test_varkwargs_are_sorted_and_after_real_kwargs():
def foo(d, e, f, **kwargs):
pass
assert (
arg_string(foo, (), {"a": 1, "b": 2, "c": 3, "d": 4, "e": 5, "f": 6})
== "d=4, e=5, f=6, a=1, b=2, c=3"
)
def run(data):
with BuildContext(data, is_final=is_final):
orig = sys.gettrace()
try: # pragma: no cover
sys.settrace(None)
import random as rnd_module
rnd_module.seed(0)
finally: # pragma: no cover
sys.settrace(orig)
args, kwargs = data.draw(search_strategy)
if print_example:
report(lambda: 'Falsifying example: %s(%s)' %
(test.__name__, arg_string(test, args, kwargs)))
elif current_verbosity() >= Verbosity.verbose:
report(lambda: 'Trying example: %s(%s)' %
(test.__name__, arg_string(test, args, kwargs)))
return test(*args, **kwargs)
def inner(*args, **kwargs):
if data.frozen:
raise InvalidState(
"This generated %s function can only be called within the "
"scope of the @given that created it." %
(nicerepr(self.like), ))
val = data.draw(self.returns)
note("Called function: %s(%s) -> %r" % (nicerepr(
self.like), arg_string(self.like, args, kwargs), val))
return val
def run(data):
with local_settings(self.settings):
with deterministic_PRNG():
with BuildContext(data, is_final=is_final):
args, kwargs = data.draw(self.search_strategy)
if expected_failure is not None:
text_repr[0] = arg_string(test, args, kwargs)
if print_example:
example = "%s(%s)" % (
test.__name__,
arg_string(test, args, kwargs),
)
report("Falsifying example: %s" % (example,))
elif current_verbosity() >= Verbosity.verbose:
report(
lambda: "Trying example: %s(%s)"
% (test.__name__, arg_string(test, args, kwargs))
)
return test(*args, **kwargs)
def run():
with BuildContext():
args, kwargs = search_strategy.reify(template)
text_version = arg_string(test, args, kwargs)
if print_example:
report(lambda: "Falsifying example: %s(%s)" % (test.__name__, text_version))
elif current_verbosity() >= Verbosity.verbose or always_print:
report(lambda: "Trying example: %s(%s)" % (test.__name__, text_version))
if record_repr is not None:
record_repr[0] = text_version
return test(*args, **kwargs)
def run(data):
with BuildContext(data, is_final=is_final):
orig = sys.gettrace()
try: # pragma: no cover
sys.settrace(None)
import random as rnd_module
rnd_module.seed(0)
finally: # pragma: no cover
sys.settrace(orig)
args, kwargs = data.draw(search_strategy)
if print_example:
report(
lambda: 'Falsifying example: %s(%s)' % (
test.__name__, arg_string(test, args, kwargs)))
elif current_verbosity() >= Verbosity.verbose:
report(
lambda: 'Trying example: %s(%s)' % (
test.__name__, arg_string(test, args, kwargs)))
return test(*args, **kwargs)
def accept(*args, **kwargs):
result = strategy_definition(*args, **kwargs)
args, kwargs = convert_positional_arguments(strategy_definition, args,
kwargs)
kwargs_for_repr = dict(kwargs)
for k, v in defaults.items():
if k in kwargs_for_repr and kwargs_for_repr[k] is defaults[k]:
del kwargs_for_repr[k]
representation = u'%s(%s)' % (strategy_definition.__name__,
arg_string(strategy_definition, args,
kwargs_for_repr))
return ReprWrapperStrategy(result, representation)
def run():
args, kwargs = search_strategy.reify(template)
if print_example:
report(
lambda: 'Falsifying example: %s(%s)' % (
test.__name__,
arg_string(
test, args, kwargs
)
)
)
elif current_verbosity() >= Verbosity.verbose or always_print:
report(
lambda: 'Trying example: %s(%s)' % (
test.__name__,
arg_string(
test, args, kwargs
)
)
)
return test(*args, **kwargs)
def run():
args, kwargs = search_strategy.reify(template)
if print_example:
report(
lambda: 'Falsifying example: %s(%s)' % (
test.__name__,
arg_string(
test, args, kwargs
)
)
)
else:
verbose_report(
lambda: 'Trying example: %s(%s)' % (
test.__name__,
arg_string(
test, args, kwargs
)
)
)
return test(*args, **kwargs)
def run():
args, kwargs = search_strategy.reify(template)
if print_example:
current_reporter()(
'Falsifying example: %s(%s)' % (
test.__name__,
arg_string(
test, args, kwargs
)
)
)
return test(*args, **kwargs)
def calc_repr():
_args = args
_kwargs = kwargs
_args, _kwargs = convert_positional_arguments(
strategy_definition, _args, _kwargs)
kwargs_for_repr = dict(_kwargs)
for k, v in defaults.items():
if k in kwargs_for_repr and kwargs_for_repr[k] is defaults[k]:
del kwargs_for_repr[k]
return u'%s(%s)' % (strategy_definition.__name__,
arg_string(strategy_definition, _args,
kwargs_for_repr))
def run():
args, kwargs = search_strategy.reify(template)
if print_example:
report(
lambda: 'Falsifying example: %s(%s)' % (
test.__name__,
arg_string(
test, args, kwargs
)
)
)
elif current_verbosity() >= Verbosity.verbose or always_print:
report(
lambda: 'Trying example: %s(%s)' % (
test.__name__,
arg_string(
test, args, kwargs
)
)
)
return test(*args, **kwargs)
def accept(*args, **kwargs):
result = strategy_definition(*args, **kwargs)
args, kwargs = convert_positional_arguments(
strategy_definition, args, kwargs)
kwargs_for_repr = dict(kwargs)
for k, v in defaults.items():
if k in kwargs_for_repr and kwargs_for_repr[k] is defaults[k]:
del kwargs_for_repr[k]
representation = u'%s(%s)' % (
strategy_definition.__name__,
arg_string(strategy_definition, args, kwargs_for_repr)
)
return ReprWrapperStrategy(result, representation)
def run(data):
with BuildContext(data, is_final=is_final):
import random as rnd_module
rnd_module.seed(0)
args, kwargs = data.draw(search_strategy)
if print_example:
report(
lambda: 'Falsifying example: %s(%s)' % (
test.__name__, arg_string(test, args, kwargs)))
elif current_verbosity() >= Verbosity.verbose:
report(
lambda: 'Trying example: %s(%s)' % (
test.__name__, arg_string(test, args, kwargs)))
if collector is None:
return test(*args, **kwargs)
else: # pragma: no cover
try:
collector.start()
return test(*args, **kwargs)
finally:
collector.stop()
def inner(*args, **kwargs):
if data.frozen:
raise InvalidState(
"This generated %s function can only be called within the "
"scope of the @given that created it." % (nicerepr(self.like),)
)
data.can_reproduce_example_from_repr = False
val = data.draw(self.returns)
note(
"Called function: %s(%s) -> %r"
% (nicerepr(self.like), arg_string(self.like, args, kwargs), val)
)
return val
def calc_repr():
_args = args
_kwargs = kwargs
_args, _kwargs = convert_positional_arguments(
strategy_definition, _args, _kwargs)
kwargs_for_repr = dict(_kwargs)
for k, v in defaults.items():
if k in kwargs_for_repr and kwargs_for_repr[k] is defaults[k]:
del kwargs_for_repr[k]
return u'%s(%s)' % (
strategy_definition.__name__,
arg_string(strategy_definition, _args, kwargs_for_repr)
)
def run(data):
if not hasattr(data, 'can_reproduce_example_from_repr'):
data.can_reproduce_example_from_repr = True
with local_settings(self.settings):
with BuildContext(data, is_final=is_final):
update_error_store('test_name', test.__name__)
with deterministic_PRNG():
args, kwargs = data.draw(self.search_strategy)
if expected_failure is not None:
text_repr[0] = arg_string(test, args, kwargs)
if print_example:
example = '%s(%s)' % (test.__name__,
arg_string(test, args, kwargs))
try:
ast.parse(example)
except SyntaxError:
data.can_reproduce_example_from_repr = False
one_error = {}
variable_list = []
for variableset in text_repr[0].split(', '):
[name, value] = variableset.split('=')
variable_pair = {'v_name': name, 'v_value': value}
variable_list.append(variable_pair)
one_error['variables'] = variable_list
one_error['error_type'] = ((
expected_failure[0]).__class__.__name__)
one_error['error_message'] = str(expected_failure[0])
one_error['traceback'] = expected_failure[1]
add_one_error(one_error)
report('Falsifying example: %s' % (example, ))
elif current_verbosity() >= Verbosity.verbose:
report(lambda: 'Trying example: %s(%s)' %
(test.__name__, arg_string(test, args, kwargs)))
with deterministic_PRNG():
return test(*args, **kwargs)
def run():
with BuildContext(is_final=is_final):
args, kwargs = search_strategy.reify(template)
text_version = arg_string(test, args, kwargs)
if print_example:
report(lambda: 'Falsifying example: %s(%s)' % (
test.__name__,
text_version,
))
elif current_verbosity() >= Verbosity.verbose:
report(lambda: 'Trying example: %s(%s)' %
(test.__name__, text_version))
if record_repr is not None:
record_repr[0] = text_version
return test(*args, **kwargs)
def inner(*args, **kwargs):
if data.frozen:
raise InvalidState(
"This generated %s function can only be called within the "
"scope of the @given that created it." %
(nicerepr(self.like), ))
if self.pure:
args, kwargs = convert_positional_arguments(
self.like, args, kwargs)
key = (inner, args, frozenset(kwargs.items()))
val = data.draw(SharedStrategy(base=self.returns, key=key))
else:
val = data.draw(self.returns)
note("Called function: %s(%s) -> %r" % (nicerepr(
self.like), arg_string(self.like, args, kwargs), val))
return val
def test_or_flaky(*args, **kwargs):
text_repr = arg_string(test, args, kwargs)
if text_repr == expected_repr:
raise Flaky(
(
u'Hypothesis %s(%s) produces unreliable results: Falsified'
u' on the first call but did not on a subsequent one'
) % (test.__name__, text_repr,))
else:
raise Flaky(
(
u'Hypothesis %s produces unreliable results: Falsified'
u' on the first call but did not on a subsequent one.'
u' This is possibly due to unreliable values, which may '
u'be a bug in the strategy.\nCall 1: %s\nCall 2: %s\n'
) % (test.__name__, expected_repr, text_repr,))
def test_or_flaky(*args, **kwargs):
text_repr = arg_string(test, args, kwargs)
if text_repr == expected_repr:
raise Flaky(
(
'Hypothesis %s(%s) produces unreliable results: Falsified'
' on the first call but did not on a subsequent one'
) % (test.__name__, text_repr,))
else:
raise Flaky(
(
'Hypothesis %s produces unreliable results: Falsified'
' on the first call but did not on a subsequent one. This '
' is possibly due to unreliable values, which may be a bug'
' in the strategy.\nCall 1: %s\nCall 2: %s\n'
) % (test.__name__, expected_repr, text_repr,))
def execute_explicit_examples(
test_runner, test, wrapped_test, settings, arguments, kwargs
):
original_argspec = getfullargspec(test)
for example in reversed(getattr(
wrapped_test, 'hypothesis_explicit_examples', ()
)):
example_kwargs = dict(original_argspec.kwonlydefaults or {})
if example.args:
if len(example.args) > len(original_argspec.args):
raise InvalidArgument(
'example has too many arguments for test. '
'Expected at most %d but got %d' % (
len(original_argspec.args), len(example.args)))
example_kwargs.update(dict(zip(
original_argspec.args[-len(example.args):],
example.args
)))
else:
example_kwargs.update(example.kwargs)
if Phase.explicit not in settings.phases:
continue
example_kwargs.update(kwargs)
# Note: Test may mutate arguments and we can't rerun explicit
# examples, so we have to calculate the failure message at this
# point rather than than later.
example_string = '%s(%s)' % (
test.__name__, arg_string(test, arguments, example_kwargs)
)
try:
with BuildContext(None) as b:
if settings.verbosity >= Verbosity.verbose:
report('Trying example: ' + example_string)
test_runner(
None,
lambda data: test(*arguments, **example_kwargs)
)
except BaseException:
report('Falsifying example: ' + example_string)
for n in b.notes:
report(n)
raise
def execute_explicit_examples(test_runner, test, wrapped_test, settings,
arguments, kwargs):
original_argspec = getfullargspec(test)
for example in reversed(
getattr(wrapped_test, "hypothesis_explicit_examples", ())):
example_kwargs = dict(original_argspec.kwonlydefaults or {})
if example.args:
if len(example.args) > len(original_argspec.args):
raise InvalidArgument(
"example has too many arguments for test. "
"Expected at most %d but got %d" %
(len(original_argspec.args), len(example.args)))
example_kwargs.update(
dict(
zip(original_argspec.args[-len(example.args):],
example.args)))
else:
example_kwargs.update(example.kwargs)
if Phase.explicit not in settings.phases:
continue
example_kwargs.update(kwargs)
# Note: Test may mutate arguments and we can't rerun explicit
# examples, so we have to calculate the failure message at this
# point rather than than later.
example_string = "%s(%s)" % (
test.__name__,
arg_string(test, arguments, example_kwargs),
)
with local_settings(settings):
try:
with BuildContext(None) as b:
verbose_report("Trying example: " + example_string)
test_runner(
None, lambda data: test(*arguments, **example_kwargs))
except BaseException:
report("Falsifying example: " + example_string)
for n in b.notes:
report(n)
raise
def test_arg_string_kwargs_are_bad_repr_safe():
assert arg_string(varargs, (), {"x": Frosty}) == "x=☃"
def test_arg_strings_are_bad_repr_safe():
assert arg_string(varargs, (Frosty,), {}) == "☃"
def wrapped_test(*arguments, **kwargs):
import hypothesis.strategies as sd
from hypothesis.internal.strategymethod import strategy
selfy = None
arguments, kwargs = convert_positional_arguments(
wrapped_test, arguments, kwargs)
# Anything in unused_kwargs hasn't been injected through
# argspec.defaults, so we need to add them.
for k in unused_kwargs:
if k not in kwargs:
kwargs[k] = unused_kwargs[k]
# If the test function is a method of some kind, the bound object
# will be the first named argument if there are any, otherwise the
# first vararg (if any).
if argspec.args:
selfy = kwargs.get(argspec.args[0])
elif arguments:
selfy = arguments[0]
if isinstance(selfy, HypothesisProvided):
selfy = None
test_runner = executor(selfy)
for example in getattr(
wrapped_test, u'hypothesis_explicit_examples', ()
):
if example.args:
example_kwargs = dict(zip(
argspec.args[-len(example.args):], example.args
))
else:
example_kwargs = dict(example.kwargs)
for k, v in kwargs.items():
if not isinstance(v, HypothesisProvided):
example_kwargs[k] = v
# Note: Test may mutate arguments and we can't rerun explicit
# examples, so we have to calculate the failure message at this
# point rather than than later.
message_on_failure = u'Falsifying example: %s(%s)' % (
test.__name__, arg_string(test, arguments, example_kwargs)
)
try:
test_runner(
lambda: test(*arguments, **example_kwargs)
)
except BaseException:
report(message_on_failure)
raise
if not any(
isinstance(x, HypothesisProvided)
for xs in (arguments, kwargs.values())
for x in xs
):
# All arguments have been satisfied without needing to invoke
# hypothesis
test_runner(lambda: test(*arguments, **kwargs))
return
def convert_to_specifier(v):
if isinstance(v, HypothesisProvided):
return strategy(v.value, settings)
else:
return sd.just(v)
given_specifier = sd.tuples(
sd.tuples(*map(convert_to_specifier, arguments)),
sd.fixed_dictionaries(dict(
(k, convert_to_specifier(v)) for (k, v) in kwargs.items()))
)
search_strategy = strategy(given_specifier, settings)
if settings.database:
storage = settings.database.storage(
fully_qualified_name(test))
else:
storage = None
last_exception = [None]
repr_for_last_exception = [None]
def is_template_example(xs):
record_repr = [None]
try:
test_runner(reify_and_execute(
search_strategy, xs, test,
always_print=settings.max_shrinks <= 0,
record_repr=record_repr,
))
return False
except UnsatisfiedAssumption as e:
raise e
except Exception as e:
if settings.max_shrinks <= 0:
raise e
last_exception[0] = traceback.format_exc()
repr_for_last_exception[0] = record_repr[0]
verbose_report(last_exception[0])
return True
is_template_example.__name__ = test.__name__
is_template_example.__qualname__ = qualname(test)
falsifying_template = None
try:
falsifying_template = best_satisfying_template(
search_strategy, random, is_template_example,
settings, storage
)
except NoSuchExample:
return
assert last_exception[0] is not None
with settings:
test_runner(reify_and_execute(
search_strategy, falsifying_template, test,
print_example=True, is_final=True
))
report(
u'Failed to reproduce exception. Expected: \n' +
last_exception[0],
)
test_runner(reify_and_execute(
search_strategy, falsifying_template,
test_is_flaky(test, repr_for_last_exception[0]),
print_example=True, is_final=True
))
def run(data):
# Set up dynamic context needed by a single test run.
with local_settings(self.settings):
with deterministic_PRNG():
with BuildContext(data, is_final=is_final):
# Generate all arguments to the test function.
args, kwargs = data.draw(self.search_strategy)
if expected_failure is not None:
text_repr[0] = arg_string(test, args, kwargs)
if print_example or current_verbosity(
) >= Verbosity.verbose:
output = CUnicodeIO()
printer = RepresentationPrinter(output)
if print_example:
printer.text("Falsifying example:")
else:
printer.text("Trying example:")
if self.print_given_args:
printer.text(" ")
printer.text(test.__name__)
with printer.group(indent=4,
open="(",
close=""):
printer.break_()
for v in args:
printer.pretty(v)
# We add a comma unconditionally because
# generated arguments will always be
# kwargs, so there will always be more
# to come.
printer.text(",")
printer.breakable()
# We need to make sure to print these in the argument order for
# Python 2 and older versionf of Python 3.5. In modern versions
# this isn't an issue because kwargs is ordered.
arg_order = {
v: i
for i, v in enumerate(
getfullargspec(self.test).args)
}
for i, (k, v) in enumerate(
sorted(
kwargs.items(),
key=lambda t: (
arg_order.get(
t[0], float("inf")),
t[0],
),
)):
printer.text(k)
printer.text("=")
printer.pretty(v)
printer.text(",")
if i + 1 < len(kwargs):
printer.breakable()
printer.break_()
printer.text(")")
printer.flush()
report(output.getvalue())
return test(*args, **kwargs)
def test_can_handle_non_unicode_repr_containing_non_ascii():
def foo(x):
pass
assert arg_string(foo, [BittySnowman()], {}) == 'x=☃'
assert arg_string(foo, [], {'x': BittySnowman()}) == 'x=☃'
def test_can_handle_repr_of_none():
def foo(x):
pass
assert arg_string(foo, [None], {}) == 'x=None'
assert arg_string(foo, [], {'x': None}) == 'x=None'
def test_can_handle_repr_on_type():
def foo(x):
pass
assert arg_string(foo, [Snowman], {}) == 'x=%r' % (Snowman,)
assert arg_string(foo, [NoRepr], {}) == 'x=%r' % (NoRepr,)
def test_can_handle_unicode_repr():
def foo(x):
pass
assert arg_string(foo, [Snowman()], {}) == 'x=☃'
assert arg_string(foo, [], {'x': Snowman()}) == 'x=☃'
def run():
args, kwargs = search_strategy.reify(template)
if print_example:
current_reporter()('Falsifying example: %s(%s)' %
(test.__name__, arg_string(test, args, kwargs)))
return test(*args, **kwargs)
