def test_does_not_falsify_if_all_args_given(): verifier = Verifier() verifier.falsify = None @given(int, int, verifier=verifier) def foo(x, y): pass foo(1, 2)
def test_a_verifier_retrieves_previous_failing_examples_from_the_database(): database = ExampleDatabase() verifier = Verifier(settings=hs.Settings(database=database)) verifier.falsify(lambda x: x < 11, int) called = [] def save_calls(t): called.append(t) return False verifier2 = Verifier(settings=hs.Settings(database=database)) verifier2.falsify(save_calls, int) assert called[0] == 11 assert all(0 <= x <= 11 for x in called)
from hypothesis.internal.verifier import Verifier hs.Settings.default.max_examples = 1000 TestStandardDescriptorFeatures1 = strategy_test_suite(datetime) TestStandardDescriptorFeatures2 = strategy_test_suite( timezone_aware_datetime) TestStandardDescriptorFeatures3 = strategy_test_suite(naive_datetime) TestStandardDescriptorFeatures4 = strategy_test_suite(one_of(( naive_datetime, timezone_aware_datetime, ))) falsify = Verifier().falsify def test_can_find_after_the_year_2000(): falsify(lambda x: x.year > 2000, datetime) def test_can_find_before_the_year_2000(): falsify(lambda x: x.year < 2000, datetime) def test_can_find_each_month(): for i in hrange(1, 12): falsify(lambda x: x.month != i, datetime)
def test_french_names_may_have_an_accent(): Verifier().falsify(lambda x: 'é' not in x, FakeFactory('name', locale='fr_FR'))
def test_can_falsify_in_derandomize_mode(): settings = Settings(derandomize=True) v = Verifier(settings=settings) v.falsify(lambda x: x > 0, int)
def test_verifier_explodes_when_you_mix_random_and_derandom(): settings = Settings(derandomize=True) with pytest.raises(ValueError): Verifier(settings=settings, random=Random())
# coding=utf-8 # Copyright (C) 2013-2015 David R. MacIver ([email protected]) # This file is part of Hypothesis (https://github.com/DRMacIver/hypothesis) # This Source Code Form is subject to the terms of the Mozilla Public License, # v. 2.0. If a copy of the MPL was not distributed with this file, You can # obtain one at http://mozilla.org/MPL/2.0/. # END HEADER from hypothesis.internal.verifier import Verifier import hypothesis.settings as hs settings = hs.Settings(max_examples=100, timeout=4) small_verifier = Verifier(settings=settings, )
def given(*generator_arguments, **generator_kwargs): """A decorator for turning a test function that accepts arguments into a randomized test. This is the main entry point to Hypothesis. See the full tutorial for details of its behaviour. """ if 'verifier' in generator_kwargs: verifier = generator_kwargs.pop('verifier') verifier.start_time = time.time() else: verifier = Verifier( settings=generator_kwargs.pop('settings', None), random=generator_kwargs.pop('random', None), ) if not (generator_arguments or generator_kwargs): raise InvalidArgument( 'given must be called with at least one argument') def run_test_with_generator(test): original_argspec = inspect.getargspec(test) if original_argspec.varargs: raise InvalidArgument('varargs are not supported with @given') extra_kwargs = [ k for k in generator_kwargs if k not in original_argspec.args ] if extra_kwargs and not original_argspec.keywords: raise InvalidArgument( '%s() got an unexpected keyword argument %r' % (test.__name__, extra_kwargs[0])) if (len(generator_arguments) > len(original_argspec.args)): raise InvalidArgument( ('Too many positional arguments for %s() (got %d but' ' expected at most %d') % (test.__name__, len(generator_arguments), len(original_argspec.args))) arguments = original_argspec.args + sorted(extra_kwargs) specifiers = list(generator_arguments) for a in arguments: if a in generator_kwargs: specifiers.append(generator_kwargs[a]) argspec = inspect.ArgSpec(args=arguments, keywords=original_argspec.keywords, varargs=original_argspec.varargs, defaults=tuple( map(HypothesisProvided, specifiers))) @copy_argspec(test.__name__, argspec) def wrapped_test(*arguments, **kwargs): selfy = None # Because we converted all kwargs to given into real args and # error if we have neither args nor kwargs, this should always # be valid assert argspec.args selfy = kwargs.get(argspec.args[0]) if isinstance(selfy, HypothesisProvided): selfy = None if selfy is not None: setup_example = getattr(selfy, 'setup_example', None) teardown_example = getattr(selfy, 'teardown_example', None) else: setup_example = None teardown_example = None setup_example = setup_example or (lambda: None) teardown_example = teardown_example or (lambda ex: None) 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 setup_example() try: test(*arguments, **kwargs) finally: teardown_example((arguments, kwargs)) return def convert_to_specifier(v): if isinstance(v, HypothesisProvided): return v.value else: return just(v) given_specifier = (tuple(map(convert_to_specifier, arguments)), { k: convert_to_specifier(v) for k, v in kwargs.items() }) def to_falsify(xs): testargs, testkwargs = xs try: test(*testargs, **testkwargs) return True except UnsatisfiedAssumption as e: raise e except Exception: # pylint: disable=broad-except return False to_falsify.__name__ = test.__name__ to_falsify.__qualname__ = getattr(test, '__qualname__', test.__name__) if _debugging_return_failing_example.value: return verifier.falsify( to_falsify, given_specifier, setup_example=setup_example, teardown_example=teardown_example, )[0] try: falsifying_example = verifier.falsify( to_falsify, given_specifier, setup_example=setup_example, teardown_example=teardown_example, )[0] except Unfalsifiable: return try: false_args, false_kwargs = falsifying_example current_reporter()( 'Falsifying example: %s(%s)' % (test.__name__, arg_string( test, false_args, false_kwargs, ))) # We run this one final time so we get good errors # Otherwise we would have swallowed all the reports of it # actually having gone wrong. test(*false_args, **false_kwargs) finally: teardown_example(falsifying_example) # If we get here then something has gone wrong: We found a counter # example but it didn't fail when we invoked it again. raise Flaky(test, falsifying_example) wrapped_test.__name__ = test.__name__ wrapped_test.__doc__ = test.__doc__ wrapped_test.verifier = verifier wrapped_test.is_hypothesis_test = True return wrapped_test return run_test_with_generator
def test_slow_failing_test_1(x): time.sleep(0.05) assert not calls[0] calls[0] = 1 @fails @given(int, settings=timeout_settings) def test_slow_failing_test_2(x): time.sleep(0.05) assert not calls[1] calls[1] = 1 @fails @given(int, verifier=Verifier(settings=timeout_settings)) def test_slow_failing_test_3(x): time.sleep(0.05) assert not calls[2] calls[2] = 1 @fails @given(int, verifier=Verifier(settings=timeout_settings)) def test_slow_failing_test_4(x): time.sleep(0.05) assert not calls[3] calls[3] = 1 @fails
def strategy_test_suite(specifier, max_examples=100, random=None): settings = Settings( database=None, max_examples=max_examples, average_list_length=2.0, ) random = random or Random() verifier = Verifier(settings=settings, random=random) strat = strategy(specifier, settings) specifier_test = given(TemplatesFor(specifier), settings=settings) class ValidationSuite(TestCase): def __repr__(self): return 'strategy_test_suite(%s)' % (show(specifier), ) @given(specifier, settings=settings) def test_does_not_error(self, value): pass def test_can_give_example(self): strat.example() @specifier_test def test_is_basic(self, value): def is_basic(v): return isinstance( v, integer_types + (list, type(None), text_type)) and ( not isinstance(v, list) or all(is_basic(w) for w in v)) supposedly_basic = strat.to_basic(value) self.assertTrue(is_basic(supposedly_basic), repr(supposedly_basic)) @specifier_test def test_can_round_trip_through_the_database(self, template): empty_db = ExampleDatabase(backend=SQLiteBackend(':memory:'), ) try: storage = empty_db.storage_for(specifier) storage.save(template) values = list(storage.fetch()) assert len(values) == 1 assert strat.to_basic(template) == strat.to_basic(values[0]) finally: empty_db.close() @specifier_test def test_template_is_hashable(self, template): hash(template) @specifier_test def test_can_minimize_to_empty(self, template): simplest = list(strat.simplify_such_that(template, lambda x: True))[-1] assert list(strat.simplify(simplest)) == [] @given(Random, verifier=verifier) def test_can_perform_all_basic_operations(self, random): parameter = strat.draw_parameter(random) template = strat.draw_template(BuildContext(random), parameter) minimal_template = list( strat.simplify_such_that(template, lambda x: True))[-1] strat.reify(minimal_template) assert (strat.to_basic(minimal_template) == strat.to_basic( strat.from_basic(strat.to_basic(minimal_template)))) return ValidationSuite
def smallest_tree(predicate): d = NAryTree(int, int, int) strat = strategy(d) v = Verifier() return strat.reify(v.falsify(lambda t: not predicate(t), d)[0])
def smallest_tree(predicate): d = NAryTree(int, int, int) strat = strategy(d) v = Verifier() return strat.reify(v.falsify(lambda t: not predicate(t), d)[0])
def test_a_verifier_can_still_do_its_thing_if_a_saved_example_fails(): database = ExampleDatabase() verifier = Verifier(settings=hs.Settings(database=database)) verifier.falsify(lambda x: x < 11, int) verifier2 = Verifier(settings=hs.Settings(database=database)) verifier2.falsify(lambda x: x < 100, int)
def test_a_verifier_saves_any_failing_examples_in_its_database(): database = ExampleDatabase() verifier = Verifier(settings=hs.Settings(database=database)) counterexample = verifier.falsify(lambda x: x > 0, int) saved = list(database.storage_for((int, )).fetch()) assert saved == [counterexample]