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 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(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(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()