def test_remove(self):
skip = SkipList([1, 2, 3])
with self.assertRaises(KeyError):
skip.remove(100)
x = 1
skip.remove(x)
self.assertNotIn(x, skip)
items = list(range(100))
random.shuffle(items)
skip = SkipList()
std = set()
for i, x in enumerate(items):
skip.add(x)
std.add(x)
self.assertEqual(sorted(list(skip)), sorted(list(std)))
for i, x in enumerate(items):
skip.remove(x)
std.remove(x)
self.assertNotIn(x, skip)
self.assertEqual(sorted(list(skip)), sorted(list(std)))
def test_relevel_2(self):
sl = SkipList(3)
sl.insert(1)
sl.insert(2)
sl.insert(3)
sl.insert(4)
sl.insert(5)
sl.insert(6)
sl.insert(7)
sl.insert(8)
sl.insert(9)
sl.relevel()
self.assertEqual(sl.get_at(0).level, 3)
self.assertEqual(sl.get_at(0).skiplist[0].data, 2)
self.assertEqual(sl.get_at(0).skiplist[1].data, 3)
self.assertEqual(sl.get_at(0).skiplist[2].data, 5)
self.assertEqual(sl.get_at(0).skiplist[3].data, 9)
self.assertEqual(sl.get_at(0).skipindex[0], 1)
self.assertEqual(sl.get_at(0).skipindex[1], 2)
self.assertEqual(sl.get_at(0).skipindex[2], 4)
self.assertEqual(sl.get_at(0).skipindex[3], 8)
self.assertEqual(sl.get_at(2).level, 1)
self.assertEqual(sl.get_at(2).skiplist[1].data, 5)
self.assertEqual(sl.get_at(4).level, 2)
self.assertEqual(sl.get_at(4).skiplist[1].data, 7)
self.assertEqual(sl.get_at(4).skiplist[2].data, 9)
self.assertEqual(sl.get_at(4).skipindex[0], 1)
self.assertEqual(sl.get_at(4).skipindex[1], 2)
self.assertEqual(sl.get_at(4).skipindex[2], 4)
def test_insert_r_second_2(self):
sl = SkipList()
sl.insert(1, 0)
sl.insert(2, 0)
self.assertEqual(sl.head.data, 1)
self.assertEqual(sl.head.skiplist[0].data, 2)
self.assertEqual(sl.get_at(0).skiplist.count(None), sl.max_height)
self.assertEqual(sl.get_at(1).skiplist.count(None), 1)
def test_find_r_2(self):
sl = SkipList()
sl.insert(3, 0)
sl.insert(1, 0)
self.assertEqual(sl.find_r(1), 1)
self.assertEqual(sl.find_r(3), 3)
self.assertEqual(sl.find_r(2), None)
def test_insert_r_third_2(self):
sl = SkipList()
sl.insert(1)
sl.insert(2)
sl.insert(3)
self.assertEqual(sl.head.data, 1)
self.assertEqual(sl.head.skiplist[0].data, 2)
self.assertEqual(sl.head.skiplist[0].skiplist[0].data, 3)
def test_insert_r_third_3(self):
sl = SkipList()
sl.insert(1)
sl.insert(2, 1)
sl.insert(3, 0)
self.assertEqual(sl.get_at(0).skiplist.count(None), sl.max_height - 1)
self.assertEqual(sl.get_at(1).skiplist.count(None), 1)
self.assertEqual(sl.get_at(2).skiplist.count(None), 1)
def test_insertion():
skl = SkipList()
skl.insert('A', 100)
skl.insert('B', 200)
assert skl.header.forward[0].key == 'A'
assert skl.header.forward[0].val == 100
assert skl.header.forward[0].forward[0].key == 'B'
assert skl.header.forward[0].forward[0].val == 200
def test_stress(self):
limit = 3000
sl = SkipList()
items = list(range(limit))
shuffle(items)
for i in range(limit):
sl.insert(items[i])
sl.remove(i / 2)
def test_skip_2(self):
sl = SkipList()
sl.insert(1, 1)
sl.insert(2, 0)
sl.insert(3, 1)
self.assertEqual(sl.head.data, 1)
self.assertEqual(sl.head.skiplist[0].data, 2)
self.assertEqual(sl.head.skiplist[1].data, 3)
def test_insert_r_index_2(self):
sl = SkipList()
sl.insert(1, sl.max_height)
sl.insert(2, 0)
sl.insert(3, 1)
self.assertEqual(sl.get_at(0).skipindex[0], 1)
self.assertEqual(sl.get_at(0).skipindex[1], 2)
self.assertEqual(sl.get_at(1).skipindex[0], 1)
self.assertEqual(sl.get_at(2).skipindex[0], 1)
def test_find_4(self):
sl = SkipList()
sl.insert(3, 1)
sl.insert(2, 0)
sl.insert(1, 1)
self.assertEqual(sl.find(1), 1)
self.assertEqual(sl.find(2), 2)
self.assertEqual(sl.find(3), 3)
self.assertEqual(sl.find(1.5), None)
def test_remove_r_last(self):
sl = SkipList()
sl.insert(2)
sl.insert(1)
sl.remove(2)
self.assertEqual(sl.head.data, 1)
for i in range(sl.max_height + 1):
self.assertIsNone(sl.head.skiplist[i])
def test_skip_1(self):
sl = SkipList()
sl.insert(3, 3)
sl.insert(2, 1)
sl.insert(1, 3)
self.assertEqual(sl.head.level, 3)
self.assertEqual(sl.find(2), 2)
self.assertEqual(sl.get_at(1).level, 3)
self.assertEqual(sl.head.skiplist[0].data, 2)
self.assertEqual(sl.head.skiplist[1].data, 2)
def test_get_at_3(self):
sl = SkipList()
sl.insert(1, 2)
sl.insert(2, 0)
sl.insert(3, 1)
self.assertEqual(sl.get_at(0).data, 1)
self.assertEqual(sl.get_at(1).data, 2)
self.assertEqual(sl.get_at(2).data, 3)
self.assertIsNone(sl.get_at(3))
def test_remove_r_first(self):
sl = SkipList()
sl.insert(1)
sl.insert(2, 0)
sl.remove(1)
self.assertEqual(sl.head.data, 2)
self.assertEqual(sl.head.level, sl.max_height)
for i in range(sl.max_height + 1):
self.assertIsNone(sl.head.skiplist[i])
def test_insert_r_third_1(self):
sl = SkipList()
sl.insert(3)
sl.insert(2)
sl.insert(1)
self.assertEqual(sl.head.data, 1)
self.assertEqual(sl.head.skiplist[0].data, 2)
self.assertEqual(sl.head.skiplist[0].skiplist[0].data, 3)
self.assertEqual(sl.get_at(0).skiplist.count(None), 0)
self.assertEqual(sl.get_at(1).skiplist.count(None), 0)
self.assertEqual(sl.get_at(2).skiplist.count(None), sl.max_height + 1)
def test_smoke(self):
skip = SkipList()
skip.add(3)
skip.add(2)
skip.add(1)
# print(skip.viz())
self.assertTrue(1 in skip)
self.assertTrue(2 in skip)
self.assertTrue(3 in skip)
self.assertFalse(0 in skip)
self.assertFalse(4 in skip)
self.assertFalse(10 in skip)
def test_add(self):
items = list(range(100))
random.shuffle(items)
skip = SkipList()
std = set()
for i, x in enumerate(items):
skip.add(x)
std.add(x)
self.assertEqual(x in skip, x in std)
for j in range(i):
y = items[j]
self.assertEqual(y in skip, y in std)
def process_query(self, expression):
stack = []
if not expression:
return SkipList(None)
exp = deque(expression)
while exp:
token = exp.popleft()
# Execute boolean operation if token is an operator.
# Retrieve postings list of previous terms from the stack.
if token in operators:
if token == 'NOT':
complement_postings = stack.pop()
# Special condition to facilitate a more efficient "AND NOT" query processing
if exp and exp[0] == 'AND':
next_operator = exp.popleft()
stack.append(
self.evaluate_and_not_query(
complement_postings, stack.pop()))
else:
all_postings = self.postings.get_postings_at_offset(0)
stack.append(
self.evaluate_and_not_query(
complement_postings, all_postings))
else:
postings1, postings2 = stack.pop(), stack.pop()
if token == 'AND':
stack.append(
self.evaluate_and_query(postings1, postings2))
elif token == 'OR':
stack.append(
self.evaluate_or_query(postings1, postings2))
# If token is a term, then load its postings list and put it on the stack.
else:
if self.token_in_vocab(token) is None:
stack.append(SkipList(None))
else:
stack.append(self.get_postings(token))
return stack.pop()
def test_remove_r_middle_2(self):
sl = SkipList()
sl.insert(1, 3)
sl.insert(2, 0)
sl.insert(3, 0)
sl.insert(4, 2)
sl.insert(5, 0)
sl.insert(6, 3)
sl.remove(4)
self.assertEqual(sl.head.data, 1)
self.assertEqual(sl.get_at(0).skiplist[2].data, 6)
self.assertEqual(sl.get_at(0).skiplist[1].data, 6)
self.assertEqual(sl.get_at(2).skiplist[0].data, 5)
def test__get_level(self):
sl = SkipList(3)
for x in range(1, 101, 2):
self.assertEqual(sl._get_level(x), 0)
self.assertEqual(sl._get_level(0), sl.max_height)
self.assertEqual(sl._get_level(2), 1)
self.assertEqual(sl._get_level(4), 2)
self.assertEqual(sl._get_level(6), 1)
self.assertEqual(sl._get_level(8), 3)
self.assertEqual(sl._get_level(10), 1)
self.assertEqual(sl._get_level(12), 2)
self.assertEqual(sl._get_level(14), 1)
self.assertEqual(sl._get_level(16), 3)
def test_remove_r_middle_1(self):
sl = SkipList()
sl.insert(3)
sl.insert(2)
sl.insert(1)
sl.remove(2)
self.assertEqual(sl.head.data, 1)
self.assertEqual(sl.get_at(1).data, 3)
self.assertIsNone(sl.find(2))
sl.insert(2)
self.assertEqual(sl.get_at(1).data, 2)
self.assertEqual(sl.get_at(2).data, 3)
def test_remove_r_index_1(self):
sl = SkipList()
sl.insert(1, 2)
sl.insert(2, 0)
sl.insert(3, 1)
sl.insert(4, 0)
sl.insert(5, 2)
sl.remove(3)
self.assertEqual(sl.get_at(0).skipindex[0], 1)
self.assertEqual(sl.get_at(0).skipindex[1], 3)
self.assertEqual(sl.get_at(0).skipindex[2], 3)
self.assertEqual(sl.get_at(1).skipindex[0], 1)
self.assertEqual(sl.get_at(2).skipindex[0], 1)
def test_remove_r_index_5(self):
# remove last
sl = SkipList()
sl.insert(1, 2)
sl.insert(2, 1)
sl.insert(3, 0)
sl.insert(4, 2)
sl.remove(4)
sl.insert(4, 2)
self.assertEqual(sl.get_at(0).skipindex[0], 1)
self.assertEqual(sl.get_at(0).skipindex[1], 1)
self.assertEqual(sl.get_at(0).skipindex[2], 3)
self.assertEqual(sl.get_at(1).skipindex[0], 1)
self.assertEqual(sl.get_at(1).skipindex[1], 2)
self.assertEqual(sl.get_at(2).skipindex[0], 1)
def test_insert_r_index_4(self):
# middle insert
sl = SkipList()
sl.insert(1, sl.max_height)
sl.insert(2, 0)
sl.insert(4, 1)
sl.insert(5, sl.max_height)
sl.insert(3, 2)
self.assertEqual(sl.get_at(3).skipindex[0], 1)
self.assertEqual(sl.get_at(3).skipindex[1], 1)
# *****
self.assertEqual(sl.get_at(2).skipindex[0], 1)
self.assertEqual(sl.get_at(2).skipindex[1], 1)
self.assertEqual(sl.get_at(2).skipindex[2], 2)
# *****
self.assertEqual(sl.get_at(1).skipindex[0], 1)
self.assertEqual(sl.get_at(0).skipindex[0], 1)
self.assertEqual(sl.get_at(0).skipindex[1], 2)
self.assertEqual(sl.get_at(0).skipindex[2], 2)
self.assertEqual(sl.get_at(0).skipindex[sl.max_height], 4)
def test_relevel(self):
sl = SkipList()
sl.insert(1, 3)
sl.insert(2, 3)
sl.insert(3, 2)
sl.relevel()
self.assertEqual(sl.get_at(0).level, 3)
self.assertEqual(sl.get_at(0).skiplist[0].data, 2)
self.assertEqual(sl.get_at(0).skiplist[1].data, 3)
self.assertEqual(sl.get_at(0).skiplist[2], None)
self.assertEqual(sl.get_at(0).skiplist[3], None)
self.assertEqual(sl.get_at(0).skipindex[0], 1)
self.assertEqual(sl.get_at(0).skipindex[1], 2)
self.assertEqual(sl.get_at(1).level, 0)
self.assertEqual(sl.get_at(1).skiplist[0].data, 3)
self.assertEqual(sl.get_at(1).skipindex[0], 1)
self.assertEqual(sl.get_at(2).level, 1)
self.assertEqual(sl.get_at(2).skiplist[0], None)
self.assertEqual(sl.get_at(2).skiplist[1], None)
def setUp(self):
self.sl = SkipList()
def test_insert_r_first(self):
sl = SkipList()
sl.insert(1)
self.assertEqual(sl.head.data, 1)
self.assertEqual(sl.head.skiplist.count(None), sl.max_height + 1)
def test_str(self):
sl = SkipList()
sl.insert(3)
sl.insert(2)
sl.insert(1)
self.assertEqual(str(sl), '[1,2,3]')
def test_find_r_1(self):
sl = SkipList()
sl.insert(3, 0)
sl.insert(1, 0)
self.assertEqual(sl.find_r(1), 1)
