with pytest.raises(ValueError): FakeFactory('spoon') def test_fake_factory_errors_if_private_ish_method(): with pytest.raises(ValueError): FakeFactory('_Generator__config') def test_can_get_specification_for_fake_factory(): ff = FakeFactory('email') strategy(ff) TestFakeEmail = strategy_test_suite( FakeFactory('email') ) TestFakeNames = strategy_test_suite( FakeFactory('name') ) TestFakeEnglishNames = strategy_test_suite( FakeFactory('name', locale='en_US') ) def test_equality(): assert FakeFactory('email') == FakeFactory('email') assert FakeFactory('email') != FakeFactory('name') assert FakeFactory('email') != FakeFactory('email', locale='en_US')
# 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 __future__ import division, print_function, absolute_import, \ unicode_literals import numpy as np import pytest from hypothesis import find, given, strategy from hypothesis.extra.numpy import arrays from hypothesis.strategytests import strategy_test_suite from hypothesis.internal.compat import text_type, binary_type TestFloats = strategy_test_suite(arrays(float, ())) TestIntMatrix = strategy_test_suite(arrays(int, (3, 2))) TestBoolTensor = strategy_test_suite(arrays(bool, (2, 2, 2))) STANDARD_TYPES = list( map(np.dtype, [ 'int8', 'int32', 'int64', 'float', 'float32', 'float64', complex, bool, text_type, binary_type ])) @pytest.mark.parametrize('t', STANDARD_TYPES) def test_produces_instances(t): @given(t) def test_is_t(x): assert isinstance(x, t.type)
from hypothesis import Settings, strategy from tests.common.basic import Bitfields, BoringBitfields, \ simplify_bitfield from hypothesis.stateful import StateMachineSearchStrategy from hypothesis.strategies import just, none, sets, text, basic, lists, \ binary, builds, floats, one_of, tuples, randoms, booleans, decimals, \ integers, fractions, streaming, frozensets, dictionaries, \ sampled_from, complex_numbers, fixed_dictionaries from hypothesis.strategytests import mutate_basic, templates_for, \ strategy_test_suite from hypothesis.internal.compat import hrange from hypothesis.searchstrategy.narytree import n_ary_tree with Settings(average_list_length=5.0): TestIntegerRange = strategy_test_suite(integers(min_value=0, max_value=5)) TestGiantIntegerRange = strategy_test_suite( integers(min_value=(-(2**129)), max_value=(2**129))) TestFloatRange = strategy_test_suite(floats(min_value=0.5, max_value=10)) TestSampled10 = strategy_test_suite(sampled_from(elements=list(range(10)))) TestSampled1 = strategy_test_suite(sampled_from(elements=(1, ))) TestSampled2 = strategy_test_suite(sampled_from(elements=(1, 2))) TestIntegersFrom = strategy_test_suite(integers(min_value=13)) TestIntegersFrom = strategy_test_suite(integers(min_value=1 << 1024)) TestOneOf = strategy_test_suite(one_of(integers(), integers(), booleans())) TestOneOfSameType = strategy_test_suite( one_of( integers(min_value=1, max_value=10),
# Hypothesis convention is to wrap all strategy production into helper # functions rather than expose strategy classes directly. This isn't strictly # necessary in this case but is generally good practice. def binary_trees(leaves): # The call to strategy is part of the deprecated strategy building API. # Until Hypothesis 2.0 this will work but will emit a warning (error in # strict mode) when called with a non-strategy argument. return BinaryTreeStrategy(strategy(leaves)) # We now want to test our implementation. Hypothesis provides a standard suite # of tests you can run to check that your implementation is working correctly. # We test two examples: One with empty labels, the other with integer labels. TestBinaryTreeOfNone = strategy_test_suite(binary_trees(just(None))) TestBinaryTreeOfInts = strategy_test_suite(binary_trees(integers())) # If we've got to here we should now have a working strategy. Now lets look # at some explicit examples to make sure that everything is simplifying well # and we can find the examples we want to find. # First we'll define some convenience functions that we'll need for delineating # different areas of the search space and testing our results. def labels(tree): """Convenience function for getting all labels out of a tree, no matter how deep they are.""" if isinstance(tree, Leaf):
from __future__ import division, print_function, absolute_import from datetime import MINYEAR import pytz import pytest import hypothesis._settings as hs from hypothesis import given, assume, settings from hypothesis.errors import InvalidArgument from hypothesis.strategytests import strategy_test_suite from hypothesis.extra.datetime import datetimes from hypothesis.internal.debug import minimal from hypothesis.internal.compat import hrange TestStandardDescriptorFeatures1 = strategy_test_suite(datetimes()) TestStandardDescriptorFeatures2 = strategy_test_suite( datetimes(allow_naive=False)) TestStandardDescriptorFeatures3 = strategy_test_suite( datetimes(timezones=[]), ) def test_can_find_after_the_year_2000(): assert minimal(datetimes(), lambda x: x.year > 2000).year == 2001 def test_can_find_before_the_year_2000(): assert minimal(datetimes(), lambda x: x.year < 2000).year == 1999
import math from random import Random from collections import namedtuple from hypothesis.stateful import StateMachineSearchStrategy from hypothesis.strategies import just, none, sets, text, lists, binary, \ builds, floats, one_of, tuples, randoms, booleans, decimals, \ integers, composite, fractions, recursive, streaming, frozensets, \ dictionaries, sampled_from, complex_numbers, fixed_dictionaries from hypothesis.strategytests import mutate_basic, templates_for, \ strategy_test_suite from hypothesis.internal.compat import hrange, OrderedDict from hypothesis.searchstrategy.morphers import MorpherStrategy TestIntegerRange = strategy_test_suite(integers(min_value=0, max_value=5)) TestGiantIntegerRange = strategy_test_suite( integers(min_value=(-(2 ** 129)), max_value=(2 ** 129)) ) TestFloatRange = strategy_test_suite(floats(min_value=0.5, max_value=10)) TestSampled10 = strategy_test_suite(sampled_from(elements=list(range(10)))) TestSampled1 = strategy_test_suite(sampled_from(elements=(1,))) TestSampled2 = strategy_test_suite(sampled_from(elements=(1, 2))) TestIntegersFrom = strategy_test_suite(integers(min_value=13)) TestIntegersFrom = strategy_test_suite(integers(min_value=1 << 1024)) TestOneOf = strategy_test_suite(one_of( integers(), integers(), booleans())) TestOneOfSameType = strategy_test_suite(
from fractions import Fraction from collections import OrderedDict, namedtuple from hypothesis import strategy from tests.common.basic import Bitfields, BoringBitfields, \ simplify_bitfield from hypothesis.specifiers import just, one_of, strings, streaming, \ dictionary, sampled_from, integers_from, floats_in_range, \ integers_in_range from tests.common.specifiers import Descriptor from hypothesis.strategytests import TemplatesFor, strategy_test_suite from hypothesis.internal.compat import text_type, binary_type from hypothesis.searchstrategy.basic import basic_strategy from hypothesis.searchstrategy.narytree import NAryTree TestIntegerRange = strategy_test_suite(integers_in_range(0, 5)) TestGiantIntegerRange = strategy_test_suite( integers_in_range(-(2 ** 129), 2 ** 129) ) TestFloatRange = strategy_test_suite(floats_in_range(0.5, 10)) TestSampled10 = strategy_test_suite(sampled_from(elements=list(range(10)))) TestSampled1 = strategy_test_suite(sampled_from(elements=(1,))) TestSampled2 = strategy_test_suite(sampled_from(elements=(1, 2))) TestIntegersFrom = strategy_test_suite(integers_from(13)) TestOneOf = strategy_test_suite(one_of((int, int, bool))) TestOneOfSameType = strategy_test_suite( one_of((integers_in_range(1, 10), integers_in_range(8, 15))) ) TestRandom = strategy_test_suite(Random)
return simplify_bitfield(random, value) def copy(self, value): return value def popcount(x): # don't judge tot = 0 while x: tot += (x & 1) x >>= 1 return tot TestBoringBitfieldsClass = strategy_test_suite(BoringBitfields) TestBitfieldsClass = strategy_test_suite(Bitfields) TestBitfieldsInstance = strategy_test_suite(Bitfields()) TestBitfields = strategy_test_suite([ basic_strategy( generate=lambda r, p: r.getrandbits(128), simplify=simplify_bitfield, copy=lambda x: x, ) ]) TestBitfieldsSet = strategy_test_suite({ basic_strategy( generate=lambda r, p: r.getrandbits(128), simplify=simplify_bitfield,
# 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 # most interesting tests of this nature are exected in nocover, but we have # a few here to make sure we have coverage of the strategytests module itself. from __future__ import division, print_function, absolute_import, \ unicode_literals from hypothesis.strategies import sets, booleans, integers from hypothesis.strategytests import strategy_test_suite TestBoolSets = strategy_test_suite(sets(booleans())) TestInts = strategy_test_suite(integers())
import datetime as dt import pytest from flaky import flaky from hypothesis import find, given, settings from tests.common.debug import minimal from hypothesis.strategies import none, dates, times, binary, datetimes, \ timedeltas from hypothesis.strategytests import strategy_test_suite from hypothesis.internal.compat import hrange from hypothesis.searchstrategy.datetime import DatetimeStrategy from hypothesis.internal.conjecture.data import Status, StopTest, \ ConjectureData TestStandardDescriptorFeatures_timedeltas1 = strategy_test_suite(timedeltas()) def test_can_find_positive_delta(): assert minimal(timedeltas(), lambda x: x.days > 0) == dt.timedelta(1) def test_can_find_negative_delta(): assert minimal(timedeltas(max_delta=dt.timedelta(10**6)), lambda x: x.days < 0) == dt.timedelta(-1) def test_can_find_on_the_second(): minimal(timedeltas(), lambda x: x.seconds == 0)
# END HEADER from __future__ import division, print_function, absolute_import, \ unicode_literals from random import Random from collections import namedtuple from hypothesis.specifiers import just, one_of, sampled_from, \ floats_in_range, integers_in_range from tests.common.specifiers import Descriptor, DescriptorWithValue from hypothesis.strategytests import TemplatesFor, strategy_test_suite from hypothesis.internal.compat import text_type, binary_type from hypothesis.searchstrategy.narytree import NAryTree TestIntegerRange = strategy_test_suite(integers_in_range(0, 5)) TestFloatRange = strategy_test_suite(floats_in_range(0.5, 10)) TestSampled = strategy_test_suite(sampled_from(elements=(1, 2, 3))) TestOneOf = strategy_test_suite(one_of((int, int, bool))) TestOneOfSameType = strategy_test_suite( one_of((integers_in_range(1, 10), integers_in_range(8, 15))) ) TestRandom = strategy_test_suite(Random) TestInts = strategy_test_suite(int) TestBoolLists = strategy_test_suite([bool]) TestString = strategy_test_suite(text_type) BinaryString = strategy_test_suite(binary_type) TestIntBool = strategy_test_suite((int, bool)) TestFloats = strategy_test_suite(float) TestComplex = strategy_test_suite(complex)
from __future__ import division, print_function, absolute_import import datetime as dt import pytz import pytest from hypothesis import given, assume from hypothesis.errors import InvalidArgument from tests.common.debug import minimal from hypothesis.extra.pytz import timezones from hypothesis.strategies import times, datetimes, sampled_from from hypothesis.strategytests import strategy_test_suite TestStandardDescriptorFeatures1 = strategy_test_suite(timezones()) TestStandardDescriptorFeatures_datetimes2 = strategy_test_suite( datetimes(timezones=timezones())) def test_utc_is_minimal(): assert pytz.UTC is minimal(timezones()) def test_can_generate_non_naive_time(): assert minimal(times(timezones=timezones()), lambda d: d.tzinfo).tzinfo == pytz.UTC def test_can_generate_non_naive_datetime(): assert minimal(datetimes(timezones=timezones()),
from __future__ import division, print_function, absolute_import, \ unicode_literals from itertools import islice import pytest from hypothesis import given, assume from hypothesis.errors import InvalidArgument from hypothesis.specifiers import streaming from hypothesis.utils.show import show from hypothesis.strategytests import strategy_test_suite from hypothesis.internal.debug import minimal, via_database, some_template from hypothesis.internal.compat import text_type, integer_types from hypothesis.searchstrategy.streams import Stream, StreamTemplate TestIntStreams = strategy_test_suite(streaming(int)) TestStreamLists = strategy_test_suite(streaming(int)) TestIntStreamStreams = strategy_test_suite(streaming(streaming(int))) @given([bool]) def test_stream_give_lists(xs): s = Stream(iter(xs)) assert list(s) == xs assert list(s) == xs @given([bool]) def test_can_zip_streams_with_self(xs): s = Stream(iter(xs)) assert list(zip(s, s)) == list(zip(xs, xs))
return simplify_bitfield(random, value) def copy(self, value): return value def popcount(x): # don't judge tot = 0 while x: tot += (x & 1) x >>= 1 return tot TestBoringBitfieldsClass = strategy_test_suite(BoringBitfields) TestBitfieldsClass = strategy_test_suite(Bitfields) TestBitfieldsInstance = strategy_test_suite(Bitfields()) TestBitfields = strategy_test_suite([ basic_strategy( generate=lambda r, p: r.getrandbits(128), simplify=simplify_bitfield, copy=lambda x: x, ) ]) TestBitfieldsSet = strategy_test_suite({ basic_strategy( generate=lambda r, p: r.getrandbits(128),
def test_fake_factory_errors_with_unsupported_locale(): with pytest.raises(ValueError): fake_factory("name", locale="badger_BADGER") def test_fake_factory_errors_if_any_locale_is_unsupported(): with pytest.raises(ValueError): fake_factory("name", locales=["fr_FR", "en_US", "mushroom_MUSHROOM"]) def test_fake_factory_errors_if_unsupported_method(): with pytest.raises(ValueError): fake_factory("spoon") def test_fake_factory_errors_if_private_ish_method(): with pytest.raises(ValueError): fake_factory("_Generator__config") def test_can_get_specification_for_fake_factory(): ff = fake_factory("email") strategy(ff) TestFakeEmail = strategy_test_suite(fake_factory("email")) TestFakeNames = strategy_test_suite(fake_factory("name")) TestFakeEnglishNames = strategy_test_suite(fake_factory("name", locale="en_US"))
from hypothesis import Settings, strategy from tests.common.basic import Bitfields, BoringBitfields, \ simplify_bitfield from hypothesis.stateful import StateMachineSearchStrategy from hypothesis.strategies import just, none, sets, text, basic, lists, \ binary, builds, floats, one_of, tuples, randoms, booleans, decimals, \ integers, fractions, streaming, frozensets, dictionaries, \ sampled_from, complex_numbers, fixed_dictionaries from hypothesis.strategytests import mutate_basic, templates_for, \ strategy_test_suite from hypothesis.internal.compat import hrange from hypothesis.searchstrategy.narytree import n_ary_tree with Settings(average_list_length=5.0): TestIntegerRange = strategy_test_suite(integers(min_value=0, max_value=5)) TestGiantIntegerRange = strategy_test_suite( integers(min_value=(-(2 ** 129)), max_value=(2 ** 129)) ) TestFloatRange = strategy_test_suite(floats(min_value=0.5, max_value=10)) TestSampled10 = strategy_test_suite(sampled_from(elements=list(range(10)))) TestSampled1 = strategy_test_suite(sampled_from(elements=(1,))) TestSampled2 = strategy_test_suite(sampled_from(elements=(1, 2))) TestIntegersFrom = strategy_test_suite(integers(min_value=13)) TestIntegersFrom = strategy_test_suite(integers(min_value=1 << 1024)) TestOneOf = strategy_test_suite(one_of( integers(), integers(), booleans())) TestOneOfSameType = strategy_test_suite(
# # END HEADER from __future__ import division, print_function, absolute_import import numpy as np import pytest import hypothesis.strategies as st from flaky import flaky from hypothesis import find, given, settings from hypothesis.extra.numpy import arrays, from_dtype from hypothesis.strategytests import strategy_test_suite from hypothesis.internal.compat import text_type, binary_type TestFloats = strategy_test_suite(arrays(float, ())) TestIntMatrix = strategy_test_suite(arrays(int, (3, 2))) TestBoolTensor = strategy_test_suite(arrays(bool, (2, 2, 2))) STANDARD_TYPES = list(map(np.dtype, [ u'int8', u'int32', u'int64', u'float', u'float32', u'float64', complex, bool, text_type, binary_type ])) @pytest.mark.parametrize(u't', STANDARD_TYPES) def test_produces_instances(t): @given(from_dtype(t))
from __future__ import division, print_function, absolute_import, \ unicode_literals from random import Random from decimal import Decimal from fractions import Fraction from collections import namedtuple from hypothesis.specifiers import just, one_of, sampled_from, \ integers_from, floats_in_range, integers_in_range from tests.common.specifiers import Descriptor, DescriptorWithValue from hypothesis.strategytests import TemplatesFor, strategy_test_suite from hypothesis.internal.compat import text_type, binary_type from hypothesis.searchstrategy.narytree import NAryTree TestIntegerRange = strategy_test_suite(integers_in_range(0, 5)) TestFloatRange = strategy_test_suite(floats_in_range(0.5, 10)) TestSampled = strategy_test_suite(sampled_from(elements=(1, 2, 3))) TestIntegersFrom = strategy_test_suite(integers_from(13)) TestOneOf = strategy_test_suite(one_of((int, int, bool))) TestOneOfSameType = strategy_test_suite( one_of((integers_in_range(1, 10), integers_in_range(8, 15))) ) TestRandom = strategy_test_suite(Random) TestInts = strategy_test_suite(int) TestBoolLists = strategy_test_suite([bool]) TestString = strategy_test_suite(text_type) BinaryString = strategy_test_suite(binary_type) TestIntBool = strategy_test_suite((int, bool))
# # END HEADER from __future__ import division, print_function, absolute_import import math from collections import Container, namedtuple from hypothesis.strategies import just, none, sets, text, lists, binary, \ builds, floats, one_of, tuples, randoms, booleans, decimals, \ integers, composite, fractions, recursive, frozensets, dictionaries, \ sampled_from, complex_numbers, fixed_dictionaries from hypothesis.strategytests import strategy_test_suite from hypothesis.internal.compat import OrderedDict TestIntegerRange = strategy_test_suite(integers(min_value=0, max_value=5)) TestGiantIntegerRange = strategy_test_suite( integers(min_value=(-(2**129)), max_value=(2**129))) TestFloatRange = strategy_test_suite(floats(min_value=0.5, max_value=10)) TestSampled10 = strategy_test_suite(sampled_from(elements=list(range(10)))) TestSampled1 = strategy_test_suite(sampled_from(elements=(1, ))) TestSampled2 = strategy_test_suite(sampled_from(elements=(1, 2))) TestIntegersFrom = strategy_test_suite(integers(min_value=13)) TestIntegersFrom = strategy_test_suite(integers(min_value=1 << 1024)) TestOneOf = strategy_test_suite(one_of(integers(), integers(), booleans())) TestOneOfSameType = strategy_test_suite( one_of( integers(min_value=1, max_value=10),
unicode_literals from random import Random from decimal import Decimal from fractions import Fraction from collections import OrderedDict, namedtuple from hypothesis import strategy from hypothesis.specifiers import just, one_of, dictionary, sampled_from, \ integers_from, floats_in_range, integers_in_range from tests.common.specifiers import Descriptor, DescriptorWithValue from hypothesis.strategytests import TemplatesFor, strategy_test_suite from hypothesis.internal.compat import text_type, binary_type from hypothesis.searchstrategy.narytree import NAryTree TestIntegerRange = strategy_test_suite(integers_in_range(0, 5)) TestGiantIntegerRange = strategy_test_suite( integers_in_range(-(2**129), 2**129)) TestFloatRange = strategy_test_suite(floats_in_range(0.5, 10)) TestSampled = strategy_test_suite(sampled_from(elements=(1, 2, 3))) TestIntegersFrom = strategy_test_suite(integers_from(13)) TestOneOf = strategy_test_suite(one_of((int, int, bool))) TestOneOfSameType = strategy_test_suite( one_of((integers_in_range(1, 10), integers_in_range(8, 15)))) TestRandom = strategy_test_suite(Random) TestInts = strategy_test_suite(int) TestBoolLists = strategy_test_suite([bool]) TestDictionaries = strategy_test_suite(dictionary((int, int), bool)) TestOrderedDictionaries = strategy_test_suite(dictionary(
from datetime import MAXYEAR, datetime import pytz import pytest import hypothesis.settings as hs from hypothesis import given, assume from hypothesis.strategytests import strategy_test_suite from hypothesis.extra.datetime import datetimes, any_datetime, \ naive_datetime, timezone_aware_datetime from hypothesis.internal.debug import minimal from hypothesis.internal.compat import hrange from hypothesis.searchstrategy.strategies import BadData hs.Settings.default.max_examples = 1000 TestStandardDescriptorFeatures1 = strategy_test_suite(datetimes()) TestStandardDescriptorFeatures2 = strategy_test_suite( datetimes(allow_naive=False)) TestStandardDescriptorFeatures3 = strategy_test_suite( datetimes(timezones=[]), ) def test_can_find_after_the_year_2000(): assert minimal(datetimes(), lambda x: x.year > 2000).year == 2001 def test_can_find_before_the_year_2000(): assert minimal(datetimes(), lambda x: x.year < 2000).year == 1999 def test_can_find_each_month():
unicode_literals from random import Random from decimal import Decimal from fractions import Fraction from collections import OrderedDict, namedtuple from hypothesis import strategy from hypothesis.specifiers import just, one_of, dictionary, sampled_from, \ integers_from, floats_in_range, integers_in_range from tests.common.specifiers import Descriptor, DescriptorWithValue from hypothesis.strategytests import TemplatesFor, strategy_test_suite from hypothesis.internal.compat import text_type, binary_type from hypothesis.searchstrategy.narytree import NAryTree TestIntegerRange = strategy_test_suite(integers_in_range(0, 5)) TestGiantIntegerRange = strategy_test_suite( integers_in_range(-(2 ** 129), 2 ** 129) ) TestFloatRange = strategy_test_suite(floats_in_range(0.5, 10)) TestSampled = strategy_test_suite(sampled_from(elements=(1, 2, 3))) TestIntegersFrom = strategy_test_suite(integers_from(13)) TestOneOf = strategy_test_suite(one_of((int, int, bool))) TestOneOfSameType = strategy_test_suite( one_of((integers_in_range(1, 10), integers_in_range(8, 15))) ) TestRandom = strategy_test_suite(Random) TestInts = strategy_test_suite(int) TestBoolLists = strategy_test_suite([bool])
from datetime import datetime import pytz import hypothesis.settings as hs from hypothesis import given, assume from hypothesis.specifiers import one_of from hypothesis.strategytests import strategy_test_suite from hypothesis.extra.datetime import naive_datetime, \ timezone_aware_datetime from hypothesis.internal.debug import minimal from hypothesis.internal.compat import hrange 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, ))) def test_can_find_after_the_year_2000(): assert minimal(datetime, lambda x: x.year > 2000).year == 2001 def test_can_find_before_the_year_2000(): assert minimal(datetime, lambda x: x.year < 2000).year == 1999
def test_fake_factory_errors_if_unsupported_method(): with pytest.raises(ValueError): FakeFactory('spoon') def test_fake_factory_errors_if_private_ish_method(): with pytest.raises(ValueError): FakeFactory('_Generator__config') def test_can_get_specification_for_fake_factory(): ff = FakeFactory('email') strategy(ff) TestFakeEmail = strategy_test_suite(FakeFactory('email')) TestFakeNames = strategy_test_suite(FakeFactory('name')) TestFakeEnglishNames = strategy_test_suite(FakeFactory('name', locale='en_US')) def test_equality(): assert FakeFactory('email') == FakeFactory('email') assert FakeFactory('email') != FakeFactory('name') assert FakeFactory('email') != FakeFactory('email', locale='en_US') def test_hashing(): x = FakeFactory('email') assert hash(x) == hash(FakeFactory('email'))
from fractions import Fraction from collections import OrderedDict, namedtuple from hypothesis import strategy from tests.common.basic import Bitfields, BoringBitfields, \ simplify_bitfield from hypothesis.specifiers import just, one_of, strings, streaming, \ dictionary, sampled_from, integers_from, floats_in_range, \ integers_in_range from tests.common.specifiers import Descriptor from hypothesis.strategytests import TemplatesFor, strategy_test_suite from hypothesis.internal.compat import text_type, binary_type from hypothesis.searchstrategy.basic import basic_strategy from hypothesis.searchstrategy.narytree import NAryTree TestIntegerRange = strategy_test_suite(integers_in_range(0, 5)) TestGiantIntegerRange = strategy_test_suite( integers_in_range(-(2**129), 2**129)) TestFloatRange = strategy_test_suite(floats_in_range(0.5, 10)) TestSampled10 = strategy_test_suite(sampled_from(elements=list(range(10)))) TestSampled1 = strategy_test_suite(sampled_from(elements=(1, ))) TestSampled2 = strategy_test_suite(sampled_from(elements=(1, 2))) TestIntegersFrom = strategy_test_suite(integers_from(13)) TestOneOf = strategy_test_suite(one_of((int, int, bool))) TestOneOfSameType = strategy_test_suite( one_of((integers_in_range(1, 10), integers_in_range(8, 15)))) TestRandom = strategy_test_suite(Random) TestInts = strategy_test_suite(int) TestBoolLists = strategy_test_suite([bool])
check_length(2, data) return self._make_split(*map(self.from_basic, data)) # Hypothesis convention is to wrap all strategy production into helper # functions rather than expose strategy classes directly. This isn't strictly # necessary in this case but is generally good practice. def binary_trees(leaves): return BinaryTreeStrategy(leaves) # We now want to test our implementation. Hypothesis provides a standard suite # of tests you can run to check that your implementation is working correctly. # We test two examples: One with empty labels, the other with integer labels. TestBinaryTreeOfNone = strategy_test_suite(binary_trees(just(None))) TestBinaryTreeOfInts = strategy_test_suite(binary_trees(integers())) # If we've got to here we should now have a working strategy. Now lets look # at some explicit examples to make sure that everything is simplifying well # and we can find the examples we want to find. # First we'll define some convenience functions that we'll need for delineating # different areas of the search space and testing our results. def labels(tree): """Convenience function for getting all labels out of a tree, no matter how deep they are.""" if isinstance(tree, Leaf):
def test_fake_factory_errors_if_unsupported_method(): with pytest.raises(ValueError): fake_factory(u'spoon') def test_fake_factory_errors_if_private_ish_method(): with pytest.raises(ValueError): fake_factory(u'_Generator__config') def test_can_get_specification_for_fake_factory(): ff = fake_factory(u'email') strategy(ff) TestFakeEmail = strategy_test_suite( fake_factory(u'email') ) TestFakeNames = strategy_test_suite( fake_factory(u'name') ) TestFakeEnglishNames = strategy_test_suite( fake_factory(u'name', locale=u'en_US') ) TestStates = strategy_test_suite( fake_factory(u'state') )
from datetime import datetime import hypothesis.settings as hs from hypothesis import given, assume from hypothesis.specifiers import one_of from hypothesis.strategytests import strategy_test_suite from hypothesis.extra.datetime import naive_datetime, \ timezone_aware_datetime from hypothesis.searchstrategy import strategy from hypothesis.internal.compat import hrange 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)
from __future__ import division, print_function, absolute_import from random import Random import pytz import pytest import hypothesis._settings as hs from hypothesis import given, assume from hypothesis.errors import UnsatisfiedAssumption from hypothesis.strategytests import strategy_test_suite from hypothesis.extra.datetime import times from hypothesis.internal.debug import minimal TestStandardDescriptorFeatures1 = strategy_test_suite(times()) def test_can_find_midnight(): minimal( times(), lambda x: (x.hour == 0 and x.minute == 0 and x.second == 0), ) def test_can_find_non_midnight(): assert minimal(times(), lambda x: x.hour != 0).hour == 1 def test_can_find_off_the_minute(): minimal(times(), lambda x: x.second == 0)
from hypothesis import Settings from tests.common.basic import Bitfields, BoringBitfields, \ simplify_bitfield from hypothesis.stateful import StateMachineSearchStrategy from hypothesis.strategies import just, none, sets, text, basic, lists, \ binary, builds, floats, one_of, tuples, randoms, booleans, decimals, \ integers, composite, fractions, recursive, streaming, frozensets, \ dictionaries, sampled_from, complex_numbers, fixed_dictionaries from hypothesis.strategytests import mutate_basic, templates_for, \ strategy_test_suite from hypothesis.internal.compat import hrange, OrderedDict from hypothesis.searchstrategy.morphers import MorpherStrategy from hypothesis.searchstrategy.narytree import n_ary_tree with Settings(average_list_length=5.0): TestIntegerRange = strategy_test_suite(integers(min_value=0, max_value=5)) TestGiantIntegerRange = strategy_test_suite( integers(min_value=(-(2**129)), max_value=(2**129))) TestFloatRange = strategy_test_suite(floats(min_value=0.5, max_value=10)) TestSampled10 = strategy_test_suite(sampled_from(elements=list(range(10)))) TestSampled1 = strategy_test_suite(sampled_from(elements=(1, ))) TestSampled2 = strategy_test_suite(sampled_from(elements=(1, 2))) TestIntegersFrom = strategy_test_suite(integers(min_value=13)) TestIntegersFrom = strategy_test_suite(integers(min_value=1 << 1024)) TestOneOf = strategy_test_suite(one_of(integers(), integers(), booleans())) TestOneOfSameType = strategy_test_suite( one_of( integers(min_value=1, max_value=10),