def test_min_magnitude_respected(data, mag): c = data.draw(complex_numbers(min_magnitude=mag)) assert ( abs(c.real) >= mag or abs(c.imag) >= mag or abs(c) >= mag * (1 - sys.float_info.epsilon) )
def test_minmax_magnitude_equal(data, mag): val = data.draw(st.complex_numbers(min_magnitude=mag, max_magnitude=mag)) try: assume(abs(val) < float('inf')) assert math.isclose(abs(val), mag) except OverflowError: reject() except AttributeError: pass # Python 2.7.3 does not have math.isclose
def test_minmax_magnitude_equal(data, mag): val = data.draw(st.complex_numbers(min_magnitude=mag, max_magnitude=mag)) try: # Cap magnitude at 10e300 to avoid float overflow, and imprecision # at very large exponents (which makes math.isclose fail) assert math.isclose(abs(val), mag) except OverflowError: reject() except AttributeError: pass # Python 2.7.3 does not have math.isclose
def from_dtype(dtype): # type: (np.dtype) -> st.SearchStrategy[Any] """Creates a strategy which can generate any value of the given dtype.""" check_type(np.dtype, dtype, 'dtype') # Compound datatypes, eg 'f4,f4,f4' if dtype.names is not None: # mapping np.void.type over a strategy is nonsense, so return now. return st.tuples( *[from_dtype(dtype.fields[name][0]) for name in dtype.names]) # Subarray datatypes, eg '(2, 3)i4' if dtype.subdtype is not None: subtype, shape = dtype.subdtype return arrays(subtype, shape) # Scalar datatypes if dtype.kind == u'b': result = st.booleans() # type: SearchStrategy[Any] elif dtype.kind == u'f': if dtype.itemsize == 2: result = st.floats(width=16) elif dtype.itemsize == 4: result = st.floats(width=32) else: result = st.floats() elif dtype.kind == u'c': if dtype.itemsize == 8: float32 = st.floats(width=32) result = st.builds(complex, float32, float32) else: result = st.complex_numbers() elif dtype.kind in (u'S', u'a'): # Numpy strings are null-terminated; only allow round-trippable values. # `itemsize == 0` means 'fixed length determined at array creation' result = st.binary(max_size=dtype.itemsize or None ).filter(lambda b: b[-1:] != b'\0') elif dtype.kind == u'u': result = st.integers(min_value=0, max_value=2 ** (8 * dtype.itemsize) - 1) elif dtype.kind == u'i': overflow = 2 ** (8 * dtype.itemsize - 1) result = st.integers(min_value=-overflow, max_value=overflow - 1) elif dtype.kind == u'U': # Encoded in UTF-32 (four bytes/codepoint) and null-terminated result = st.text(max_size=(dtype.itemsize or 0) // 4 or None ).filter(lambda b: b[-1:] != u'\0') elif dtype.kind in (u'm', u'M'): if '[' in dtype.str: res = st.just(dtype.str.split('[')[-1][:-1]) else: res = st.sampled_from(TIME_RESOLUTIONS) result = st.builds(dtype.type, st.integers(-2**63, 2**63 - 1), res) else: raise InvalidArgument(u'No strategy inference for {}'.format(dtype)) return result.map(dtype.type)
def test_nested_set_complexity(): strat = frozensets(frozensets(complex_numbers())) rnd = Random(0) template = ( ((float('inf'), 1.0), (-1.0325215252103651e-149, 1.0)), ((-1.677443578786644e-309, -1.0), (-2.2250738585072014e-308, 0.0)) ) simplifiers = list(strat.simplifiers(rnd, template)) rnd.shuffle(simplifiers) simplifiers = simplifiers[:10] for simplify in simplifiers: for s in islice(simplify(rnd, template), 50): assert not strat.strictly_simpler(template, s)
def test_flatmap_can_apply_all_inapplicable_simplifiers(): random = Random(1) s = booleans().flatmap(lambda x: complex_numbers() if x else booleans()) source_to_total = {} while len(source_to_total) < 2: t = s.draw_and_produce(random) source_to_total[t.source_template] = t u = source_to_total[False] v = source_to_total[True] s.reify(u) s.reify(v) for p in ((u, v), (v, u)): for simplify in s.simplifiers(random, p[0]): for target in simplify(random, p[1]): assert not s.strictly_simpler(p[1], target)
def from_dtype(dtype): if dtype.kind == u'b': result = st.booleans() elif dtype.kind == u'f': result = st.floats() elif dtype.kind == u'c': result = st.complex_numbers() elif dtype.kind in (u'S', u'a', u'V'): result = st.binary() elif dtype.kind == u'u': result = st.integers( min_value=0, max_value=1 << (4 * dtype.itemsize) - 1) elif dtype.kind == u'i': min_integer = -1 << (4 * dtype.itemsize - 1) result = st.integers(min_value=min_integer, max_value=-min_integer - 1) elif dtype.kind == u'U': result = st.text() else: raise NotImplementedError( u'No strategy implementation for %r' % (dtype,) ) return result.map(dtype.type)
def from_dtype(dtype): # Compound datatypes, eg 'f4,f4,f4' if dtype.names is not None: # mapping np.void.type over a strategy is nonsense, so return now. return st.tuples( *[from_dtype(dtype.fields[name][0]) for name in dtype.names]) # Subarray datatypes, eg '(2, 3)i4' if dtype.subdtype is not None: subtype, shape = dtype.subdtype return arrays(subtype, shape) # Scalar datatypes if dtype.kind == u'b': result = st.booleans() elif dtype.kind == u'f': result = st.floats() elif dtype.kind == u'c': result = st.complex_numbers() elif dtype.kind in (u'S', u'a'): result = st.binary() elif dtype.kind == u'u': result = st.integers( min_value=0, max_value=1 << (4 * dtype.itemsize) - 1) elif dtype.kind == u'i': min_integer = -1 << (4 * dtype.itemsize - 1) result = st.integers(min_value=min_integer, max_value=-min_integer - 1) elif dtype.kind == u'U': result = st.text() elif dtype.kind in (u'm', u'M'): if '[' in dtype.str: res = st.just(dtype.str.split('[')[-1][:-1]) else: res = st.sampled_from(TIME_RESOLUTIONS) result = st.builds(dtype.type, st.integers(-2**63, 2**63 - 1), res) else: raise InvalidArgument(u'No strategy inference for {}'.format(dtype)) return result.map(dtype.type)
def test_minimal_nonzero_real(): assert minimal(complex_numbers(), lambda x: x.real != 0) == 1
def test_minimal_quadrant2(): assert minimal(complex_numbers(), lambda x: x.imag > 0 and x.real < 0) == -1 + 1j
kw = {"elements": st.just(300)} if fill: kw = {"elements": st.nothing(), "fill": kw["elements"]} arr = data.draw(nps.arrays(dtype="int8", shape=(1, ), **kw)) assert arr[0] == (300 % 256) @pytest.mark.parametrize("fill", [False, True]) @pytest.mark.parametrize( "dtype,strat", [ ("float16", st.floats(min_value=65520, allow_infinity=False)), ("float32", st.floats(min_value=10**40, allow_infinity=False)), ( "complex64", st.complex_numbers(min_magnitude=10**300, allow_infinity=False), ), ("U1", st.text(min_size=2, max_size=2)), ("S1", st.binary(min_size=2, max_size=2)), ], ) @fails_with(InvalidArgument) @given(data=st.data()) def test_unrepresentable_elements_are_deprecated(fill, dtype, strat, data): if fill: kw = {"elements": st.nothing(), "fill": strat} else: kw = {"elements": strat} arr = data.draw(nps.arrays(dtype=dtype, shape=(1, ), **kw)) try: # This is a float or complex number, and has overflowed to infinity,
def test_minimal_quadrant3(): assert minimal(complex_numbers(), lambda x: x.imag < 0 and x.real < 0) == -1 - 1j def test_minimal_quadrant4(): assert minimal(complex_numbers(), lambda x: x.imag < 0 and x.real > 0) == 1 - 1j @given(st.data(), st.integers(-5, 5).map(lambda x: 10 ** x)) def test_max_magnitude_respected(data, mag): c = data.draw(complex_numbers(max_magnitude=mag)) assert abs(c) <= mag * (1 + sys.float_info.epsilon) @given(complex_numbers(max_magnitude=0)) def test_max_magnitude_zero(val): assert val == 0 @given(st.data(), st.integers(-5, 5).map(lambda x: 10 ** x)) def test_min_magnitude_respected(data, mag): c = data.draw(complex_numbers(min_magnitude=mag)) assert ( abs(c.real) >= mag or abs(c.imag) >= mag or abs(c) >= mag * (1 - sys.float_info.epsilon) ) def test_minimal_min_magnitude_zero():
_normalized_signal_parameters = {"channels": stn.arrays(dtype=numpy.float64, # pylint: disable=no-value-for-parameter; there is a false alarm about a missing parameter for ``draw`` shape=stn.array_shapes(min_dims=2, max_dims=2), elements=st.floats(min_value=-255.0 / 256.0, max_value=254.0 / 256.0)), # pylint: disable=line-too-long "sampling_rate": sampling_rates, "offset": st.integers(min_value=-2 ** 24, max_value=2 ** 24), "labels": st.lists(elements=texts)} normalized_signal_parameters = st.fixed_dictionaries(_normalized_signal_parameters) normalized_signals = st.builds(sumpf.Signal, **_normalized_signal_parameters) ############ # Spectrum # ############ _spectrum_parameters = {"channels": stn.arrays(dtype=numpy.complex128, # pylint: disable=no-value-for-parameter; there is a false alarm about a missing parameter for ``draw`` shape=stn.array_shapes(min_dims=2, max_dims=2), elements=st.complex_numbers(max_magnitude=1e100, allow_nan=False, allow_infinity=False)), # pylint: disable=line-too-long "resolution": resolutions, "labels": st.lists(elements=texts)} spectrum_parameters = st.fixed_dictionaries(_spectrum_parameters) spectrums = st.builds(sumpf.Spectrum, **_spectrum_parameters) ############### # Spectrogram # ############### _spectrogram_parameters = {"channels": stn.arrays(dtype=numpy.complex128, # pylint: disable=no-value-for-parameter; there is a false alarm about a missing parameter for ``draw`` shape=stn.array_shapes(min_dims=3, max_dims=3), elements=st.complex_numbers(max_magnitude=1e100, allow_nan=False, allow_infinity=False)), # pylint: disable=line-too-long "resolution": resolutions, "sampling_rate": sampling_rates, "offset": st.integers(min_value=-2 ** 24, max_value=2 ** 24),
# END HEADER from __future__ import division, print_function, absolute_import, \ unicode_literals import pytest from hypothesis.strategies import just, sets, text, lists, binary, \ floats, one_of, tuples, randoms, booleans, integers, frozensets, \ sampled_from, complex_numbers, fixed_dictionaries from hypothesis.searchstrategy.narytree import n_ary_tree from hypothesis.searchstrategy.strategies import BadData, strategy @pytest.mark.parametrize(('specifier', 'data'), [ (sets(text()), 0j), (complex_numbers(), set('hi')), (lists(sets(booleans())), 0), (just(1), 'hi'), (binary(), 0.0), (binary(), frozenset()), (fixed_dictionaries({True: sets(integers())}), []), (randoms(), []), (integers(), ''), (integers(), [0, '']), (text(), 'kittens'), (tuples(integers(), integers(), integers()), (1, 2)), (sampled_from((1, 2, 3)), 'fish'), (sampled_from((1, 2, 3)), 5), (sampled_from((1, 2, 3)), -2), (one_of(integers(), floats()), 1), (one_of(integers(), floats()), 'tv'),
def test_minimal_nonzero_imaginary(): assert minimal(complex_numbers(), lambda x: x.imag != 0) == 1j
def test_repr_has_specifier_in_it(): suite = TestComplex( u'test_can_round_trip_through_the_database') assert repr(suite) == u'strategy_test_suite(%r)' % (complex_numbers(),)
def test_minimal(): assert minimal(complex_numbers(), lambda x: True) == 0
assert minimal(complex_numbers(), lambda x: x.imag < 0 and x.real < 0) == -1 - 1j def test_minimal_quadrant4(): assert minimal(complex_numbers(), lambda x: x.imag < 0 and x.real > 0) == 1 - 1j @given(st.data(), st.integers(-5, 5).map(lambda x: 10**x)) def test_max_magnitude_respected(data, mag): c = data.draw(complex_numbers(max_magnitude=mag)) assert abs(c) <= mag * (1 + sys.float_info.epsilon) @given(complex_numbers(max_magnitude=0)) def test_max_magnitude_zero(val): assert val == 0 @given(st.data(), st.integers(-5, 5).map(lambda x: 10**x)) def test_min_magnitude_respected(data, mag): c = data.draw(complex_numbers(min_magnitude=mag)) assert (abs(c.real) >= mag or abs(c.imag) >= mag or abs(c) >= mag * (1 - sys.float_info.epsilon)) def test_minimal_min_magnitude_zero(): assert minimal(complex_numbers(min_magnitude=0), lambda x: True) == 0
(-1.0, False), (True, False), (False, False), (dict(), False), ([], False), (tuple(), False), (object(), False), ], ) def test_is_integer(obj, expected): assert is_integer(obj) is expected @pytest.mark.skipif( PY2, reason="This hypothesis test hangs occasionally on Python 2") @given(obj=st.one_of( st.none(), st.booleans(), st.text(), st.complex_numbers(), st.dates(), st.integers(), st.decimals(), st.lists(st.text()), st.dictionaries(st.text(), st.text()), )) @settings(max_examples=100) def test_maybe_stringify(obj): assert type(maybe_stringify(obj)) is (obj is not None and six.text_type or type(None))
def test_can_find_standard_complex_numbers(): find(complex_numbers(), lambda x: x.imag != 0) == 0j find(complex_numbers(), lambda x: x.real != 0) == 1
def test_max_magnitude_respected(data, mag): c = data.draw(complex_numbers(max_magnitude=mag)) assert abs(c) <= mag * (1 + sys.float_info.epsilon)
def test_minimal_quadrant1(): assert minimal(complex_numbers(), lambda x: x.imag > 0 and x.real > 0) == 1 + 1j
@given(st.data()) def test_overflowing_integers_are_deprecated(fill, data): kw = dict(elements=st.just(300)) if fill: kw = dict(elements=st.nothing(), fill=kw["elements"]) arr = data.draw(nps.arrays(dtype="int8", shape=(1,), **kw)) assert arr[0] == (300 % 256) @pytest.mark.parametrize("fill", [False, True]) @pytest.mark.parametrize( "dtype,strat", [ ("float16", st.floats(min_value=65520, allow_infinity=False)), ("float32", st.floats(min_value=10 ** 40, allow_infinity=False)), ("complex64", st.complex_numbers(10 ** 300, allow_infinity=False)), ("U1", st.text(min_size=2, max_size=2)), ("S1", st.binary(min_size=2, max_size=2)), ], ) @checks_deprecated_behaviour @given(data=st.data()) def test_unrepresentable_elements_are_deprecated(fill, dtype, strat, data): if fill: kw = dict(elements=st.nothing(), fill=strat) else: kw = dict(elements=strat) arr = data.draw(nps.arrays(dtype=dtype, shape=(1,), **kw)) try: # This is a float or complex number, and has overflowed to infinity, # triggering our deprecation for overflow.
if sum(try_issubclass(k, T) for T in mapping) == 1] empty = ', '.join(repr(s) for s in strategies if s.is_empty) if empty or not strategies: # pragma: no cover raise ResolutionFailed( 'Could not resolve %s to a strategy; consider using ' 'register_type_strategy' % (empty or thing,)) return st.one_of(strategies) _global_type_lookup = { # Types with core Hypothesis strategies type(None): st.none(), bool: st.booleans(), int: st.integers(), float: st.floats(), complex: st.complex_numbers(), fractions.Fraction: st.fractions(), decimal.Decimal: st.decimals(), text_type: st.text(), bytes: st.binary(), datetime.datetime: st.datetimes(), datetime.date: st.dates(), datetime.time: st.times(), datetime.timedelta: st.timedeltas(), uuid.UUID: st.uuids(), tuple: st.builds(tuple), list: st.builds(list), set: st.builds(set), frozenset: st.builds(frozenset), dict: st.builds(dict), # Built-in types
def complex_numbers(min_magnitude=0., max_magnitude=1e16, allow_nan=ALLOW_NAN, allow_infinity=ALLOW_INFINITY): return hps.complex_numbers(min_magnitude, max_magnitude, allow_nan, allow_infinity)
floats(), floats(min_value=-2.0, max_value=3.0), floats(), floats(min_value=-2.0), floats(), floats(max_value=-0.0), floats(), floats(min_value=0.0), floats(min_value=3.14, max_value=3.14), text(), binary(), booleans(), tuples(booleans(), booleans()), frozensets(integers()), sets(frozensets(booleans())), complex_numbers(), fractions(), decimals(), lists(lists(booleans())), lists(lists(booleans(), average_size=100)), lists(floats(0.0, 0.0), average_size=1.0), ordered_pair, constant_list(integers()), streaming(integers()).map(lambda x: list(x[:2]) and x), integers().filter(lambda x: abs(x) > 100), floats(min_value=-sys.float_info.max, max_value=sys.float_info.max), none(), randoms(), tuples().flatmap(lambda x: EvalledIntStream), templates_for(integers(min_value=0, max_value=0).flatmap(lambda x: integers(min_value=0, max_value=0))), booleans().flatmap(lambda x: booleans() if x else complex_numbers()),
st.dates, st.datetimes, partial(st.characters, **ST_CODEPOINT_LIMIT), partial(st.text, st.characters(**ST_CODEPOINT_LIMIT)) # type: ignore ) ST_TYPES_FLOAT_NAN: tp.Tuple[st.SearchStrategy, ...] = ( st.floats, st.complex_numbers, ) filter_nan = lambda x: not np.isnan(x) ST_TYPES_FLOAT_NO_NAN: tp.Tuple[tp.Callable[[], st.SearchStrategy], ...] = ( lambda: st.floats().filter(filter_nan), lambda: st.complex_numbers().filter(filter_nan)) ST_TYPES_UNARY_BINARY = (st.booleans, st.none) # common collections ST_TYPES_FOR_UNIQUE = ST_TYPES_FLOAT_NO_NAN + ST_TYPES_COMMON ST_TYPES_FOR_UNIQUE_MIXED = ST_TYPES_FLOAT_NO_NAN + ST_TYPES_COMMON + ST_TYPES_UNARY_BINARY ST_VALUE = ST_TYPES_FLOAT_NAN + ST_TYPES_COMMON + ST_TYPES_UNARY_BINARY def get_value() -> st.SearchStrategy: ''' Any plausible value. ''' return st.one_of(strat() for strat in ST_VALUE)
""" from __future__ import print_function from functools import wraps import logging from hypothesis import given, strategies as st, settings, Verbosity from gc import collect as gc import traceback import sys from time import time from stricttuple import stricttuple __all__ = 'battle_tested', 'fuzz', 'disable_traceback', 'enable_traceback', 'garbage', 'crash_map', 'success_map', 'results', 'stats', 'print_stats' garbage = (st.binary(), st.booleans(), st.characters(), st.complex_numbers(), st.decimals(), st.floats(), st.fractions(), st.integers(), st.none(), st.random_module(), st.randoms(), st.text(), st.tuples(), st.uuids(), st.dictionaries(keys=st.text(), values=st.text())) garbage += ( # iterables st.lists(elements=st.one_of(*garbage)), st.iterables(elements=st.one_of(*garbage)), st.dictionaries(keys=st.text(), values=st.one_of(*garbage))) garbage = st.one_of(*garbage) def is_py3(): return sys.version_info >= (3, 0)
def test_minimal_min_magnitude_zero(): assert minimal(complex_numbers(min_magnitude=0), lambda x: True) == 0
size_strategies = dict( min_size=st.integers(min_value=0, max_value=100) | st.none(), max_size=st.integers(min_value=0, max_value=100) | st.none(), average_size=st.floats(min_value=0.0, max_value=100.0) | st.none() ) values = st.integers() | st.text(average_size=2.0) Strategies = st.recursive( st.one_of( st.sampled_from([ st.none(), st.booleans(), st.randoms(), st.complex_numbers(), st.randoms(), st.fractions(), st.decimals(), ]), st.builds(st.just, values), st.builds(st.sampled_from, st.lists(values, min_size=1)), builds_ignoring_invalid(st.floats, st.floats(), st.floats()), ), lambda x: st.one_of( builds_ignoring_invalid(st.lists, x, **size_strategies), builds_ignoring_invalid(st.sets, x, **size_strategies), builds_ignoring_invalid( lambda v: st.tuples(*v), st.lists(x, average_size=2.0)), builds_ignoring_invalid( lambda v: st.one_of(*v), st.lists(x, average_size=2.0, min_size=1)), builds_ignoring_invalid(
def test_minimal_min_magnitude_positive(): assert minimal(complex_numbers(min_magnitude=0.5), lambda x: True) in (0.5, 1)
try_issubclass(k, T) for T in mapping) == 1 ] empty = ', '.join(repr(s) for s in strategies if s.is_empty) if empty or not strategies: # pragma: no cover raise ResolutionFailed( 'Could not resolve %s to a strategy; consider using ' 'register_type_strategy' % (empty or thing, )) return st.one_of(strategies) _global_type_lookup = { # Types with core Hypothesis strategies type(None): st.none(), bool: st.booleans(), float: st.floats(), complex: st.complex_numbers(), fractions.Fraction: st.fractions(), decimal.Decimal: st.decimals(), text_type: st.text(), bytes: st.binary(), datetime.datetime: st.datetimes(), datetime.date: st.dates(), datetime.time: st.times(), datetime.timedelta: st.timedeltas(), uuid.UUID: st.uuids(), tuple: st.builds(tuple), list: st.builds(list), set: st.builds(set), frozenset: st.builds(frozenset), dict: st.builds(dict), # Built-in types
integers(min_value=(-(2 ** 32)), max_value=(2 ** 64)), floats(), floats(min_value=-2.0, max_value=3.0), floats(), floats(min_value=-2.0), floats(), floats(max_value=-0.0), floats(), floats(min_value=0.0), floats(min_value=3.14, max_value=3.14), text(), binary(), booleans(), tuples(booleans(), booleans()), frozensets(integers()), sets(frozensets(booleans())), complex_numbers(), fractions(), decimals(), lists(lists(booleans())), lists(floats(0.0, 0.0)), ordered_pair, constant_list(integers()), integers().filter(lambda x: abs(x) > 100), floats(min_value=-sys.float_info.max, max_value=sys.float_info.max), none(), randoms(), booleans().flatmap(lambda x: booleans() if x else complex_numbers()), recursive(base=booleans(), extend=lambda x: lists(x, max_size=3), max_leaves=10), ]
def test_minimal_quadrant4(): assert minimal(complex_numbers(), lambda x: x.imag < 0 and x.real > 0) == 1 - 1j
) ) TestRandom = strategy_test_suite(randoms()) TestInts = strategy_test_suite(integers()) TestBoolLists = strategy_test_suite(lists(booleans(), average_size=5.0)) TestDictionaries = strategy_test_suite( dictionaries(keys=tuples(integers(), integers()), values=booleans())) TestOrderedDictionaries = strategy_test_suite( dictionaries( keys=integers(), values=integers(), dict_class=OrderedDict)) TestString = strategy_test_suite(text()) BinaryString = strategy_test_suite(binary()) TestIntBool = strategy_test_suite(tuples(integers(), booleans())) TestFloats = strategy_test_suite(floats()) TestComplex = strategy_test_suite(complex_numbers()) TestJust = strategy_test_suite(just(u'hi')) TestTemplates = strategy_test_suite(templates_for(sets(integers()))) TestEmptyString = strategy_test_suite(text(alphabet=u'')) TestSingleString = strategy_test_suite( text(alphabet=u'a', average_size=10.0)) TestManyString = strategy_test_suite(text(alphabet=u'abcdef☃')) Stuff = namedtuple(u'Stuff', (u'a', u'b')) TestNamedTuple = strategy_test_suite( builds(Stuff, integers(), integers())) TestMixedSets = strategy_test_suite(sets( one_of(integers(), booleans(), floats()))) TestFrozenSets = strategy_test_suite(frozensets(booleans()))
def test_repr_has_specifier_in_it(): suite = TestComplex( u'test_will_find_a_constant_failure') assert repr(suite) == u'strategy_test_suite(%r)' % (complex_numbers(),)
integers(min_value=8, max_value=15), ) ) TestRandom = strategy_test_suite(randoms()) TestInts = strategy_test_suite(integers()) TestBoolLists = strategy_test_suite(lists(booleans())) TestDictionaries = strategy_test_suite( dictionaries(keys=tuples(integers(), integers()), values=booleans())) TestOrderedDictionaries = strategy_test_suite( dictionaries( keys=integers(), values=integers(), dict_class=OrderedDict)) TestString = strategy_test_suite(text()) BinaryString = strategy_test_suite(binary()) TestIntBool = strategy_test_suite(tuples(integers(), booleans())) TestFloats = strategy_test_suite(floats()) TestComplex = strategy_test_suite(complex_numbers()) TestJust = strategy_test_suite(just(u'hi')) TestTemplates = strategy_test_suite(templates_for(sets(integers()))) TestEmptyString = strategy_test_suite(text(alphabet=u'')) TestSingleString = strategy_test_suite(strategy( text(alphabet=u'a'), Settings(average_list_length=10.0))) TestManyString = strategy_test_suite(text(alphabet=u'abcdef☃')) Stuff = namedtuple(u'Stuff', (u'a', u'b')) TestNamedTuple = strategy_test_suite( builds(Stuff, integers(), integers())) TestTrees = strategy_test_suite( n_ary_tree(integers(), integers(), integers()))
def test_minimal_min_magnitude_none(): assert minimal(complex_numbers(min_magnitude=None), lambda x: True) == 0
def define_complex_strategy(specifier, settings): return st.complex_numbers()
def test_minimal_minmax_magnitude(): assert minimal( complex_numbers(min_magnitude=0.5, max_magnitude=1.5), lambda x: True ) in (0.5, 1)
# END HEADER from __future__ import division, print_function, absolute_import, \ unicode_literals import pytest from hypothesis.strategies import just, sets, text, lists, binary, \ floats, one_of, tuples, randoms, booleans, integers, frozensets, \ sampled_from, complex_numbers, fixed_dictionaries from hypothesis.searchstrategy.narytree import n_ary_tree from hypothesis.searchstrategy.strategies import BadData, strategy @pytest.mark.parametrize(('specifier', 'data'), [ (sets(text()), 0j), (complex_numbers(), {'hi'}), (lists(sets(booleans())), 0), (just(1), 'hi'), (binary(), 0.0), (binary(), frozenset()), (fixed_dictionaries({True: sets(integers())}), []), (randoms(), []), (integers(), ''), (integers(), [0, '']), (text(), 'kittens'), (tuples(integers(), integers(), integers()), (1, 2)), (sampled_from((1, 2, 3)), 'fish'), (sampled_from((1, 2, 3)), 5), (sampled_from((1, 2, 3)), -2), (one_of(integers(), floats()), 1), (one_of(integers(), floats()), 'tv'),
class HypothesisSpec(RuleBasedStateMachine): def __init__(self): super(HypothesisSpec, self).__init__() self.database = None strategies = Bundle('strategy') strategy_tuples = Bundle('tuples') objects = Bundle('objects') streaming_strategies = Bundle('streams') basic_data = Bundle('basic') varied_floats = Bundle('varied_floats') strats_with_parameters = Bundle('strats_with_parameters') strats_with_templates = Bundle('strats_with_templates') strats_with_2_templates = Bundle('strats_with_2_templates') def teardown(self): self.clear_database() @rule(target=basic_data, st=strats_with_templates) def to_basic(self, st): return st[0].to_basic(st[1]) @rule(data=basic_data, strat=strategies) def from_basic(self, data, strat): try: template = strat.from_basic(data) except BadData: return strat.reify(template) @rule(target=basic_data, data=basic_data, r=randoms()) def mess_with_basic(self, data, r): return mutate_basic(data, r) @rule() def clear_database(self): if self.database is not None: self.database.close() self.database = None @rule() def set_database(self): self.teardown() self.database = ExampleDatabase() @rule(st=strats_with_templates) def reify(self, st): strat, temp = st strat.reify(temp) @rule(target=strats_with_templates, st=strats_with_templates) def via_basic(self, st): strat, temp = st temp = strat.from_basic(strat.to_basic(temp)) return (strat, temp) @rule(targets=(strategies, streaming_strategies), strat=strategies) def build_stream(self, strat): return strategy(streaming(strat)) @rule(targets=(strategies, streaming_strategies), strat=strategies, i=integers(1, 10)) def evalled_stream(self, strat, i): return strategy(streaming(strat)).map(lambda x: list(x[:i]) and x) @rule(stream_strat=streaming_strategies, index=integers(0, 50)) def eval_stream(self, stream_strat, index): try: stream = stream_strat.example() list(stream[:index]) except NoExamples: pass @rule(target=strats_with_templates, st=strats_with_templates, r=randoms()) def simplify(self, st, r): strat, temp = st for temp in strat.full_simplify(r, temp): break return (strat, temp) @rule(strat=strategies, r=randoms(), mshr=integers(0, 100)) def find_constant_failure(self, strat, r, mshr): with Settings( verbosity=Verbosity.quiet, max_examples=1, min_satisfying_examples=0, database=self.database, max_shrinks=mshr, ): @given( strat, random=r, ) def test(x): assert False try: test() except AssertionError: pass @rule(strat=strategies, r=randoms(), p=floats(0, 1), mex=integers(1, 10), mshr=integers(1, 100)) def find_weird_failure(self, strat, r, mex, p, mshr): with Settings( verbosity=Verbosity.quiet, max_examples=mex, min_satisfying_examples=0, database=self.database, max_shrinks=mshr, ): @given( strat, random=r, ) def test(x): assert Random(hashlib.md5( show(x).encode('utf-8')).digest()).random() <= p try: test() except AssertionError: pass @rule(target=strats_with_parameters, strat=strategies, r=randoms()) def draw_parameter(self, strat, r): return (strat, strat.draw_parameter(r)) @rule(target=strats_with_templates, sp=strats_with_parameters, r=randoms()) def draw_template(self, sp, r): strat, param = sp return (strat, strat.draw_template(r, param)) @rule(target=strats_with_2_templates, sp=strats_with_parameters, r=randoms()) def draw_templates(self, sp, r): strat, param = sp return ( strat, strat.draw_template(r, param), strat.draw_template(r, param), ) @rule(st=strats_with_templates) def check_serialization(self, st): strat, template = st as_basic = strat.to_basic(template) assert show(strat.reify(template)) == show( strat.reify(strat.from_basic(as_basic))) assert as_basic == strat.to_basic(strat.from_basic(as_basic)) @rule(target=strategies, spec=sampled_from(( integers(), booleans(), floats(), complex_numbers(), fractions(), decimals(), text(), binary(), none(), StateMachineSearchStrategy(), tuples(), ))) def strategy(self, spec): return spec @rule(target=strategies, values=lists(integers() | text(), min_size=1)) def sampled_from_strategy(self, values): return sampled_from(values) @rule(target=strategies, spec=strategy_tuples) def strategy_for_tupes(self, spec): return tuples(*spec) @rule(target=strategies, source=strategies, level=integers(1, 10), mixer=text()) def filtered_strategy(s, source, level, mixer): def is_good(x): return bool( Random( hashlib.md5( (mixer + show(x)).encode('utf-8')).digest()).randint( 0, level)) return source.filter(is_good) @rule(target=strategies, elements=strategies) def list_strategy(self, elements): return lists(elements, average_size=AVERAGE_LIST_LENGTH) @rule(target=strategies, l=strategies, r=strategies) def or_strategy(self, l, r): return l | r @rule(target=strategies, source=strategies, result=strategies, mixer=text()) def mapped_strategy(self, source, result, mixer): cache = {} def do_map(value): rep = show(value) try: return deepcopy(cache[rep]) except KeyError: pass random = Random( hashlib.md5((mixer + rep).encode('utf-8')).digest()) outcome_template = result.draw_and_produce(random) cache[rep] = result.reify(outcome_template) return deepcopy(cache[rep]) return source.map(do_map) @rule(target=varied_floats, source=floats()) def float(self, source): return source @rule(target=varied_floats, source=varied_floats, offset=integers(-100, 100)) def adjust_float(self, source, offset): return int_to_float(clamp(0, float_to_int(source) + offset, 2**64 - 1)) @rule(target=strategies, left=varied_floats, right=varied_floats) def float_range(self, left, right): for f in (math.isnan, math.isinf): for x in (left, right): assume(not f(x)) left, right = sorted((left, right)) assert left <= right return strategy(floats(left, right)) @rule(target=strategies, source=strategies, result1=strategies, result2=strategies, mixer=text(), p=floats(0, 1)) def flatmapped_strategy(self, source, result1, result2, mixer, p): assume(result1 is not result2) def do_map(value): rep = show(value) random = Random( hashlib.md5((mixer + rep).encode('utf-8')).digest()) if random.random() <= p: return result1 else: return result2 return source.flatmap(do_map) @rule(target=strategies, value=objects) def just_strategy(self, value): return strategy(just(value)) @rule(target=strategy_tuples, source=strategies) def single_tuple(self, source): return (source, ) @rule(target=strategy_tuples, l=strategy_tuples, r=strategy_tuples) def cat_tuples(self, l, r): return l + r @rule(target=objects, strat=strategies) def get_example(self, strat): try: strat.example() except NoExamples: # Because of filtering some strategies we look for don't actually # have any examples. pass @rule(target=strategies, left=integers(), right=integers()) def integer_range(self, left, right): left, right = sorted((left, right)) return strategy(integers(left, right)) @rule(strat=strategies) def repr_is_good(self, strat): assert ' at 0x' not in repr(strat) @rule(strat=strategies) def template_upper_bound_is_valid(self, strat): ub = strat.template_upper_bound assert ub >= 0 if isinstance(ub, float): assert math.isinf(ub) else: assert isinstance(ub, int) @rule(strat=strategies, r=randoms()) def can_find_as_many_templates_as_size(self, strat, r): tempstrat = templates_for(strat) n = min(10, strat.template_upper_bound) found = [] with Settings(verbosity=Verbosity.quiet, timeout=2.0): for i in range(n): try: x = find( tempstrat, lambda t: t not in found, random=r, ) except: print('Exception at %d/%d. template_upper_bound=%r' % (i, n, strat.template_upper_bound)) raise found.append(x)