def test_get_last_node():
""" Test getting the last node """
a, b, c = Item("a"), Item("b"), Item("c")
tmp = LinkedList(None)
tmp.add_to_list(a)
assert tmp.get_last_node().item is a, "Expected last to be Item a"
tmp.add_to_list(b)
tmp.add_to_list(c)
assert tmp.get_last_node().item is c, "Expected last to be Item c"
def _gen_tmp_list():
tmp = LinkedList(None)
item_1 = Item("a")
item_2 = Item("b")
item_3 = Item("c")
tmp.add_to_list(item_1)
tmp.add_to_list(item_2)
tmp.add_to_list(item_3)
return tmp, [item_1, item_2, item_3]
def test_reverse_recur():
""" Test recursively reversing the linked list """
item_d = Item("d")
tmp = LinkedList(None)
tmp.add_to_list(item_d)
tmp.reverse_recur()
TestLinkedList._validate_list(tmp, [item_d])
tmp, [i1, i2, i3] = TestLinkedList._gen_tmp_list()
tmp.add_to_list(item_d)
tmp.reverse_recur()
TestLinkedList._validate_list(tmp, [item_d, i3, i2, i1])
def test_add():
""" Test adding an item to the linked list """
tmp = LinkedList(None)
tmp.add_to_list(Item("a"))
assert len(tmp) == 1
tmp.add_to_list(Item("b"))
tmp.add_to_list(Item("c"))
assert len(tmp) == 3
titles_correct = ["a", "b", "c"]
for idx, val in enumerate(tmp):
assert titles_correct[idx] == val.item.title
def test_add_to_list(self):
name = "Jose"
matric = "1234"
year = 2
node = Node(name, matric, year)
linked_list = LinkedList()
linked_list.add_to_list(node)
self.assertEqual(linked_list.get_root(), node)
def test_merge():
""" Test mergint the linked list """
letters = ["a", "c", "e", "g"]
letters2 = ["b", "d", "f", "h"]
items = []
l1, l2 = LinkedList(None), LinkedList(None)
for _, (i, i2) in enumerate(zip(letters, letters2)):
l1.add_to_list(Item(i))
items.append(Item(i))
l2.add_to_list(Item(i2))
items.append(Item(i2))
l1.merge(l2)
TestLinkedList._validate_list(l1, items)
def test_find_in_list(self):
names = ("Jose", "1234", 2), ("Rolf", "2345", 3), ("Anna", "3456", 7)
nodes = [Node(name, matric, year) for name, matric, year in names]
linked_list = LinkedList()
for node in nodes:
linked_list.add_to_list(node)
marker = linked_list.get_root()
for i in range(len(nodes) - 1, -1, -1):
self.assertEqual(linked_list.find_name(marker.get_name()), nodes[i])
marker = marker.get_next()
def test_sort():
""" Test sorting capability """
l = ListStore([3, 2, 7, 1])
after = sorted(l)
assert after[0] == 1
ll = LinkedList(None)
ll.add_to_list(Item("3"))
ll.add_to_list(Item("2"))
ll.add_to_list(Item("1"))
store2 = ListStore(ll, sort_method=sorted,
key_selector=lambda n: n.item.title)
store2 = store2.sort()
assert store2[0].item.title == "1"
assert isinstance(store2, list)
class Stack:
def __init__(self):
self.__linked_list = LinkedList()
def push(self, node):
self.__linked_list.add_to_list(node)
def pop(self):
return self.__linked_list.remove_start_from_list()
def print_details(self):
self.__linked_list.print_list()
def get_size(self):
return self.__linked_list.get_size()
def test_sort():
""" Test sorting the linked list """
tmp, [i1, i2, i3] = TestLinkedList._gen_tmp_list()
tmp.sort()
TestLinkedList._validate_list(tmp, [i1, i2, i3])
i4 = Item("d")
i5 = Item("e")
i6 = Item("f")
tmp.add_to_list(i5)
tmp.add_to_list(i6)
tmp.add_to_list(i4)
tmp.sort()
TestLinkedList._validate_list(tmp, [i1, i2, i3, i4, i5, i6])
tmp2 = LinkedList(None)
tmp2.add_to_list(i1)
tmp2.sort()
TestLinkedList._validate_list(tmp2, [i1])
def test_delete_element_from_position(self):
names = ("Jose", "1234", 2), ("Rolf", "2345", 3), \
("Anna", "3456", 7), ("James", "2675", 5)
nodes = [Node(name, matric, year) for name, matric, year in names]
linked_list = LinkedList()
for node in nodes:
linked_list.add_to_list(node)
linked_list.delete_element_from_position(linked_list.get_root(), 2)
nodes_after_delete = [node for node in nodes if node.get_name() != "Rolf"]
marker = linked_list.get_root ()
for i in range ( len (nodes_after_delete) - 1, -1, -1 ):
self.assertEqual(linked_list.find_name(marker.get_name()), nodes_after_delete[i] )
marker = marker.get_next()
def test_delete_year_greater_than_3(self):
names = ("Jose", "1234", 2), ("Rolf", "2345", 2), \
("Anna", "3456", 2), ("James", "2675", 7)
nodes = [Node ( name, matric, year ) for name, matric, year in names]
linked_list = LinkedList ()
for node in nodes:
linked_list.add_to_list ( node )
nodes_after_delete = [node for node in nodes if node.get_name () in ["Anna", "Rolf", "Jose"]]
marker = linked_list.get_root ()
linked_list.delete_year_greater_than ( marker, 3 )
marker = linked_list.get_root ()
for i in range ( len ( nodes_after_delete ) - 1, -1, -1 ):
self.assertEqual ( linked_list.find_name ( marker.get_name () ), nodes_after_delete[i] )
marker = marker.get_next ()
def test_insert_at_position3(self):
names = ("Jose", "1234", 7), ("Rolf", "2345", 7), \
("Anna", "3456", 7), ("James", "2675", 7)
nodes = [Node ( name, matric, year ) for name, matric, year in names]
linked_list = LinkedList ()
for node in nodes:
linked_list.add_to_list(node)
new_node = Node("Becky", "9898", 3)
# Insert in the middle.
nodes.insert(3, new_node)
linked_list.insert_at_position(linked_list.get_root(), new_node, 1)
marker = linked_list.get_root ()
for i in range(len(nodes) - 1, -1, -1):
self.assertEqual(linked_list.find_name(marker.get_name()), nodes[i])
marker = marker.get_next ()
def test_compare_two_lists_by_name(self):
names = ("Jose", "1234", 7), ("Rolf", "2345", 7), \
("Anna", "3456", 7), ("James", "2675", 7)
nodes = [Node ( name, matric, year ) for name, matric, year in names]
linked_list1 = LinkedList()
linked_list2 = LinkedList()
for node in nodes:
linked_list1.add_to_list(node)
linked_list2.add_to_list(node)
marker1 = linked_list1.get_root()
marker2 = linked_list2.get_root()
self.assertTrue(linked_list1.compare_two_lists_by_name(marker1, marker2))
linked_list2.reverse_linked_list(linked_list2.get_root())
marker2 = linked_list2.get_root ()
self.assertFalse(linked_list1.compare_two_lists_by_name(marker1, marker2))
def test_delete_year_greater_than_1(self):
names = ("Jose", "1234", 7), ("Rolf", "2345", 7), \
("Anna", "3456", 7), ("James", "2675", 7)
nodes = [Node(name, matric, year) for name, matric, year in names]
linked_list = LinkedList()
for node in nodes:
linked_list.add_to_list(node)
nodes_after_delete = [node for node in nodes if node.get_name() in []]
marker = linked_list.get_root()
linked_list.delete_year_greater_than(marker, 3)
# Make sure the head is updated, it could have been assigned to the node that meets
# has year <= than .
marker = linked_list.get_root()
for i in range ( len (nodes_after_delete) - 1, -1, -1 ):
self.assertEqual(linked_list.find_name(marker.get_name()), nodes_after_delete[i] )
marker = marker.get_next()
from Node_Stack import NodeS
from stack import Stack
from Node_BinaryTree import NodeB
from binary_tree import BinaryTree
print("---------------------- Linked List -------------------------------")
name = "Mary"
marks = 54
year = 2
student = Node(name, year, marks)
linked_list = LinkedList()
linked_list.add_to_list(student)
linked_list.print_list()
names = ("John", 2, 99), ("Ron", 3, 68), ("Anna", 7, 81)
students = [Node(name, year, marks) for name, year, marks in names]
new_linked_list = LinkedList()
for student in students:
new_linked_list.add_to_list(student)
new_linked_list.print_list()
new_linked_list.remove_from_list("Ron")
