def test_key():
slt = SortedListWithKey(range(10000), key=lambda val: val % 10)
slt._check()
values = sorted(range(10000), key=lambda val: (val % 10, val))
assert slt == values
assert all(val in slt for val in range(10000))
def test_delitem():
random.seed(0)
slt = SortedListWithKey(range(100), key=negate)
slt._reset(17)
while len(slt) > 0:
del slt[random.randrange(len(slt))]
slt._check()
def test_key():
slt = SortedListWithKey(range(10000), key=lambda val: val % 10)
slt._check()
values = sorted(range(10000), key=lambda val: (val % 10, val))
assert slt == values
assert all(val in slt for val in range(10000))
def test_check():
slt = SortedListWithKey(range(10),
load=4,
key=modulo,
value_orderable=False)
slt._list._len = 5
slt._check()
def test_append():
slt = SortedListWithKey(load=17, key=negate)
slt.append(1000)
for val in range(999, -1, -1):
slt.append(val)
slt._check()
def test_bisect_right():
slt = SortedListWithKey(key=modulo)
assert slt.bisect_right(10) == 0
slt = SortedListWithKey(range(100), load=17, key=modulo)
slt.update(range(100))
slt._check()
assert slt.bisect_right(10) == 20
assert slt.bisect_right(0) == 20
def test_extend():
slt = SortedListWithKey(load=4, key=modulo, value_orderable=False)
slt.extend(range(5))
slt._check()
slt.extend(range(6, 10))
slt._check()
def test_append():
slt = SortedListWithKey(load=4, key=modulo, value_orderable=False)
slt.append(0)
for val in range(1, 10):
slt.append(val)
slt._check()
def test_append():
slt = SortedListWithKey(load=4, key=modulo)
slt.append(0)
for val in range(1, 10):
slt.append(val)
slt._check()
def test_append():
slt = SortedListWithKey(load=17, key=negate)
slt.append(1000)
for val in range(999, -1, -1):
slt.append(val)
slt._check()
def test_bisect_right():
slt = SortedListWithKey(key=modulo)
assert slt.bisect_right(10) == 0
slt = SortedListWithKey(range(100), load=17, key=modulo)
slt.update(range(100))
slt._check()
assert slt.bisect_right(10) == 20
assert slt.bisect_right(0) == 20
def test_append():
slt = SortedListWithKey(load=4, key=modulo)
slt.append(0)
for val in range(1, 10):
slt.append(val)
slt._check()
def test_extend():
slt = SortedListWithKey(load=4, key=modulo)
slt.extend(range(5))
slt._check()
slt.extend(range(6, 10))
slt._check()
def test_bisect():
slt = SortedListWithKey(key=negate)
assert slt.bisect(0) == 0
slt = SortedListWithKey(range(100), load=17, key=negate)
slt.update(range(100))
slt._check()
assert slt.bisect(50) == 98
assert slt.bisect(0) == 198
def test_extend():
slt = SortedListWithKey(load=4, key=modulo)
slt.extend(range(5))
slt._check()
slt.extend(range(6, 10))
slt._check()
def test_bisect():
slt = SortedListWithKey(key=negate)
assert slt.bisect(10) == 0
slt = SortedListWithKey(range(100), load=17, key=negate)
slt.update(range(100))
slt._check()
assert slt.bisect(10) == 180
assert slt.bisect(0) == 200
def test_bisect():
slt = SortedListWithKey(key=modulo, value_orderable=False)
assert slt.bisect(10) == 0
slt = SortedListWithKey(range(100), load=17, key=modulo, value_orderable=False)
slt.update(range(100))
slt._check()
assert slt.bisect(10) == 20
assert slt.bisect(0) == 20
def test_extend():
slt = SortedListWithKey(load=4, key=modulo, value_orderable=False)
slt.extend(range(5))
slt._check()
slt.extend(range(6, 10))
slt._check()
def test_append():
slt = SortedListWithKey(load=4, key=modulo, value_orderable=False)
slt.append(0)
for val in range(1, 10):
slt.append(val)
slt._check()
def test_delete():
slt = SortedListWithKey(range(20), load=4, key=modulo, value_orderable=False)
slt._check()
for val in range(20):
slt.remove(val)
slt._check()
assert len(slt) == 0
assert slt._list._maxes == None
assert slt._list._lists == []
def test_bisect():
slt = SortedListWithKey(key=modulo)
assert slt.bisect(10) == 0
slt = SortedListWithKey(range(100), key=modulo)
slt._reset(17)
slt.update(range(100))
slt._check()
assert slt.bisect(10) == 20
assert slt.bisect(0) == 20
def test_bisect_right():
slt = SortedListWithKey(key=negate)
assert slt.bisect_right(10) == 0
slt = SortedListWithKey(range(100), key=negate)
slt._reset(17)
slt.update(range(100))
slt._check()
assert slt.bisect_right(10) == 180
assert slt.bisect_right(0) == 200
def test_delitem():
random.seed(0)
slt = SortedListWithKey(range(100),
load=17,
key=modulo,
value_orderable=False)
while len(slt) > 0:
del slt[random.randrange(len(slt))]
slt._check()
def test_delete():
slt = SortedListWithKey(range(20), load=4, key=modulo)
slt._check()
for val in range(20):
slt.remove(val)
slt._check()
assert len(slt) == 0
assert slt._maxes == []
assert slt._lists == []
def test_extend():
slt = SortedListWithKey(key=modulo)
slt._reset(4)
slt.extend(range(5))
slt._check()
slt.extend(range(6, 10))
slt._check()
def test_delete():
slt = SortedListWithKey(range(20), load=4, key=modulo)
slt._check()
for val in range(20):
slt.remove(val)
slt._check()
assert len(slt) == 0
assert slt._maxes == []
assert slt._lists == []
def test_delete():
slt = SortedListWithKey(range(20), key=negate)
slt._reset(4)
slt._check()
for val in range(20):
slt.remove(val)
slt._check()
assert len(slt) == 0
assert slt._maxes == []
assert slt._lists == []
def test_update():
slt = SortedListWithKey(key=negate)
slt.update(range(1000))
assert all(tup[0] == tup[1] for tup in zip(slt, reversed(range(1000))))
assert len(slt) == 1000
slt._check()
slt.update(range(10000))
assert len(slt) == 11000
slt._check()
def test_pop():
slt = SortedListWithKey(range(10), load=4, key=modulo)
slt._check()
assert slt.pop() == 9
slt._check()
assert slt.pop(0) == 0
slt._check()
assert slt.pop(-2) == 7
slt._check()
assert slt.pop(4) == 5
slt._check()
def test_pop():
slt = SortedListWithKey(range(10), load=4, key=negate)
slt._check()
assert slt.pop() == 0
slt._check()
assert slt.pop(0) == 9
slt._check()
assert slt.pop(-2) == 2
slt._check()
assert slt.pop(4) == 4
slt._check()
def test_update():
slt = SortedListWithKey(key=modulo, value_orderable=False)
slt.update(range(1000))
assert all(tup[0] == tup[1] for tup in zip(slt, sorted(range(1000), key=modulo)))
assert len(slt) == 1000
slt._check()
slt.update(range(10000))
assert len(slt) == 11000
slt._check()
def test_setitem():
random.seed(0)
slt = SortedListWithKey(range(0, 100, 10), load=4, key=negate)
slt[-3] = 20
slt._check()
values = list(enumerate(range(95, 5, -10)))
random.shuffle(values)
for pos, val in values:
slt[pos] = val
def test_update():
slt = SortedListWithKey(key=modulo)
slt.update(range(1000))
assert all(tup[0] == tup[1] for tup in zip(slt, sorted(range(1000), key=modulo)))
assert len(slt) == 1000
slt._check()
slt.update(range(10000))
assert len(slt) == 11000
slt._check()
def test_update():
slt = SortedListWithKey(key=negate)
slt.update(range(1000))
assert all(tup[0] == tup[1] for tup in zip(slt, reversed(range(1000))))
assert len(slt) == 1000
slt._check()
slt.update(range(10000))
assert len(slt) == 11000
slt._check()
def test_pop():
slt = SortedListWithKey(range(10), load=4, key=modulo)
slt._check()
assert slt.pop() == 9
slt._check()
assert slt.pop(0) == 0
slt._check()
assert slt.pop(-2) == 7
slt._check()
assert slt.pop(4) == 5
slt._check()
def test_pop():
slt = SortedListWithKey(range(10), load=4, key=negate)
slt._check()
assert slt.pop() == 0
slt._check()
assert slt.pop(0) == 9
slt._check()
assert slt.pop(-2) == 2
slt._check()
assert slt.pop(4) == 4
slt._check()
def test_setitem():
random.seed(0)
slt = SortedListWithKey(range(0, 100, 10), load=4, key=negate)
slt[-3] = 20
slt._check()
values = list(enumerate(range(95, 5, -10)))
random.shuffle(values)
for pos, val in values:
slt[pos] = val
def test_contains():
slt = SortedListWithKey(key=negate)
assert 0 not in slt
slt.update(range(10000))
for val in range(10000):
assert val in slt
assert 10000 not in slt
slt._check()
def test_count():
slt = SortedListWithKey(load=7, key=negate)
assert slt.count(0) == 0
for iii in range(100):
for jjj in range(iii):
slt.add(iii)
slt._check()
for iii in range(100):
assert slt.count(iii) == iii
def test_count():
slt = SortedListWithKey(load=7, key=negate)
assert slt.count(0) == 0
for iii in range(100):
for jjj in range(iii):
slt.add(iii)
slt._check()
for iii in range(100):
assert slt.count(iii) == iii
def test_delitem():
random.seed(0)
slt = SortedListWithKey(range(100), load=17, key=modulo)
while len(slt) > 0:
del slt[random.randrange(len(slt))]
slt._check()
slt = SortedListWithKey(range(100), load=17, key=modulo)
del slt[:]
assert len(slt) == 0
slt._check()
def test_delitem():
random.seed(0)
slt = SortedListWithKey(range(100), load=17, key=modulo)
while len(slt) > 0:
del slt[random.randrange(len(slt))]
slt._check()
slt = SortedListWithKey(range(100), load=17, key=modulo)
del slt[:]
assert len(slt) == 0
slt._check()
def test_contains():
slt = SortedListWithKey(key=negate)
assert 0 not in slt
slt.update(range(10000))
for val in range(10000):
assert val in slt
assert 10000 not in slt
slt._check()
def test_count():
slt = SortedListWithKey(load=7, key=modulo, value_orderable=False)
assert slt.count(0) == 0
for iii in range(100):
for jjj in range(iii):
slt.add(iii)
slt._check()
for iii in range(100):
assert slt.count(iii) == iii
def test_contains():
slt = SortedListWithKey(key=modulo, value_orderable=False)
assert 0 not in slt
slt.update(range(10000))
for val in range(10000):
assert val in slt
assert 10000 not in slt
slt._check()
def test_remove():
slt = SortedListWithKey(key=modulo)
assert slt.discard(0) == None
assert len(slt) == 0
slt._check()
slt = SortedListWithKey([1, 2, 2, 2, 3, 3, 5], load=4, key=modulo)
slt.remove(2)
slt._check()
assert all(tup[0] == tup[1] for tup in zip(slt, [1, 2, 2, 3, 3, 5]))
def test_remove():
slt = SortedListWithKey(key=modulo)
assert slt.discard(0) == None
assert len(slt) == 0
slt._check()
slt = SortedListWithKey([1, 2, 2, 2, 3, 3, 5], load=4, key=modulo)
slt.remove(2)
slt._check()
assert all(tup[0] == tup[1] for tup in zip(slt, [1, 2, 2, 3, 3, 5]))
def test_contains():
slt = SortedListWithKey(key=modulo, value_orderable=False)
assert 0 not in slt
slt.update(range(10000))
for val in range(10000):
assert val in slt
assert 10000 not in slt
slt._check()
slt = SortedListWithKey(range(10), key=modulo, value_orderable=False, load=4)
assert all(val not in slt for val in range(10, 20))
def test_getitem():
random.seed(0)
slt = SortedListWithKey(load=17, key=modulo)
slt.append(5)
slt._build_index()
slt._check()
slt.clear()
lst = list(random.random() for rpt in range(100))
slt.update(lst)
lst.sort(key=modulo)
assert all(slt[idx] == lst[idx] for idx in range(100))
assert all(slt[idx - 99] == lst[idx - 99] for idx in range(100))
def test_count():
slt = SortedListWithKey(load=7, key=modulo, value_orderable=False)
assert slt.count(0) == 0
for iii in range(100):
for jjj in range(iii):
slt.add(iii)
slt._check()
for iii in range(100):
assert slt.count(iii) == iii
slt = SortedListWithKey(range(8), key=modulo, value_orderable=False)
assert slt.count(9) == 0
def test_getitem():
random.seed(0)
slt = SortedListWithKey(load=17, key=modulo)
slt.append(5)
slt._build_index()
slt._check()
slt.clear()
lst = list(random.random() for rpt in range(100))
slt.update(lst)
lst.sort(key=modulo)
assert all(slt[idx] == lst[idx] for idx in range(100))
assert all(slt[idx - 99] == lst[idx - 99] for idx in range(100))
def test_remove():
slt = SortedListWithKey(key=negate)
assert slt.discard(0) == None
assert len(slt) == 0
slt._check()
slt = SortedListWithKey([1, 2, 2, 2, 3, 3, 5], key=negate)
slt._reset(4)
slt.remove(2)
slt._check()
assert all(tup[0] == tup[1]
for tup in zip(slt, reversed([1, 2, 2, 3, 3, 5])))
def test_contains():
slt = SortedListWithKey(key=modulo, load=7)
assert 0 not in slt
slt.update(range(100))
for val in range(100):
assert val in slt
assert 100 not in slt
slt._check()
slt = SortedListWithKey(range(100), key=modulo, load=4)
assert all(val not in slt for val in range(100, 200))
def test_discard():
slt = SortedListWithKey(key=modulo, value_orderable=False)
assert slt.discard(0) == None
assert len(slt) == 0
slt._check()
slt = SortedListWithKey([1, 2, 2, 2, 3, 3, 5], load=4, key=modulo, value_orderable=False)
slt.discard(6)
slt._check()
slt.discard(4)
slt._check()
slt.discard(2)
slt._check()
assert all(tup[0] == tup[1] for tup in zip(slt, [1, 2, 2, 3, 3, 5]))
def test_discard():
slt = SortedListWithKey(key=negate)
assert slt.discard(0) == None
assert len(slt) == 0
slt._check()
slt = SortedListWithKey([1, 2, 2, 2, 3, 3, 5], load=4, key=negate)
slt.discard(6)
slt._check()
slt.discard(4)
slt._check()
slt.discard(2)
slt._check()
assert all(tup[0] == tup[1] for tup in zip(slt, reversed([1, 2, 2, 3, 3, 5])))
def test_extend():
slt = SortedListWithKey(load=17, key=negate)
slt.extend(range(300, 200, -1))
slt._check()
slt.extend(list(range(200, 100, -1)))
slt._check()
for val in range(100, 0, -1):
slt.extend([val] * (val))
slt._check()
def test_extend():
slt = SortedListWithKey(load=17, key=negate)
slt.extend(range(300, 200, -1))
slt._check()
slt.extend(list(range(200, 100, -1)))
slt._check()
for val in range(100, 0, -1):
del slt._index[:]
slt._build_index()
slt.extend([val] * (101 - val))
slt._check()
def test_add():
random.seed(0)
slt = SortedListWithKey(key=modulo)
for val in range(1000):
slt.add(val)
slt._check()
slt = SortedListWithKey(key=modulo)
for val in range(1000, 0, -1):
slt.add(val)
slt._check()
slt = SortedListWithKey(key=modulo)
for val in range(1000):
slt.add(random.random())
slt._check()
def test_update():
slt = SortedListWithKey(key=negate)
slt.update(range(1000))
assert len(slt) == 1000
slt._check()
slt.update(range(100))
assert len(slt) == 1100
slt._check()
slt.update(range(10000))
assert len(slt) == 11100
slt._check()
values = sorted((val for val in chain(range(100), range(1000), range(10000))), key=negate)
assert all(tup[0] == tup[1] for tup in zip(slt, values))
