def test_can_falsify_complex_numbers(): falsify(lambda x: x == (x**2)**0.5, complex) with pytest.raises(Unfalsifiable): falsify( lambda x, y: (x * y).conjugate() == x.conjugate() * y.conjugate(), complex, complex)
def test_can_produce_long_mixed_lists_with_only_a_subset(): def is_good(xs): if len(xs) < 20: return True if any((isinstance(x, int) for x in xs)): return True return False falsify(is_good, [int,str])
def test_can_produce_long_mixed_lists_with_only_a_subset(): def is_good(xs): if len(xs) < 20: return True if any((isinstance(x, int) for x in xs)): return True return False falsify(is_good, [int, str])
def test_can_go_deep_into_recursive_descriptors(): foo = [str] foo.append(foo) def depth(x): if isinstance(x, str): return 1 elif not x: return 0 else: return max(map(depth, x)) + 1 falsify(lambda x: depth(x) <= 5, foo)
def test_can_falsify_complex_numbers(): falsify(lambda x: assume(abs(x) <= 1000) and x == (x**2)**0.5, complex) with pytest.raises(Unfalsifiable): falsify( lambda x, y: actually_equal((x * y).conjugate(), x.conjugate() * y.conjugate()), complex, complex)
def test_can_generate_non_ascii(): def is_ascii(s): try: s.encode('ascii') return True except UnicodeEncodeError: return False falsify(is_ascii, text_type)
def test_can_produce_things_that_are_not_utf8(): def is_utf8(x): try: x.decode('utf-8') return True except UnicodeDecodeError: return False falsify(is_utf8, binary_type)
def test_detects_flaky_failure(): calls = [0] def flaky(x): result = calls != [0] calls[0] = 1 return result with pytest.raises(Flaky): falsify(flaky, int)
def test_does_not_call_twice_with_same_passing_parameter(): calls = [0] def count_calls(x): calls[0] += 1 return True with pytest.raises(Exhausted): falsify(count_calls, bool) assert calls == [2]
def test_can_produce_long_mixed_lists_with_only_a_subset(): def short_or_includes(t): def is_good(xs): if len(xs) < 20: return True return any(isinstance(x, t) for x in xs) return is_good falsify(short_or_includes(text_type), [int, text_type]) falsify(short_or_includes(int), [int, text_type])
def test_gravitates_towards_good_parameter_values(): good_value_counts = [0] all_value_counts = [0] def just_being_awkward(xs): assume(len(xs) >= 10) all_value_counts[0] += 1 assume(all(x >= 0 for x in xs)) good_value_counts[0] += 1 return True with pytest.raises(Unfalsifiable): falsify(just_being_awkward, [float]) assert all_value_counts[0] >= 300 assert good_value_counts[0] >= 0.6 * all_value_counts[0]
def test_can_falsify_tuples(): def out_of_order_positive_tuple(x): a,b = x assume(a > 0 and b > 0) assert a >= b return True assert falsify(out_of_order_positive_tuple, (int,int))[0] == (1,2)
def test_can_falsify_methods_which_mutate_data_without_proving_flaky(): def pop_single(xs): if len(xs) == 1: xs.pop() return False return True assert falsify(pop_single, [int]) == ([0], )
def test_can_falsify_tuples(): def out_of_order_positive_tuple(x): a, b = x assume(a > 0 and b > 0) assert a >= b return True assert falsify(out_of_order_positive_tuple, (int, int))[0] == (1, 2)
def test_can_falsify_string_commutativity(): def commutes(x, y): return x + y == y + x non_commuting = falsify(commutes, text_type, text_type) x, y = sorted(non_commuting) assert x == '0' assert y == '1'
def test_only_generates_valid_unicode(): def is_valid(x): try: x.encode('utf-8') return True except UnicodeEncodeError: return False with pytest.raises(Unfalsifiable): print(falsify(is_valid, text_type))
def test_can_falsify_dicts(): def is_good(x): assume("foo" in x) assume("bar" in x) return x["foo"] < x["bar"] assert falsify(is_good, { "foo": int, "bar": int })[0] == { "foo": 0, "bar": 0 }
def test_can_falsify_dicts(): def is_good(x): assume('foo' in x) assume('bar' in x) return x['foo'] < x['bar'] assert falsify(is_good, { 'foo': int, 'bar': int })[0] == { 'foo': 0, 'bar': 0 }
def test_can_produce_and_minimize_long_lists_of_only_one_element(): def is_a_monoculture(xs): assume(len(xs) >= 10) return len(set(xs)) > 1 falsify(is_a_monoculture, [descriptors.integers_in_range(0, 10)])
def test_can_falsify_with_true_boolean(): assert falsify(lambda x: not x, bool)[0] is True
def test_can_make_assumptions(): def is_good(x): assume(x > 5) return x % 2 == 0 assert falsify(is_good, int)[0] == 7
def test_can_falsify_list_inclusion(): assert falsify(lambda x,y: x not in y, int, [int]) == (0,[0])
def test_can_falsify_empty_tuples(): assert falsify(lambda x: False, ())[0] == ()
def test_stops_loop_pretty_quickly(): with pytest.raises(Unfalsifiable): falsify(lambda x: x == x, int)
def test_falsifies_integer_keyed_dictionary(): falsify(always_false, {1: int})
def test_minimizes_strings_to_zeroes(): assert falsify(lambda x: len(x) < 3, str)[0] == "000"
def test_can_find_short_strings(): assert falsify(lambda x: len(x) > 0, str)[0] == "" assert len(falsify(lambda x: len(x) <= 1, str)[0]) == 2 assert falsify(lambda x : len(x) < 10, [str])[0] == [""] * 10
def test_can_falsify_string_matching(): # Note that just doing a match("foo",x) will never find a good solution # because the state space is too large assert falsify(lambda x: not re.search("a.*b",x), str)[0] == "ab"
def test_can_falsify_mixed_lists(): xs = falsify(is_pure, [int,str])[0] assert len(xs) == 2 assert 0 in xs assert "" in xs
def test_can_produce_long_lists_with_floats_at_right(): def is_small_given_large(xs): assume(len(xs) >= 15) return any(x <= 0.8 for x in xs) falsify(is_small_given_large, [descriptors.floats_in_range(0, 1)])
def test_good_errors_on_bad_values(): some_string = "I am the very model of a modern major general" with pytest.raises(MissingSpecification) as e: falsify(lambda x: False, some_string) assert some_string in e.value.args[0]
def test_works_with_zero_arguments(): with pytest.raises(Unfalsifiable): falsify(lambda: True) falsify(lambda: False)
def test_can_falsify_bools(): assert falsify(lambda x: x, bool)[0] == False
def test_can_falsify_alternating_types(): falsify(lambda x: isinstance(x, int), one_of([int, str]))[0] == ""
def test_can_falsify_lists_of_bools(): falsify(lambda x : len([y for y in x if not y]) <= 5, [bool])
def test_can_falsify_set_inclusion(): assert falsify(lambda x,y: x not in y, int, {int}) == (0,{0})
def test_can_falsify_named_tuples(): pair = falsify(lambda x: x.kitten1 < x.kitten2, Litter(text_type, text_type))[0] assert isinstance(pair, Litter) assert pair == Litter('', '')
def test_can_find_unsorted_lists(): unsorted = falsify(lambda x: sorted(x) == x, [int])[0] assert unsorted == [1,0] or unsorted == [0,-1]
def test_raises_on_unsatisfiable_assumption(): with pytest.raises(Unsatisfiable): falsify(lambda x: assume(False), int)
def test_can_falsify_long_lists(): assert falsify(lambda x: len(x) < 20, [int],warming_rate=0.5)[0] == [0] * 20
def test_can_falsify_sets(): assert falsify(lambda x: not x, {int})[0] == {0}
def test_can_randomize_random(): falsify(lambda x: x.randint(0, 10) != 10, Random)
def test_falsification_contains_function_string(): with pytest.raises(Unfalsifiable) as e: assert falsify(lambda x: True, int) assert 'lambda x: True' in e.value.args[0]
def test_can_find_negative_floats(): assert falsify(lambda x : x > -1.0, float)[0] == -1.0
def test_can_falsify_string_commutativity(): assert tuple(sorted(falsify(lambda x,y: x + y == y + x,str,str))) == ('0','1')
def test_can_falsify_dicts(): def is_good(x): assume("foo" in x) assume("bar" in x) return x["foo"] < x["bar"] assert falsify(is_good, {"foo": int, "bar" : int})[0] == {"foo" : 0, "bar" : 0}
def test_can_falsify_int_pairs(): assert falsify(lambda x,y: x > y, int,int) == (0,0)
def test_can_falsify_assertions(): def is_good(x): assert x < 3 return True assert falsify(is_good, int)[0] == 3
def test_minimizes_to_empty(desc): x = falsify(always_false, desc)[0] s = StrategyTable.default().strategy(desc) assert not list(s.simplify(x))
def test_can_falsify_lists(): assert falsify(lambda x: len(x) < 3, [int])[0] == [0] * 3
def test_falsifies_sets_of_union_types(): assert falsify(always_false, {one_of([text_type, binary_type])})[0] == set()
def test_can_falsify_ints(): assert falsify(lambda x: x != 0, int)[0] == 0
def test_can_find_an_element_in_a_list(): falsify(lambda x, ys: x not in ys, int, [int])
def test_can_falsify_types_without_minimizers(): assert isinstance(falsify(lambda x: False, Foo)[0], Foo)
def test_can_produce_deep_binary_trees(): falsify(lambda x: x.depth() <= 2, BinaryTree)
def test_can_find_negative_ints(): assert falsify(lambda x: x >= 0, int)[0] == -1
def test_can_falsify_named_tuples(): pair = falsify(lambda x: x.kitten1 < x.kitten2, Litter(str,str))[0] assert isinstance(pair,Litter) assert pair == Litter("","")