def test_registry_add_only_accept_integers(): from binlog.registry import Registry r = Registry() with pytest.raises(TypeError): r.add(None)
def test_registry_multiplesegment_invert(values): r = Registry() for point in values: r.add(point) assert (~~r).acked == r.acked
def test_registry_add_starts_range(data): from binlog.registry import Registry r = Registry() assert r.add(data) assert r.acked == list([(data, data)])
def test_registry_double_add(): from binlog.registry import Registry r = Registry() assert r.add(0) assert not r.add(0)
def test_registry_is_iterator(points): from binlog.registry import Registry r = Registry() for p in points: r.add(p) assert list(r) == sorted(points)
def test_registry_contains(data, point): from binlog.registry import Registry r = Registry() for i in data: r.add(i) assert (point in r) == (point in data)
def test_registry_is_always_sorted(data): from binlog.registry import Registry r = Registry() for i in data: r.add(i) assert list(r.acked) == sorted(r.acked) # sorted always returns list
def test_registries_support_intersection__same_point(): from binlog.registry import Registry, S registry_a = Registry(acked=list([S(0, 0)])) registry_b = Registry(acked=list([S(0, 0)])) registry_x1 = registry_a & registry_b registry_x2 = registry_b & registry_a assert registry_x1.acked == registry_x2.acked == list([S(0, 0)])
def test_registries_support_intersection__start_and_end_are_consecutive(): from binlog.registry import Registry, S registry_a = Registry(acked=list([S(0, 10)])) registry_b = Registry(acked=list([S(11, 20)])) registry_x1 = registry_a & registry_b registry_x2 = registry_b & registry_a assert registry_x1.acked == registry_x2.acked == list([])
def test_registries_support_intersection__overlap_segments(): from binlog.registry import Registry, S registry_a = Registry(acked=list([S(0, 10)])) registry_b = Registry(acked=list([S(5, 20)])) registry_x1 = registry_a & registry_b registry_x2 = registry_b & registry_a assert registry_x1.acked == registry_x2.acked == list([S(5, 10)])
def test_registries_support_union_one_point(): from binlog.registry import Registry, S registry_a = Registry(acked=list([S(0, 0)])) registry_b = Registry() registry_x1 = registry_a | registry_b registry_x2 = registry_b | registry_a assert registry_x1.acked == registry_x2.acked == list([S(0, 0)])
def test_registries_support_union__bigger_segment(): from binlog.registry import Registry, S registry_a = Registry(acked=list([S(0, 10)])) registry_b = Registry(acked=list([S(5, 8)])) registry_x1 = registry_a | registry_b registry_x2 = registry_b | registry_a assert registry_x1.acked == registry_x2.acked == list([S(0, 10)])
def test_registry_add_randomized_range(data): from binlog.registry import Registry r = Registry() l = list(range(data, data + 101)) * random.randint(1, 3) random.shuffle(l) for i in l: r.add(i) assert (data, data + 100) in r.acked
def test_registryiterseek_backward_threesegments_seek(a, b, c, d, e, f, seeks): assume(len(set([a, b, c, d, e, f])) == 6) a, b, c, d, e, f = sorted([a, b, c, d, e, f]) assume(b + 1 < c and d + 1 < e) from binlog.registry import RegistryIterSeek r = RegistryIterSeek(Registry([S(a, b), S(c, d), S(e, f)]), direction=Direction.B) for s in list(seeks): r.seek(s) if s < a: with pytest.raises(StopIteration): next(r) elif a <= s <= b or c <= s <= d or e <= s <= f: assert next(r) == s, s elif b <= s <= c: assert next(r) == b, s elif d <= s <= e: assert next(r) == d, s elif s > f: assert next(r) == f, s else: assert False, "Non defined %d" % s
def test_registryiterseek_backward_onesegment_unset(a, b): assume(len(set([a, b])) == 2) a, b = sorted([a, b]) from binlog.registry import RegistryIterSeek r = RegistryIterSeek(Registry([S(a, b)]), direction=Direction.B) assert list(r) == list(chain(range(b, a - 1, -1)))
def test_registryiterseek_forward_twosegments_unset(a, b, c, d): assume(len(set([a, b, c, d])) == 4) a, b, c, d = sorted([a, b, c, d]) assume(b + 1 < c) from binlog.registry import RegistryIterSeek r = RegistryIterSeek(Registry([S(a, b), S(c, d)])) assert list(r) == list(chain(range(a, b + 1), range(c, d + 1)))
def test_registryiterseek_forward_onesegment_unset(a, b): assume(len(set([a, b])) == 2) from binlog.registry import RegistryIterSeek a, b = sorted([a, b]) r = RegistryIterSeek(Registry([S(a, b)])) assert list(r) == list(chain(range(a, b + 1)))
def test_registryiterseek_backward_twosegments_unset(a, b, c, d): assume(len(set([a, b, c, d])) == 4) a, b, c, d = sorted([a, b, c, d]) assume(b + 1 < c) from binlog.registry import RegistryIterSeek r = RegistryIterSeek(Registry([S(a, b), S(c, d)]), direction=Direction.B) assert list(r) == list(chain(range(d, c - 1, -1), range(b, a - 1, -1)))
def test_registryiterseek_forward_threesegments_unset(a, b, c, d, e, f): assume(len(set([a, b, c, d, e, f])) == 6) a, b, c, d, e, f = sorted([a, b, c, d, e, f]) assume(b + 1 < c and d + 1 < e) from binlog.registry import RegistryIterSeek r = RegistryIterSeek(Registry([S(a, b), S(c, d), S(e, f)])) assert list(r) == list( chain(range(a, b + 1), range(c, d + 1), range(e, f + 1)))
def test_registryiterseek_backward_threesegments_unset(a, b, c, d, e, f): assume(len(set([a, b, c, d, e, f])) == 6) a, b, c, d, e, f = sorted([a, b, c, d, e, f]) assume(b + 1 < c and d + 1 < e) from binlog.registry import RegistryIterSeek r = RegistryIterSeek(Registry([S(a, b), S(c, d), S(e, f)]), direction=Direction.B) assert list(r) == list( chain(range(f, e - 1, -1), range(d, c - 1, -1), range(b, a - 1, -1)))
def test_registry_onesegment_invert(a, b): start, end = min(a, b), max(a, b) r = ~Registry([S(start, end)]) if start == S.MIN: if end == S.MIN: assert r.acked == [S(start + 1, S.MAX)] elif end == S.MAX: assert r.acked == [] elif end == S.MAX: assert r.acked == [S(S.MIN, start - 1)] else: assert r.acked == [S(S.MIN, start - 1), S(end + 1, S.MAX)]
def test_registry_add_consecutive_left_side(data): from binlog.registry import Registry r = Registry() r.add(data) r.add(data - 1) assert (data - 1, data) in r.acked
def test_registry_add_consecutive_left_and_right(data): from binlog.registry import Registry r = Registry() r.add(data - 1) r.add(data + 1) r.add(data) assert (data - 1, data + 1) in r.acked
def test_registry_add_non_consecutive(data): from binlog.registry import Registry r = Registry() r.add(0) assert (0, 0) in r.acked r.add(data) assert (data, data) in r.acked
def test_registryiterseek_forward_onesegment_seek(a, b, seeks): assume(len(set([a, b])) == 2) a, b = sorted([a, b]) from binlog.registry import RegistryIterSeek r = RegistryIterSeek(Registry([S(a, b)])) for s in list(seeks): r.seek(s) if s < a: assert next(r) == a, s elif a <= s <= b: assert next(r) == s, s elif s > b: with pytest.raises(StopIteration): next(r) else: assert False, "Non defined %d" % s
def test_registries_support_intersection(data_a, data_b): from binlog.registry import Registry registry_a = Registry() registry_b = Registry() for p in data_a: registry_a.add(p) for p in data_b: registry_b.add(p) registry_x = registry_a & registry_b ack_points = data_a & data_b non_ack_points = set(range(0, 20)) - ack_points for p in ack_points: assert p in registry_x for p in non_ack_points: assert p not in registry_x
def test_registryiterseek_forward_twosegments_seek(a, b, c, d, seeks): assume(len(set([a, b, c, d])) == 4) a, b, c, d = sorted([a, b, c, d]) assume(b + 1 < c) from binlog.registry import RegistryIterSeek r = RegistryIterSeek(Registry([S(a, b), S(c, d)])) for s in list(seeks): r.seek(s) if s < a: assert next(r) == a, s elif a <= s <= b or c <= s <= d: assert next(r) == s, s elif b <= s <= c: assert next(r) == c, s elif s > d: with pytest.raises(StopIteration): next(r) else: assert False, "Non defined %d" % s
def test_registryiterseek_backward_empty_seek(seek_to): from binlog.registry import RegistryIterSeek r = RegistryIterSeek(Registry(), direction=Direction.B) r.seek(seek_to) assert not list(r)
def test_registry_empty_invert(): r = ~Registry() assert r.acked == [S(S.MIN, S.MAX)]
def test_registryiterseek_forward_empty_seek(seek_to): from binlog.registry import RegistryIterSeek r = RegistryIterSeek(Registry()) r.seek(seek_to) assert not list(r)