def basic(basic=None,
generate_parameter=None,
generate=None,
simplify=None,
copy=None):
"""Provides a facility to write your own strategies with significantly less
work.
See documentation for more details.
"""
from hypothesis.searchstrategy.basic import basic_strategy, BasicStrategy
from copy import deepcopy
if basic is not None:
if isinstance(basic, type):
basic = basic()
check_type(BasicStrategy, basic)
generate_parameter = generate_parameter or basic.generate_parameter
generate = generate or basic.generate
simplify = simplify or basic.simplify
copy = copy or basic.copy
return basic_strategy(parameter=generate_parameter,
generate=generate,
simplify=simplify,
copy=copy or deepcopy)
def basic(
basic=None,
generate_parameter=None, generate=None, simplify=None, copy=None
):
"""Provides a facility to write your own strategies with significantly less
work.
See documentation for more details.
"""
note_deprecation(
'basic() is deprecated as Hypothesis will be moving to a new '
'model that cannot support it. There is probably no one-size fits all '
'replacement solution here. If you can\'t figure out a good '
'solution, please ask.'
)
from hypothesis.searchstrategy.basic import basic_strategy, BasicStrategy
from copy import deepcopy
if basic is not None:
if isinstance(basic, type):
basic = basic()
check_type(BasicStrategy, basic)
generate_parameter = generate_parameter or basic.generate_parameter
generate = generate or basic.generate
simplify = simplify or basic.simplify
copy = copy or basic.copy
return basic_strategy(
parameter=generate_parameter,
generate=generate, simplify=simplify, copy=copy or deepcopy
)
def test_can_simplify_bitfields(i):
bitfield = basic_strategy(
parameter=lambda r: r.getrandbits(128),
generate=lambda r, p: r.getrandbits(128) & p,
simplify=simplify_bitfield,
copy=lambda x: x,
)
assert minimal(bitfield, lambda x: x & (1 << i)) == 1 << i
def test_can_simplify_bitfields(i):
bitfield = basic_strategy(
parameter=lambda r: r.getrandbits(128),
generate=lambda r, p: r.getrandbits(128) & p,
simplify=simplify_bitfield,
copy=lambda x: x,
)
assert minimal(bitfield, lambda x: x & (1 << i)) == 1 << i
def test_can_simplify_bitfields_with_composite(c):
bitfield = basic_strategy(
parameter=lambda r: r.getrandbits(128),
generate=lambda r, p: r.getrandbits(128) & p,
simplify=simplify_bitfield,
copy=lambda x: x,
)
t = minimal(bitfield, lambda x: popcount(x) >= c)
assert popcount(t) == c
def test_can_simplify_bitfields_with_composite(c):
bitfield = basic_strategy(
parameter=lambda r: r.getrandbits(128),
generate=lambda r, p: r.getrandbits(128) & p,
simplify=simplify_bitfield,
copy=lambda x: x,
)
t = minimal(bitfield, lambda x: popcount(x) >= c)
assert popcount(t) == c
def test_does_not_get_stuck_in_a_loop():
bad_strategy = basic_strategy(generate=lambda r, p: 1,
simplify=lambda r, v: [v])
@timeout(2)
@given(bad_strategy)
def oh_noes(x):
assert x != 1
with pytest.raises(AssertionError):
oh_noes()
def test_does_not_get_stuck_in_a_loop():
bad_strategy = basic_strategy(
generate=lambda r, p: 1,
simplify=lambda r, v: [v]
)
@timeout(2)
@given(bad_strategy)
def oh_noes(x):
assert x != 1
with pytest.raises(AssertionError):
oh_noes()
def test_can_load_a_very_deep_example_from_the_db():
bad_strategy = basic_strategy(generate=lambda r, p: 1,
simplify=lambda r, v: [v])
@timeout(2)
@given(bad_strategy, settings=Settings(database=ExampleDatabase()))
def oh_noes(x):
assert x != 1
with pytest.raises(AssertionError):
oh_noes()
with pytest.raises(AssertionError):
oh_noes()
def test_can_load_a_very_deep_example_from_the_db():
bad_strategy = basic_strategy(
generate=lambda r, p: 1,
simplify=lambda r, v: [v]
)
@timeout(2)
@given(bad_strategy, settings=Settings(database=ExampleDatabase()))
def oh_noes(x):
assert x != 1
with pytest.raises(AssertionError):
oh_noes()
with pytest.raises(AssertionError):
oh_noes()
def test_cache_is_cleaned_up_on_gc_1():
st = basic_strategy(
generate=lambda r, p: r.getrandbits(128),
simplify=simplify_bitfield,
copy=lambda x: x,
)
@given(st)
def test_all_good(x):
pass
test_all_good()
gc_clear()
assert len(st.reify_cache) == 0
def test_cache_is_cleaned_up_on_gc_1():
st = basic_strategy(
generate=lambda r, p: r.getrandbits(128),
simplify=simplify_bitfield,
copy=lambda x: x,
)
@given(st)
def test_all_good(x):
pass
test_all_good()
gc_clear()
assert len(st.reify_cache) == 0
def test_cache_is_cleaned_up_on_gc_2():
st = basic_strategy(
generate=lambda r, p: r.getrandbits(128),
simplify=simplify_bitfield,
copy=lambda x: x,
)
@given(st)
def test_all_bad(x):
assert False
try:
test_all_bad()
except AssertionError:
pass
gc_clear()
assert all(isinstance(v, integer_types) for v in st.reify_cache.values())
assert len(st.reify_cache) == 0, len(st.reify_cache)
def test_cache_is_cleaned_up_on_gc_2():
st = basic_strategy(
generate=lambda r, p: r.getrandbits(128),
simplify=simplify_bitfield,
copy=lambda x: x,
)
@given(st)
def test_all_bad(x):
assert False
try:
test_all_bad()
except AssertionError:
pass
gc_clear()
assert all(isinstance(v, integer_types) for v in st.reify_cache.values())
assert len(st.reify_cache) == 0, len(st.reify_cache)
def basic(
basic=None,
generate_parameter=None, generate=None, simplify=None, copy=None
):
"""Provides a facility to write your own strategies with significantly less
work.
See documentation for more details.
"""
from hypothesis.searchstrategy.basic import basic_strategy, BasicStrategy
from copy import deepcopy
if basic is not None:
if isinstance(basic, type):
basic = basic()
check_type(BasicStrategy, basic)
generate_parameter = generate_parameter or basic.generate_parameter
generate = generate or basic.generate
simplify = simplify or basic.simplify
copy = copy or basic.copy
return basic_strategy(
parameter=generate_parameter,
generate=generate, simplify=simplify, copy=copy or deepcopy
)
def basic_to_strategy(basic, settings):
return basic_strategy(
generate=basic.generate,
parameter=basic.generate_parameter,
simplify=basic.simplify, copy=basic.copy
)
TestManyFlatmaps = strategy_test_suite(
strategy(int).flatmap(integers_from).flatmap(integers_from).flatmap(
integers_from).flatmap(integers_from))
TestIntStreams = strategy_test_suite(streaming(int))
TestStreamLists = strategy_test_suite(streaming(int))
TestIntStreamStreams = strategy_test_suite(streaming(streaming(int)))
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,
copy=lambda x: x,
)
})
TestBitfield = strategy_test_suite(
basic_strategy(
generate=lambda r, p: r.getrandbits(128),
def basic_to_strategy(basic, settings):
return basic_strategy(generate=basic.generate,
parameter=basic.generate_parameter,
simplify=basic.simplify,
copy=basic.copy)
def test_can_find_bitfields_without_simplifying():
assert minimal(
basic_strategy(generate=lambda r, p: r.getrandbits(128)),
lambda x: x & 1
)
def test_can_find_bitfields_without_simplifying():
assert minimal(basic_strategy(generate=lambda r, p: r.getrandbits(128)),
lambda x: x & 1)
)
TestIntStreams = strategy_test_suite(streaming(int))
TestStreamLists = strategy_test_suite(streaming(int))
TestIntStreamStreams = strategy_test_suite(streaming(streaming(int)))
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,
copy=lambda x: x,
)
})
TestBitfield = strategy_test_suite(
basic_strategy(
