class AddToHeadDescListWithMultipleValuesTestCase(unittest.TestCase):
def setUp(self) -> None:
self.ol = OrderedList(False)
for i in range(0, 6):
self.ol.add(i)
def test(self):
self.assertEqual(6, self.ol.len())
self.assertEqual(6, self.ol.len_reverse())
self.assertEqual(5, self.ol.head.value)
self.assertEqual(4, self.ol.head.next.value)
self.assertEqual(5, self.ol.head.next.prev.value)
self.assertEqual(0, self.ol.tail.value)
self.assertEqual(1, self.ol.tail.prev.value)
self.assertEqual(0, self.ol.tail.prev.next.value)
self.assertIsNone(self.ol.head.prev)
self.assertIsNone(self.ol.tail.next)
self.ol.add(100)
self.assertEqual(7, self.ol.len())
self.assertEqual(7, self.ol.len_reverse())
self.assertEqual(100, self.ol.head.value)
self.assertEqual(5, self.ol.head.next.value)
self.assertEqual(100, self.ol.head.next.prev.value)
self.assertEqual(self.ol.find(100), self.ol.head)
nodes = []
for i in self.ol.get_all():
nodes.append(i.value)
self.assertListEqual(nodes, [100, 5, 4, 3, 2, 1, 0])
def test_desc(self):
self.ol = OrderedList(False)
self.assertEqual(0, self.ol.len())
self.assertEqual(0, self.ol.len_reverse())
self.assertIsNone(self.ol.delete(30))
self.assertEqual(0, self.ol.len())
self.assertEqual(0, self.ol.len_reverse())
def test_add_ascending(self):
ol = OrderedList(asc=True)
items = [4, 6, 2, 8, 5]
for item in items:
ol.add(item)
items.sort()
self.assertEqual([node.value for node in ol.get_all()], items)
def test_len(self):
ol = OrderedList(asc=True)
items = [4, 6, 2, 8, 5]
for item in items:
ol.add(item)
self.assertEqual(ol.len(), len(items))
class AddToEndDescListWithMultipleValuesTestCase(unittest.TestCase):
def setUp(self) -> None:
self.ol = OrderedList(False)
for i in range(1, 7):
self.ol.add(i)
def test(self):
self.assertEqual(6, self.ol.len())
self.assertEqual(6, self.ol.len_reverse())
self.assertEqual(1, self.ol.tail.value)
self.assertEqual(2, self.ol.tail.prev.value)
self.assertEqual(1, self.ol.tail.prev.next.value)
self.assertIsNone(self.ol.tail.next)
self.ol.add(0)
self.assertEqual(7, self.ol.len())
self.assertEqual(7, self.ol.len_reverse())
self.assertEqual(0, self.ol.tail.value)
self.assertEqual(1, self.ol.tail.prev.value)
self.assertEqual(0, self.ol.tail.prev.next.value)
self.assertEqual(self.ol.find(0), self.ol.tail)
self.assertIsNone(self.ol.tail.next)
class AddToMiddleAscListTestCase(unittest.TestCase):
def setUp(self) -> None:
self.ol = OrderedList(True)
for i in range(0, 6):
self.ol.add(i)
def test(self):
self.assertEqual(6, self.ol.len())
self.assertEqual(6, self.ol.len_reverse())
self.assertEqual(0, self.ol.head.value)
self.assertEqual(5, self.ol.tail.value)
self.assertIsNone(self.ol.head.prev)
self.assertIsNone(self.ol.tail.next)
self.assertEqual(0, self.ol.head.next.prev.value)
self.ol.add(4)
nodes = []
for i in self.ol.get_all():
nodes.append(i.value)
self.assertListEqual(nodes, [0, 1, 2, 3, 4, 4, 5])
self.assertEqual(7, self.ol.len())
self.assertEqual(7, self.ol.len_reverse())
self.assertEqual(0, self.ol.head.value)
self.assertEqual(5, self.ol.tail.value)
self.assertIsNone(self.ol.head.prev)
self.assertIsNone(self.ol.tail.next)
def test_adding(self):
l = OrderedList()
self.assertEqual(l.size(), 0)
self.assertTrue(l.is_empty())
l.add(1)
self.assertEqual(l.size(), 1)
self.assertEqual(l.head.value, 1)
self.assertFalse(l.is_empty())
l.add(2)
self.assertEqual(l.size(), 2)
self.assertEqual(l.head.value, 1)
def test_find_by_value_descending(self):
ol = OrderedList(asc=True)
items = [4, 6, 2, 8, 5]
for item in items:
ol.add(item)
node = ol.find(4)
self.assertEqual(node.value, 4)
def test_pop(self):
lst = OrderedList()
self.assertRaises(IndexError, lst.pop)
lst.add(1)
lst.add(3)
lst.add(2)
self.assertRaises(IndexError, lst.pop, 3)
self.assertEqual(lst.pop(1), 2)
self.assertEqual(lst.pop(0), 1)
lst.add(4)
self.assertEqual(lst.pop(), 4)
self.assertEqual(lst.pop(), 3)
def test_4(self):
ordered_list = OrderedList()
self.assertEqual(ordered_list.is_empty(), True)
ordered_list.add(2)
ordered_list.add(1)
ordered_list.add(3)
self.assertEqual(ordered_list.head.val, 1)
self.assertEqual(ordered_list.tail.val, 3)
self.assertRaises(ValueError, ordered_list.remove, 4)
self.assertEqual(ordered_list.remove(2), 1)
self.assertEqual(ordered_list.pop(0), 1)
self.assertEqual(ordered_list.pop(), 3)
def test_3(self):
ordered_list = OrderedList()
self.assertEqual(ordered_list.is_empty(), True)
ordered_list.add(2)
self.assertEqual(ordered_list.head.val, 2)
self.assertEqual(ordered_list.tail.val, 2)
ordered_list.add(1)
ordered_list.add(3)
self.assertEqual(ordered_list.search_forward(3), True)
self.assertEqual(ordered_list.search_backward(3), True)
class AddToHeadAscListWithSingleValueTestCase(unittest.TestCase):
def setUp(self) -> None:
self.ol = OrderedList(True)
self.ol.add(1)
def test(self):
self.assertEqual(1, self.ol.len())
self.assertEqual(1, self.ol.len_reverse())
self.assertEqual(1, self.ol.head.value)
self.assertEqual(1, self.ol.tail.value)
self.assertIsNone(self.ol.head.prev)
self.assertIsNone(self.ol.head.next)
self.assertIsNone(self.ol.tail.next)
self.assertIsNone(self.ol.tail.prev)
self.ol.add(0)
self.assertEqual(2, self.ol.len())
self.assertEqual(2, self.ol.len_reverse())
self.assertEqual(0, self.ol.head.value)
self.assertIsNone(self.ol.head.prev)
self.assertEqual(1, self.ol.head.next.value)
self.assertEqual(0, self.ol.head.next.prev.value)
self.assertEqual(1, self.ol.tail.value)
self.assertEqual(0, self.ol.tail.prev.value)
self.assertIsNone(self.ol.tail.next)
def test_7(self):
ordered_list = OrderedList()
ordered_list.add(1)
ordered_list.add(2)
ordered_list.add(5)
ordered_list.add(3)
self.assertEqual(ordered_list.head.val, 1)
self.assertEqual(ordered_list.tail.val, 5)
self.assertEqual(ordered_list.search_forward(4), False)
self.assertEqual(ordered_list.search_forward(6), False)
self.assertEqual(ordered_list.search_forward(1), True)
self.assertEqual(ordered_list.search_backward(4), False)
self.assertEqual(ordered_list.search_backward(2), True)
self.assertEqual(ordered_list.search_backward(5), True)
class AddToHeadAscListWithMultipleValuesTestCase(unittest.TestCase):
def setUp(self) -> None:
self.ol = OrderedList(True)
for i in range(1, 6):
self.ol.add(i)
def test(self):
self.assertEqual(5, self.ol.len())
self.assertEqual(5, self.ol.len_reverse())
self.assertEqual(1, self.ol.head.value)
self.assertEqual(5, self.ol.tail.value)
self.assertIsNone(self.ol.head.prev)
self.assertIsNone(self.ol.tail.next)
self.ol.add(0)
self.assertEqual(6, self.ol.len())
self.assertEqual(6, self.ol.len_reverse())
self.assertEqual(0, self.ol.head.value)
self.assertEqual(5, self.ol.tail.value)
self.assertIsNone(self.ol.head.prev)
self.assertIsNone(self.ol.tail.next)
self.assertEqual(1, self.ol.head.next.value)
self.assertEqual(0, self.ol.head.next.prev.value)
def test_desc(self):
self.ol = OrderedList(False)
self.assertEqual(0, self.ol.len())
self.assertEqual(0, self.ol.len_reverse())
self.assertIsNone(self.ol.head)
self.assertIsNone(self.ol.tail)
self.ol.add(1)
self.assertEqual(1, self.ol.len())
self.assertEqual(1, self.ol.len_reverse())
self.assertEqual(1, self.ol.head.value)
self.assertEqual(1, self.ol.tail.value)
self.assertEqual(1, self.ol.get_all()[0].value)
def test_OrderedList_office_hours(self):
orderlst = OrderedList()
orderlst.add(5)
orderlst.add(3)
orderlst.add(6)
orderlst.add(2)
self.assertEqual(orderlst.pop(), 6)
self.assertEqual(orderlst.pop(0), 2)
def test_1(self):
ordered_list = OrderedList()
self.assertEqual(ordered_list.is_empty(), True)
ordered_list.add(2)
self.assertEqual(ordered_list.head.val, 2)
self.assertEqual(ordered_list.tail.val, 2)
ordered_list.add(1)
ordered_list.add(3)
self.assertEqual(ordered_list.size(), 3)
def test_search_forward(self):
lst = OrderedList()
self.assertFalse(lst.search_forward(10))
lst.head = Node(2, Node(5, Node(10, None)))
lst.tail = Node(10)
lst.num_items = 3
self.assertTrue(lst.search_forward(10))
class DeleteFromEmptyListTestCase(unittest.TestCase):
def test_asc(self):
self.ol = OrderedList(True)
self.assertEqual(0, self.ol.len())
self.assertEqual(0, self.ol.len_reverse())
self.assertIsNone(self.ol.delete(30))
self.assertEqual(0, self.ol.len())
self.assertEqual(0, self.ol.len_reverse())
def test_desc(self):
self.ol = OrderedList(False)
self.assertEqual(0, self.ol.len())
self.assertEqual(0, self.ol.len_reverse())
self.assertIsNone(self.ol.delete(30))
self.assertEqual(0, self.ol.len())
self.assertEqual(0, self.ol.len_reverse())
def test_2(self):
ordered_list = OrderedList()
ordered_list.add(2)
self.assertEqual(ordered_list.head.val, 2)
self.assertEqual(ordered_list.tail.val, 2)
ordered_list.add(1)
ordered_list.add(3)
self.assertEqual(ordered_list.index(1), 0)
self.assertEqual(ordered_list.index(2), 1)
self.assertEqual(ordered_list.index(3), 2)
self.assertRaises(LookupError, ordered_list.index, 4)
def test_remove(self):
lst = OrderedList()
lst.add(1)
lst.add(3)
lst.add(2)
self.assertEqual(lst.remove(1), 0)
self.assertEqual(lst.remove(3), 1)
self.assertRaises(ValueError, lst.remove, 3)
def test_5(self):
ordered_list = OrderedList()
ordered_list.add(1)
ordered_list.add(2)
ordered_list.add(5)
ordered_list.add(3)
self.assertEqual(ordered_list.head.val, 1)
self.assertEqual(ordered_list.tail.val, 5)
self.assertEqual(ordered_list.size(), 4)
class FindAscTestCase(unittest.TestCase):
def setUp(self) -> None:
self.ol = OrderedList(True)
for i in range(0, 6):
self.ol.add(i)
def test(self):
self.assertEqual(6, self.ol.len())
self.assertEqual(6, self.ol.len_reverse())
self.assertIsInstance(self.ol.find(0), Node)
self.assertIsInstance(self.ol.find(5), Node)
self.assertIsInstance(self.ol.find(3), Node)
self.assertEqual(6, self.ol.len())
self.assertEqual(6, self.ol.len_reverse())
def test_empty(self):
self.ol = OrderedList(True)
self.assertIsNone(self.ol.find(3))
class DeleteFromMiddleAscListWithMultipleValuesTestCase(unittest.TestCase):
def setUp(self) -> None:
self.ol = OrderedList(True)
for i in range(0, 6):
self.ol.add(i)
def test(self):
self.assertEqual(6, self.ol.len())
self.assertEqual(6, self.ol.len_reverse())
self.assertEqual(0, self.ol.head.value)
self.assertEqual(5, self.ol.tail.value)
self.assertIsNone(self.ol.head.prev)
self.assertIsNone(self.ol.tail.next)
self.ol.delete(2)
self.ol.delete(4)
self.assertEqual(4, self.ol.len())
self.assertEqual(4, self.ol.len_reverse())
self.assertEqual(self.ol.find(3).prev, self.ol.find(1))
self.assertEqual(self.ol.find(3).next, self.ol.find(5))
def test_index(self):
lst = OrderedList()
self.assertRaises(LookupError, lst.index, 5)
lst.head = Node(2, Node(5, Node(10, None)))
lst.num_items = 3
self.assertEqual(lst.index(5), 1)
self.assertEqual(lst.index(2), 0)
self.assertEqual(lst.index(10), 2)
def create_huff_tree(char_freq):
'''Create a Huffman tree for characters with non-zero frequency
Returns the root node of the Huffman tree'''
ol = OrderedList()
for i in range(255):
if char_freq[i] != 0:
ol.add(HuffmanNode(i, char_freq[i]))
while ol.size() > 1:
a = ol.pop(0)
b = ol.pop(0)
if a.char < b.char:
char = a.char
else:
char = b.char
new = HuffmanNode(char, a.freq + b.freq)
new.left = a
new.right = b
ol.add(new)
return ol.pop(0)
def test_delete_ascending_end(self):
ol = OrderedList(asc=True)
items = [4, 6, 2, 8, 5]
for item in items:
ol.add(item)
items.sort()
items.remove(8)
ol.delete(8)
self.assertEqual([node.value for node in ol.get_all()], items)
def test_delete_descending_begin(self):
ol = OrderedList(asc=False)
items = [4, 6, 2, 8, 5]
for item in items:
ol.add(item)
items.sort(reverse=True)
items.remove(2)
ol.delete(2)
self.assertEqual([node.value for node in ol.get_all()], items)
def test_clean(self):
ol = OrderedList(asc=True)
items = [4, 6, 2, 8, 5]
for item in items:
ol.add(item)
ol.clean(asc=True)
self.assertEqual(ol.head, None)
self.assertEqual(ol.tail, None)
class DeleteFromHeadDescListWithMultipleValuesTestCase(unittest.TestCase):
def setUp(self) -> None:
self.ol = OrderedList(False)
for i in range(0, 6):
self.ol.add(i)
def test(self):
self.assertEqual(6, self.ol.len())
self.assertEqual(6, self.ol.len_reverse())
self.assertEqual(5, self.ol.head.value)
self.assertEqual(4, self.ol.head.next.value)
self.assertEqual(5, self.ol.head.next.prev.value)
self.ol.delete(4)
self.ol.delete(5)
self.assertEqual(4, self.ol.len())
self.assertEqual(4, self.ol.len_reverse())
self.assertEqual(3, self.ol.head.value)
self.assertEqual(2, self.ol.head.next.value)
self.assertIsNone(self.ol.head.prev)
class CompareTestCase(unittest.TestCase):
def setUp(self) -> None:
self.ol = OrderedList(True)
def test(self):
self.assertEqual(+1, self.ol.compare(3, 1))
self.assertEqual(+1, self.ol.compare(3, 0))
self.assertEqual(+1, self.ol.compare(301, 100))
self.assertEqual(-1, self.ol.compare(1, 3))
self.assertEqual(-1, self.ol.compare(0, 3))
self.assertEqual(-1, self.ol.compare(200, 300))
self.assertEqual(0, self.ol.compare(0, 0))
self.assertEqual(0, self.ol.compare(1, 1))
self.assertEqual(0, self.ol.compare(300, 300))
def test_searching(self):
l = OrderedList()
for i in range(4):
l.add(i)
for i in range(4):
self.assertTrue(l.search(i))
