def test_overflow_in_simplify():
"""This is a test that we don't trigger a pytz bug when we're simplifying
around MINYEAR where valid dates can produce an overflow error."""
minimal(
datetimes(max_year=MINYEAR),
lambda x: x.tzinfo != pytz.UTC
)
def test_finding_decimals_with_defined_precision():
def is_integral(x):
try:
return x == int(x)
except (ValueError, OverflowError):
return False
assert minimal(Decimal, is_integral) == Decimal(0)
minimal(Decimal, lambda x: is_integral(x * 100) and 0 < x < 1)
def test_legacy_api():
with hs.Settings(strict=False):
x = minimal(datetime)
assert x.tzinfo == pytz.UTC
assert x.year == 2000
assert minimal(naive_datetime).tzinfo is None
assert minimal(timezone_aware_datetime) == x
assert minimal(any_datetime) == x
def test_minimal_infinite_float_is_positive():
assert minimal(float, math.isinf) == float('inf')
def list_of_infinities(xs):
assume(len(xs) >= 10)
return len([
t for t in xs if (math.isinf(t) or math.isnan(t))
]) >= 10
assert minimal([float], list_of_infinities) == [float('inf')] * 10
def test_dictionary(dict_class):
assert minimal(dictionary(int, text_type, dict_class)) == dict_class()
x = minimal(dictionary(int, text_type, dict_class), lambda t: len(t) >= 3)
assert isinstance(x, dict_class)
assert set(x.values()) == {''}
for k in x:
if k < 0:
assert k + 1 in x
if k > 0:
assert k - 1 in x
def test_dictionary(dict_class):
assert minimal(dictionaries(keys=integers(), values=text(), dict_class=dict_class)) == dict_class()
x = minimal(dictionaries(keys=integers(), values=text(), dict_class=dict_class), lambda t: len(t) >= 3)
assert isinstance(x, dict_class)
assert set(x.values()) == set((u"",))
for k in x:
if k < 0:
assert k + 1 in x
if k > 0:
assert k - 1 in x
def test_list_of_fractional_float():
assert set(minimal(
[float], lambda x: len([t for t in x if t >= 1.5]) >= 10
)) in (
{1.5},
{1.5, 2.0}
)
def test_increasing_sequence():
xs = minimal(
[int], lambda t: length_of_longest_ordered_sequence(t) >= 5,
timeout_after=60,
)
start = xs[0]
assert xs == list(range(start, start + 5))
def test_non_reversible_decimals():
def not_reversible(xs):
assume(all(x.is_finite() for x in xs))
return sum(xs) != sum(reversed(xs))
sigh = minimal(lists(decimals()), not_reversible, timeout_after=30)
assert len(sigh) < 10
def test_small_sum_lists():
xs = minimal(
lists(floats()),
lambda x: len(x) >= 100 and sum(t for t in x if float("inf") > t >= 0) >= 1,
settings=Settings(average_list_length=200),
)
assert 1.0 <= sum(t for t in xs if t >= 0) <= 1.5
def test_non_reversible_ints_as_decimals():
def not_reversible(xs):
ts = list(map(Decimal, xs))
return sum(ts) != sum(reversed(ts))
sigh = minimal(lists(integers()), not_reversible, timeout_after=30)
assert len(sigh) <= 25
def test_bordering_on_a_leap_year():
x = minimal(
datetimes(min_year=2002, max_year=2005),
lambda x: x.month == 2 and x.day == 29,
settings=settings(database=None, max_examples=10 ** 7)
)
assert x.year == 2004
def test_can_find_unique_lists_of_non_set_order():
ls = minimal(
lists(text(), unique=True),
lambda x: list(set(reversed(x))) != x
)
assert len(set(ls)) == len(ls)
assert len(ls) == 2
def test_anti_sorted_ordered_pair():
result = minimal(
lists(ordered_pair),
lambda x: (
len(x) >= 30 and
2 < length_of_longest_ordered_sequence(x) <= 10))
assert len(result) == 30
def test_non_reversible_fractions_as_decimals():
def not_reversible(xs):
xs = [Decimal(x.numerator) / x.denominator for x in xs]
return sum(xs) != sum(reversed(xs))
sigh = minimal(lists(fractions()), not_reversible, timeout_after=20)
assert len(sigh) <= 25
def test_increasing_sequence():
k = 6
xs = minimal(
lists(integers()), lambda t: (len(t) <= 30 and length_of_longest_ordered_sequence(t) >= k), timeout_after=60
)
start = xs[0]
assert xs == list(range(start, start + k))
def test_containment(n):
iv = minimal(
tuples(lists(integers()), integers()),
lambda x: x[1] in x[0] and x[1] >= n,
timeout_after=60
)
assert iv == ([n], n)
def test_non_reversible_ints_as_decimals():
def not_reversible(xs):
xs = list(map(Decimal, xs))
return sum(xs) != sum(reversed(xs))
sigh = minimal([int], not_reversible, timeout_after=20)
assert len(sigh) < 10
def test_minimize_list_of_sets_on_large_structure():
def test_list_in_range(xs):
assume(len(xs) >= 50)
return len(list(filter(None, xs))) >= 50
x = minimal([frozenset({int})], test_list_in_range)
assert len(x) == 50
assert len(set(x)) == 1
def test_minimize_list_of_floats_on_large_structure():
def test_list_in_range(xs):
assume(len(xs) >= 50)
return len([x for x in xs if x >= 3]) >= 30
result = minimal(lists(floats()), test_list_in_range)
result.sort()
assert result == [0.0] * 20 + [3.0] * 30
def test_minimize_list_of_sets_on_large_structure():
def test_list_in_range(xs):
assume(len(xs) >= 50)
return len(list(filter(None, xs))) >= 50
x = minimal(lists(frozensets(integers())), test_list_in_range, timeout_after=20)
assert len(x) == 50
assert len(set(x)) == 1
def test_finds_list_with_plenty_duplicates():
def is_good(xs):
return max(Counter(xs).values()) >= 3
result = minimal(
lists(text(min_size=1), average_size=50, min_size=1), is_good
)
assert result == [u'0'] * 3
def test_tuples_do_not_block_cloning():
assert (
minimal(
lists(tuples(booleans() | tuples(integers()))),
lambda x: len(x) >= 50 and any(isinstance(t[0], bool) for t in x),
)
== [(False,)] * 50
)
def test_minimal_fractions_4():
x = minimal(
lists(
fractions(max_denominator=100, max_value=100, min_value=-100),
min_size=20),
lambda s: len([t for t in s if t >= 1]) >= 20
)
assert x == [Fraction(1)] * 20
def test_increasing_float_sequence():
xs = minimal(
lists(floats()), lambda x: length_of_longest_ordered_sequence([
t for t in x if t >= 0
]) >= 7 and len([t for t in x if t >= 500.0]) >= 4
)
assert max(xs) < 1000
assert not any(math.isinf(x) for x in xs)
def test_small_sum_lists():
xs = minimal(
lists(floats(), min_size=100, average_size=200),
lambda x:
sum(t for t in x if float(u'inf') > t >= 0) >= 1,
timeout_after=60,
)
assert 1.0 <= sum(t for t in xs if t >= 0) <= 1.5
def test_finds_non_reversible_floats():
t = minimal(
lists(floats()), lambda xs:
not math.isnan(sum(xs)) and sum(xs) != sum(reversed(xs)),
timeout_after=40,
settings=settings(database=None)
)
assert len(repr(t)) <= 200
print(t)
def test_minimize_list_on_large_structure():
def test_list_in_range(xs):
assume(len(xs) >= 30)
return len([
x for x in xs
if x >= 10
]) >= 60
assert minimal(lists(integers()), test_list_in_range) == [10] * 60
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_constant_lists_of_diverse_length():
# This does not currently work very well. We delete, but we don't actually
# get all that far with simplification of the individual elements.
result = minimal(
lists(constant_list(integers())),
lambda x: len(set(map(len, x))) >= 20,
timeout_after=30,
)
assert len(result) == 20
def test_can_generate_non_naive_datetime():
assert minimal(datetimes(allow_naive=True),
lambda d: d.tzinfo).tzinfo == pytz.UTC
def test_restricts_to_allowed_set_of_timezones():
timezones = list(map(pytz.timezone, list(pytz.all_timezones)[:3]))
x = minimal(datetimes(timezones=timezones))
assert any(tz.zone == x.tzinfo.zone for tz in timezones)
def test_max_year_is_respected():
assert minimal(datetimes(max_year=1998)).year == 1998
def test_can_find_before_the_year_2000():
assert minimal(datetimes(), lambda x: x.year < 2000).year == 1999
def test_minimize_list_on_large_structure():
def test_list_in_range(xs):
assume(len(xs) >= 30)
return len([x for x in xs if x >= 10]) >= 60
assert minimal(lists(integers()), test_list_in_range) == [10] * 60
def test_minimize_3_set_of_tuples():
assert minimal(sets(tuples(integers())), lambda x: len(x) >= 2) == set(
((0, ), (1, )))
def test_minimize_3_set():
assert minimal(sets(integers()), lambda x: len(x) >= 3) in (
set((0, 1, 2)),
set((-1, 0, 1)),
)
def test_minimize_longer_list_of_strings():
assert minimal(lists(text()), lambda x: len(x) >= 10) == [u''] * 10
def test_minimize_longer_string():
assert minimal(text(), lambda x: len(x) >= 10) == u'0' * 10
def test_can_find_midnight():
minimal(
datetimes(),
lambda x: (x.hour == 0 and x.minute == 0 and x.second == 0),
)
def test_can_generate_non_utc():
minimal(datetimes(), lambda d: assume(d.tzinfo) and d.tzinfo.zone != 'UTC')
def test_can_find_on_the_minute():
minimal(datetimes(), lambda x: x.second != 0)
def test_minimize_long():
assert minimal(integers(),
lambda x: type(x).__name__ == u'long') == sys.maxint + 1
def test_tuples_do_not_block_cloning():
assert minimal(
lists(tuples(booleans() | tuples(integers()))),
lambda x: len(x) >= 50 and any(isinstance(t[0], bool)
for t in x)) == [(False, )] * 50
def test_anti_sorted_ordered_pair():
result = minimal(
lists(ordered_pair), lambda x:
(len(x) >= 30 and 2 < length_of_longest_ordered_sequence(x) <= 10))
assert len(result) == 30
def test_can_simplify_flatmap_with_bounded_left_hand_size():
assert minimal(booleans().flatmap(lambda x: lists(just(x))),
lambda x: len(x) >= 10) == [False] * 10
def test_can_find_each_month():
for i in hrange(1, 12):
minimal(datetimes(), lambda x: x.month == i)
def test_can_simplify_across_flatmap_of_just():
assert minimal(integers().flatmap(just)) == 0
def test_can_find_after_the_year_2000():
assert minimal(datetimes(), lambda x: x.year > 2000).year == 2001
def test_can_simplify_on_right_hand_strategy_of_flatmap():
assert minimal(integers().flatmap(lambda x: lists(just(x)))) == []
def test_min_year_is_respected():
assert minimal(datetimes(min_year=2003)).year == 2003
def test_simplifies_towards_midnight():
d = minimal(datetimes())
assert d.hour == 0
assert d.minute == 0
assert d.second == 0
assert d.microsecond == 0
def test_can_ignore_left_hand_side_of_flatmap():
assert minimal(integers().flatmap(lambda x: lists(integers())),
lambda x: len(x) >= 10) == [0] * 10
def test_can_generate_naive_datetime():
minimal(datetimes(allow_naive=True), lambda d: not d.tzinfo)
def test_can_find_off_the_minute():
minimal(times(), lambda x: x.second == 0)
def test_can_simplify_on_both_sides_of_flatmap():
assert minimal(integers().flatmap(lambda x: lists(just(x))),
lambda x: len(x) >= 10) == [0] * 10
def test_minimize_single_element_in_silly_large_int_range():
ir = integers(-(2**256), 2**256)
assert minimal(ir, lambda x: x >= -(2**255)) == -(2**255)
def test_minimize_one_of_distinct_types():
y = booleans() | binary()
x = minimal(tuples(y, y), lambda x: type(x[0]) != type(x[1]))
assert x in ((False, b''), (b'', False))
def test_minimize_mixed_list():
mixed = minimal(lists(integers() | text()), lambda x: len(x) >= 10)
assert set(mixed).issubset(set((0, u'')))
def test_can_find_non_midnight():
assert minimal(datetimes(), lambda x: x.hour != 0).hour == 1
