def run(self, state_machine, print_steps=None):
if print_steps is None:
print_steps = current_verbosity() >= Verbosity.debug
self.data.hypothesis_runner = state_machine
stopping_value = 1 - 1.0 / (1 + self.n_steps * 0.5)
try:
state_machine.check_invariants()
steps = 0
while True:
if steps >= self.n_steps:
stopping_value = 0
self.data.start_example()
if not cu.biased_coin(self.data, stopping_value):
self.data.stop_example()
break
assert steps < self.n_steps
value = self.data.draw(state_machine.steps())
steps += 1
if print_steps:
state_machine.print_step(value)
state_machine.execute_step(value)
self.data.stop_example()
state_machine.check_invariants()
finally:
state_machine.teardown()
def run(self, state_machine, print_steps=None):
if print_steps is None:
print_steps = current_verbosity() >= Verbosity.debug
self.data.hypothesis_runner = state_machine
should_continue = cu.many(
self.data, min_size=1, max_size=self.n_steps,
average_size=self.n_steps,
)
try:
if print_steps:
state_machine.print_start()
state_machine.check_invariants()
while should_continue.more():
value = self.data.draw(state_machine.steps())
if print_steps:
state_machine.print_step(value)
state_machine.execute_step(value)
state_machine.check_invariants()
finally:
if print_steps:
state_machine.print_end()
state_machine.teardown()
def run_state_machine(factory, data):
machine = factory()
check_type(GenericStateMachine, machine, "state_machine_factory()")
data.conjecture_data.hypothesis_runner = machine
n_steps = settings.stateful_step_count
should_continue = cu.many(
data.conjecture_data, min_size=1, max_size=n_steps, average_size=n_steps
)
print_steps = (
current_build_context().is_final or current_verbosity() >= Verbosity.debug
)
try:
if print_steps:
machine.print_start()
machine.check_invariants()
while should_continue.more():
value = data.conjecture_data.draw(machine.steps())
if print_steps:
machine.print_step(value)
machine.execute_step(value)
machine.check_invariants()
finally:
if print_steps:
machine.print_end()
machine.teardown()
def run_state_machine(factory, data):
machine = factory()
check_type(GenericStateMachine, machine, "state_machine_factory()")
data.conjecture_data.hypothesis_runner = machine
n_steps = settings.stateful_step_count
should_continue = cu.many(data.conjecture_data,
min_size=1,
max_size=n_steps,
average_size=n_steps)
print_steps = (current_build_context().is_final
or current_verbosity() >= Verbosity.debug)
try:
if print_steps:
machine.print_start()
machine.check_invariants()
while should_continue.more():
value = data.conjecture_data.draw(machine.steps())
if print_steps:
machine.print_step(value)
machine.execute_step(value)
machine.check_invariants()
finally:
if print_steps:
machine.print_end()
machine.teardown()
def run(self, state_machine, print_steps=None):
if print_steps is None:
print_steps = current_verbosity() >= Verbosity.debug
self.data.hypothesis_runner = state_machine
stopping_value = 1 - 1.0 / (1 + self.n_steps * 0.5)
try:
steps = 0
while True:
if steps == self.n_steps:
stopping_value = 0
self.data.start_example()
if not cu.biased_coin(self.data, stopping_value):
self.data.stop_example()
break
value = self.data.draw(state_machine.steps())
steps += 1
if steps <= self.n_steps:
if print_steps:
state_machine.print_step(value)
state_machine.execute_step(value)
self.data.stop_example()
finally:
state_machine.teardown()
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 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 run(self, state_machine, print_steps=None):
if print_steps is None:
print_steps = current_verbosity() >= Verbosity.debug
self.data.hypothesis_runner = state_machine
should_continue = cu.many(
self.data,
min_size=1,
max_size=self.n_steps,
average_size=self.n_steps,
)
try:
if print_steps:
state_machine.print_start()
state_machine.check_invariants()
while should_continue.more():
value = self.data.draw(state_machine.steps())
if print_steps:
state_machine.print_step(value)
state_machine.execute_step(value)
state_machine.check_invariants()
finally:
if print_steps:
state_machine.print_end()
state_machine.teardown()
def execute_explicit_examples(state, wrapped_test, arguments, kwargs):
original_argspec = getfullargspec(state.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 state.settings.phases:
continue
example_kwargs.update(kwargs)
with local_settings(state.settings):
fragments_reported = []
def report_buffered():
for f in fragments_reported:
report(f)
del fragments_reported[:]
try:
with with_reporter(fragments_reported.append):
state.execute_once(
ArtificialDataForExample(example_kwargs),
is_final=True,
print_example=True,
)
except UnsatisfiedAssumption:
# Odd though it seems, we deliberately support explicit examples that
# are then rejected by a call to `assume()`. As well as iterative
# development, this is rather useful to replay Hypothesis' part of
# a saved failure when other arguments are supplied by e.g. pytest.
# See https://github.com/HypothesisWorks/hypothesis/issues/2125
pass
except BaseException:
report_buffered()
raise
if current_verbosity() >= Verbosity.verbose:
prefix = "Falsifying example"
assert fragments_reported[0].startswith(prefix)
fragments_reported[0] = (
"Trying example" + fragments_reported[0][len(prefix) :]
)
report_buffered()
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():
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(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(self, state_machine, print_steps=None):
if print_steps is None:
print_steps = current_verbosity() >= Verbosity.debug
try:
for i in hrange(self.n_steps):
strategy = state_machine.steps()
template_set = False
if i < len(self.record):
if self.record[i] is TOMBSTONE:
continue
_, data = self.record[i]
data = list(data)
for data_index in hrange(len(data) - 1, -1, -1):
try:
template = strategy.from_basic(data[data_index])
template_set = True
break
except BadData:
pass
if template_set:
data[data_index], data[-1] = (
data[-1], data[data_index]
)
else:
data = []
if not template_set:
parameter = strategy.draw_parameter(Random(
self.parameter_seed
))
template = strategy.draw_template(
Random(self.templates[i]), parameter)
data.append(strategy.to_basic(template))
new_record = (
strategy, data,
)
if i < len(self.record):
self.record[i] = new_record
else:
self.record.append(new_record)
strategy.from_basic(self.record[i][1][-1])
value = strategy.reify(template)
if print_steps:
state_machine.print_step(value)
state_machine.execute_step(value)
finally:
state_machine.teardown()
def run(self, state_machine, print_steps=None):
if print_steps is None:
print_steps = current_verbosity() >= Verbosity.debug
try:
for i in hrange(self.n_steps):
strategy = state_machine.steps()
template_set = False
if i < len(self.record):
if self.record[i] is TOMBSTONE:
continue
_, data = self.record[i]
data = list(data)
for data_index in hrange(len(data) - 1, -1, -1):
try:
template = strategy.from_basic(data[data_index])
template_set = True
break
except BadData:
pass
if template_set:
data[data_index], data[-1] = (
data[-1], data[data_index]
)
else:
data = []
if not template_set:
parameter = strategy.draw_parameter(Random(
self.parameter_seed
))
template = strategy.draw_template(
Random(self.templates[i]), parameter)
data.append(strategy.to_basic(template))
new_record = (
strategy, data,
)
if i < len(self.record):
self.record[i] = new_record
else:
self.record.append(new_record)
strategy.from_basic(self.record[i][1][-1])
value = strategy.reify(template)
if print_steps:
state_machine.print_step(value)
state_machine.execute_step(value)
finally:
state_machine.teardown()
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 set_element(self, data, result, idx, strategy=None):
strategy = strategy or self.element_strategy
val = data.draw(strategy)
result[idx] = val
if self._report_overflow and not self.check_cast(val):
note_deprecation(
'Generated array element %r from %r cannot be represented as '
'dtype %r - instead it becomes %r . Consider using a more '
'precise strategy, as this will be an error in a future '
'version.' % (val, strategy, self.dtype, result[idx]))
# Because the message includes the value of the generated element,
# it would be easy to spam users with thousands of warnings.
# We therefore only warn once per draw, unless in verbose mode.
self._report_overflow = current_verbosity() >= Verbosity.verbose
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 set_element(self, data, result, idx, strategy=None):
strategy = strategy or self.element_strategy
val = data.draw(strategy)
if self._report_overflow and not self.check_cast(val):
note_deprecation(
'Generated array element %r from %r cannot be represented as '
'dtype %r without overflow or underflow. Consider using a '
'more precise strategy, as this will be an error in a future '
'version of Hypothesis.' % (val, strategy, self.dtype)
)
# Because the message includes the value of the generated element,
# it would be easy to spam users with thousands of warnings.
# We therefore only warn once per draw, unless in verbose mode.
self._report_overflow = current_verbosity() >= Verbosity.verbose
result[idx] = val
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 execute_explicit_examples(state, wrapped_test, arguments, kwargs):
original_argspec = getfullargspec(state.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 state.settings.phases:
continue
example_kwargs.update(kwargs)
with local_settings(state.settings):
fragments_reported = []
def report_buffered():
for f in fragments_reported:
report(f)
del fragments_reported[:]
try:
with with_reporter(fragments_reported.append):
state.execute_once(
ArtificialDataForExample(example_kwargs),
is_final=True,
print_example=True,
)
except BaseException:
report_buffered()
raise
if current_verbosity() >= Verbosity.verbose:
prefix = "Falsifying example"
assert fragments_reported[0].startswith(prefix)
fragments_reported[0] = ("Trying example" +
fragments_reported[0][len(prefix):])
report_buffered()
def set_element(self, data, result, idx, strategy=None):
strategy = strategy or self.element_strategy
val = data.draw(strategy)
result[idx] = val
if self._report_overflow and val != result[idx] and val == val:
note_deprecation(
"Generated array element %r from %r cannot be represented as "
"dtype %r - instead it becomes %r (type %r). Consider using a more "
"precise strategy, for example passing the `width` argument to "
"`floats()`, as this will be an error in a future version."
% (val, strategy, self.dtype, result[idx], type(result[idx])),
since="2019-07-28",
)
# Because the message includes the value of the generated element,
# it would be easy to spam users with thousands of warnings.
# We therefore only warn once per draw, unless in verbose mode.
self._report_overflow = current_verbosity() >= Verbosity.verbose
def run_state_machine(factory, data):
machine = factory()
if isinstance(machine, GenericStateMachine) and not isinstance(
machine, RuleBasedStateMachine):
note_deprecation(
"%s inherits from GenericStateMachine, which is deprecated. Use a "
"RuleBasedStateMachine, or a test function with st.data(), instead."
% (type(machine).__name__, ),
since="2019-05-29",
)
else:
check_type(RuleBasedStateMachine, machine,
"state_machine_factory()")
data.conjecture_data.hypothesis_runner = machine
n_steps = settings.stateful_step_count
should_continue = cu.many(data.conjecture_data,
min_size=1,
max_size=n_steps,
average_size=n_steps)
print_steps = (current_build_context().is_final
or current_verbosity() >= Verbosity.debug)
try:
if print_steps:
machine.print_start()
machine.check_invariants()
while should_continue.more():
value = data.conjecture_data.draw(machine.steps())
# Assign 'result' here in case 'execute_step' fails below
result = multiple()
try:
result = machine.execute_step(value)
finally:
if print_steps:
# 'result' is only used if the step has target bundles.
# If it does, and the result is a 'MultipleResult',
# then 'print_step' prints a multi-variable assignment.
machine.print_step(value, result)
machine.check_invariants()
finally:
if print_steps:
machine.print_end()
machine.teardown()
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 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(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 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
)
)
)
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(self, state_machine, print_steps=None):
if print_steps is None:
print_steps = current_verbosity() >= Verbosity.debug
try:
for i in hrange(self.n_steps):
strategy = state_machine.steps()
template_set = False
if i < len(self.record):
if self.record[i] is TOMBSTONE:
continue
_, data = self.record[i]
try:
template = strategy.from_basic(data)
template_set = True
except BadData:
pass
if not template_set:
parameter = strategy.draw_parameter(Random(
self.parameter_seed
))
template = strategy.draw_template(
BuildContext(Random(self.templates[i])), parameter)
new_record = (
strategy, strategy.to_basic(template)
)
if i < len(self.record):
self.record[i] = new_record
else:
self.record.append(new_record)
value = strategy.reify(template)
if print_steps:
state_machine.print_step(value)
state_machine.execute_step(value)
finally:
state_machine.teardown()
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 run_state_machine(factory, data):
machine = factory()
if isinstance(machine, GenericStateMachine) and not isinstance(
machine, RuleBasedStateMachine
):
note_deprecation(
"%s inherits from GenericStateMachine, which is deprecated. Use a "
"RuleBasedStateMachine, or a test function with st.data(), instead."
% (type(machine).__name__,),
since="2019-05-29",
)
else:
check_type(RuleBasedStateMachine, machine, "state_machine_factory()")
data.conjecture_data.hypothesis_runner = machine
n_steps = settings.stateful_step_count
should_continue = cu.many(
data.conjecture_data, min_size=1, max_size=n_steps, average_size=n_steps
)
print_steps = (
current_build_context().is_final or current_verbosity() >= Verbosity.debug
)
try:
if print_steps:
machine.print_start()
machine.check_invariants()
while should_continue.more():
value = data.conjecture_data.draw(machine.steps())
if print_steps:
machine.print_step(value)
machine.execute_step(value)
machine.check_invariants()
finally:
if print_steps:
machine.print_end()
machine.teardown()
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(self, state_machine, print_steps=None):
if print_steps is None:
print_steps = current_verbosity() >= Verbosity.debug
stopping_value = 1 - 1.0 / (1 + self.n_steps * 0.5)
try:
steps = 0
while True:
if steps == self.n_steps:
stopping_value = 0
self.data.start_example()
if not cu.biased_coin(self.data, stopping_value):
self.data.stop_example()
break
value = self.data.draw(state_machine.steps())
steps += 1
if steps <= self.n_steps:
if print_steps:
state_machine.print_step(value)
state_machine.execute_step(value)
self.data.stop_example()
finally:
state_machine.teardown()
def run_state_machine(factory, data):
cd = data.conjecture_data
machine = factory()
check_type(RuleBasedStateMachine, machine, "state_machine_factory()")
cd.hypothesis_runner = machine
print_steps = (current_build_context().is_final
or current_verbosity() >= Verbosity.debug)
try:
if print_steps:
report("state = %s()" % (machine.__class__.__name__, ))
machine.check_invariants()
max_steps = settings.stateful_step_count
steps_run = 0
while True:
# We basically always want to run the maximum number of steps,
# but need to leave a small probability of terminating early
# in order to allow for reducing the number of steps once we
# find a failing test case, so we stop with probability of
# 2 ** -16 during normal operation but force a stop when we've
# generated enough steps.
cd.start_example(STATE_MACHINE_RUN_LABEL)
if steps_run == 0:
cd.draw_bits(16, forced=1)
elif steps_run >= max_steps:
cd.draw_bits(16, forced=0)
break
else:
# All we really care about is whether this value is zero
# or non-zero, so if it's > 1 we discard it and insert a
# replacement value after
cd.start_example(SHOULD_CONTINUE_LABEL)
should_continue_value = cd.draw_bits(16)
if should_continue_value > 1:
cd.stop_example(discard=True)
cd.draw_bits(16,
forced=int(bool(should_continue_value)))
else:
cd.stop_example()
if should_continue_value == 0:
break
steps_run += 1
# Choose a rule to run, preferring an initialize rule if there are
# any which have not been run yet.
if machine._initialize_rules_to_run:
init_rules = [
st.tuples(st.just(rule),
st.fixed_dictionaries(rule.arguments))
for rule in machine._initialize_rules_to_run
]
rule, data = cd.draw(st.one_of(init_rules))
machine._initialize_rules_to_run.remove(rule)
else:
rule, data = cd.draw(machine._rules_strategy)
# Pretty-print the values this rule was called with *before* calling
# _add_result_to_targets, to avoid printing arguments which are also
# a return value using the variable name they are assigned to.
# See https://github.com/HypothesisWorks/hypothesis/issues/2341
if print_steps:
data_to_print = {
k: machine._pretty_print(v)
for k, v in data.items()
}
# Assign 'result' here in case executing the rule fails below
result = multiple()
try:
data = dict(data)
for k, v in list(data.items()):
if isinstance(v, VarReference):
data[k] = machine.names_to_values[v.name]
result = rule.function(machine, **data)
if rule.targets:
if isinstance(result, MultipleResults):
for single_result in result.values:
machine._add_result_to_targets(
rule.targets, single_result)
else:
machine._add_result_to_targets(
rule.targets, result)
finally:
if print_steps:
# 'result' is only used if the step has target bundles.
# If it does, and the result is a 'MultipleResult',
# then 'print_step' prints a multi-variable assignment.
machine._print_step(rule, data_to_print, result)
machine.check_invariants()
cd.stop_example()
finally:
if print_steps:
report("state.teardown()")
machine.teardown()
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 run_state_machine(factory, data):
machine = factory()
if not isinstance(machine, _GenericStateMachine):
raise InvalidArgument(
"Expected RuleBasedStateMachine but state_machine_factory() "
"returned %r (type=%s)" % (machine, type(machine).__name__))
data.conjecture_data.hypothesis_runner = machine
print_steps = (current_build_context().is_final
or current_verbosity() >= Verbosity.debug)
try:
if print_steps:
machine.print_start()
machine.check_invariants()
max_steps = settings.stateful_step_count
steps_run = 0
cd = data.conjecture_data
while True:
# We basically always want to run the maximum number of steps,
# but need to leave a small probability of terminating early
# in order to allow for reducing the number of steps once we
# find a failing test case, so we stop with probability of
# 2 ** -16 during normal operation but force a stop when we've
# generated enough steps.
cd.start_example(STATE_MACHINE_RUN_LABEL)
if steps_run == 0:
cd.draw_bits(16, forced=1)
elif steps_run >= max_steps:
cd.draw_bits(16, forced=0)
break
else:
# All we really care about is whether this value is zero
# or non-zero, so if it's > 1 we discard it and insert a
# replacement value after
cd.start_example(SHOULD_CONTINUE_LABEL)
should_continue_value = cd.draw_bits(16)
if should_continue_value > 1:
cd.stop_example(discard=True)
cd.draw_bits(16,
forced=int(bool(should_continue_value)))
else:
cd.stop_example()
if should_continue_value == 0:
break
steps_run += 1
value = data.conjecture_data.draw(machine.steps())
# Assign 'result' here in case 'execute_step' fails below
result = multiple()
try:
result = machine.execute_step(value)
finally:
if print_steps:
# 'result' is only used if the step has target bundles.
# If it does, and the result is a 'MultipleResult',
# then 'print_step' prints a multi-variable assignment.
machine.print_step(value, result)
machine.check_invariants()
data.conjecture_data.stop_example()
finally:
if print_steps:
machine.print_end()
machine.teardown()
