def test_find_in_list():
node_1 = LinkedListNode(1)
node_2 = LinkedListNode(2)
node_3 = LinkedListNode(3)
linked_list = LinkedList(node_1)
linked_list.head.next = node_2
node_2.next = node_3
expected = True
output = linked_list.find(3)
assert output == expected
class TestLinkedList(unittest.TestCase):
def setUp(self):
self.list = LinkedList()
def tearDown(self):
del self.list
def test_add_in_tail(self):
first_node = Node(23)
second_node = Node(72)
self.list.add_in_tail(first_node)
self.assertEqual(first_node, self.list.head)
self.assertEqual(first_node, self.list.tail)
self.list.add_in_tail(second_node)
self.assertEqual(first_node, self.list.head)
self.assertEqual(second_node, self.list.tail)
self.assertEqual(second_node, first_node.next)
self.assertIsNone(second_node.next)
def test_find(self):
node = Node(99)
self.list.add_in_tail(Node(13))
self.list.add_in_tail(Node(0))
self.list.add_in_tail(node)
self.list.add_in_tail(Node(44))
found_node = self.list.find(node.value)
self.assertIsNotNone(found_node)
self.assertEqual(node, found_node)
def test_find_in_empty_list(self):
node = Node(99)
found_node = self.list.find(node.value)
self.assertEqual(0, self.list.len())
self.assertIsNone(found_node)
def test_find_all(self):
source_node = Node(99)
self.list.add_in_tail(Node(28))
self.list.add_in_tail(Node(source_node.value))
self.populate_list(self.list)
self.list.add_in_tail(Node(source_node.value))
self.list.add_in_tail(Node(81))
self.list.add_in_tail(source_node)
found_nodes = self.list.find_all(source_node.value)
self.assertEqual(3, len(found_nodes))
for node in found_nodes:
self.assertEqual(source_node.value, node.value)
def test_find_all_in_empty_list(self):
node = Node(99)
found_nodes = self.list.find_all(node.value)
self.assertEqual(0, self.list.len())
self.assertEqual([], found_nodes)
def test_len(self):
nodes = self.populate_list(self.list)
self.assertEqual(len(nodes), self.list.len())
def test_clean(self):
nodes = self.populate_list(self.list)
self.list.clean()
self.assertIsNone(self.list.head)
self.assertIsNone(self.list.tail)
for node in nodes:
self.assertIsNone(node.next)
def test_insert_after(self):
node = Node(99)
prev_node = Node(77)
self.list.add_in_tail(Node(35))
self.list.add_in_tail(prev_node)
self.list.add_in_tail(Node(64))
self.list.insert(prev_node, node)
self.assertEqual(4, self.list.len())
self.assertEqual(node, prev_node.next)
def test_insert_in_head(self):
node = Node(99)
nodes = self.populate_list(self.list)
self.list.insert(None, node)
self.assertEqual(node, self.list.head)
self.assertNotEqual(node, self.list.tail)
self.assertEqual(nodes[len(nodes) - 1], self.list.tail)
self.assertEqual(len(nodes) + 1, self.list.len())
def test_insert_multiple(self):
prev_node = None
nodes = (
Node(12),
Node(34),
Node(56),
)
for node in nodes:
self.list.insert(prev_node, node)
prev_node = node
self.assertEqual(len(nodes), self.list.len())
self.assertEqual(nodes[0], self.list.head)
self.assertEqual(nodes[len(nodes) - 1], self.list.tail)
def test_insert_in_tail(self):
node = Node(99)
nodes = self.populate_list(self.list)
self.list.insert(self.list.tail, node)
self.assertNotEqual(node, self.list.head)
self.assertEqual(nodes[0], self.list.head)
self.assertEqual(node, self.list.tail)
self.assertEqual(len(nodes) + 1, self.list.len())
def test_insert_in_empty_list(self):
node = Node(99)
self.list.insert(None, node)
self.assertEqual(node, self.list.head)
self.assertEqual(node, self.list.tail)
self.assertEqual(1, self.list.len())
def test_delete_in_head(self):
node = Node(99)
node_alt = Node(node.value)
self.list.add_in_tail(node)
nodes = self.populate_list(self.list)
self.list.add_in_tail(node_alt)
self.list.delete(node.value)
self.assertEqual(len(nodes) + 1, self.list.len())
self.assertEqual(1, len(self.list.find_all(node.value)))
self.assertNotEqual(node, self.list.head)
self.assertEqual(nodes[0], self.list.head)
self.assertEqual(node_alt, self.list.tail)
self.assertIsNone(node.next)
def test_delete_in_tail(self):
node = Node(99)
nodes = self.populate_list(self.list)
self.list.add_in_tail(node)
self.list.delete(node.value)
self.assertEqual(len(nodes), self.list.len())
self.assertEqual(0, len(self.list.find_all(node.value)))
self.assertEqual(nodes[0], self.list.head)
self.assertNotEqual(node, self.list.tail)
self.assertEqual(nodes[len(nodes) - 1], self.list.tail)
self.assertIsNone(node.next)
def test_delete_all(self):
node = Node(99)
node_alt = Node(node.value)
self.list.add_in_tail(node)
nodes = self.populate_list(self.list)
self.list.add_in_tail(node_alt)
self.list.delete(node.value, True)
self.assertEqual(len(nodes), self.list.len())
self.assertEqual(0, len(self.list.find_all(node.value)))
self.assertNotEqual(node, self.list.head)
self.assertEqual(nodes[0], self.list.head)
self.assertNotEqual(node_alt, self.list.tail)
self.assertEqual(nodes[len(nodes) - 1], self.list.tail)
self.assertIsNone(node.next)
self.assertIsNone(node_alt.next)
def test_delete_all_with_sequentially_nodes(self):
node = Node(99)
node_alt = Node(node.value)
node_result = Node(8)
self.list.add_in_tail(node)
self.list.add_in_tail(node_alt)
self.list.add_in_tail(node_result)
self.list.delete(node.value, True)
self.assertEqual(1, self.list.len())
self.assertEqual(0, len(self.list.find_all(node.value)))
self.assertNotEqual(node, self.list.head)
self.assertNotEqual(node_alt, self.list.head)
self.assertEqual(node_result, self.list.head)
self.assertNotEqual(node, self.list.tail)
self.assertNotEqual(node_alt, self.list.tail)
self.assertEqual(node_result, self.list.tail)
self.assertIsNone(node.next)
self.assertIsNone(node_alt.next)
def test_delete_all_in_empty_list(self):
self.list.delete(99, True)
self.assertEqual(0, self.list.len())
self.assertIsNone(self.list.head)
self.assertIsNone(self.list.tail)
def test_delete_all_in_one_elem_list(self):
node = Node(99)
self.list.add_in_tail(node)
self.list.delete(node.value, True)
self.assertEqual(0, self.list.len())
self.assertIsNone(self.list.head)
self.assertIsNone(self.list.tail)
self.assertIsNone(node.next)
@staticmethod
def populate_list(llist: LinkedList):
nodes = (
Node(12),
Node(34),
Node(56),
)
for node in nodes:
llist.add_in_tail(node)
return nodes
def test_find_in_empty_list():
linked_list = LinkedList()
expected = False
output = linked_list.find(1)
assert output == expected
class TestLinkedList(TestCase):
@classmethod
def get_next_element(cls, node):
return node.get_next().get_element()
def setUp(self):
self.l = LinkedList()
def test_is_empty_for_new_list_returns_true(self):
self.assertTrue(self.l.is_empty)
def test_is_empty_for_populated_list_returns_false(self):
self.l.add_first(1)
self.assertFalse(self.l.is_empty())
def test_get_first_from_empty_list_throws_exception(self):
self.assertRaises(Empty, self.l.get_first)
def test_get_first_from_populated_list_returns_head_node(self):
self.l.add_first(1)
self.l.add_first(2)
h = self.l.get_first()
self.assertEquals(h.get_element(), 2)
def test_add_first_returns_added_node(self):
self.assertEquals(self.l.add_first(1).get_element(), 1)
def test_add_first_links_nodes_between_them(self):
self.l.add_first(2)
self.l.add_first(1)
h = self.l.get_first()
self.assertEquals(TestLinkedList.get_next_element(h), 2)
def test_length_on_empty_list_returns_0(self):
self.assertEquals(len(self.l), 0)
def test_length_on_populated_list_returns_correct_length(self):
self.l.add_first(1)
self.assertEquals(len(self.l), 1)
def test_find_when_list_is_empty(self):
self.assertRaises(Empty, self.l.find, 1)
def test_find_on_populated_list_returns_the_element_node(self):
self.l.add_first(1)
self.assertEquals(self.l.find(1).get_element(), 1)
def test_find_non_existing_element_returns_null(self):
self.l.add_first(1)
self.assertEquals(self.l.find(2), None)
def test_contains_on_empty_list_throws_exception(self):
self.assertRaises(Empty, self.l.contains, 1)
def test_contains_existing_element_returns_true(self):
self.l.add_first(1)
self.assertTrue(self.l.contains(1))
def test_contains_non_existing_element_returns_false(self):
self.l.add_first(1)
self.assertFalse(self.l.contains(2))
def test_remove_from_empty_list_throws_error(self):
self.assertRaises(Empty, self.l.remove, 1)
def test_remove_non_existing_element_returns_false(self):
self.l.add_first(10)
self.assertFalse(self.l.remove(2))
def test_remove_first_element_of_one_element_list_returns_true(self):
self.l.add_first(1)
self.assertTrue(self.l.remove(1))
def test_remove_first_element_of_one_element_list_decreases_the_length_of_the_list(
self):
self.l.add_first(1)
self.l.remove(1)
self.assertEquals(len(self.l), 0)
def test_remove_first_element_of_one_element_list_makes_head_empty(self):
self.l.add_first(1)
self.l.remove(1)
self.assertRaises(Empty, self.l.get_first)
def test_remove_first_element_of_a_list_returns_true(self):
self.l.add_first(1)
self.l.add_first(2)
self.assertTrue(self.l.remove(2))
def test_remove_first_element_of_a_list_makes_the_next_element_as_new_head(
self):
self.l.add_first(1)
self.l.add_first(2)
self.l.remove(2)
self.assertTrue(self.l.get_first().get_element(), 1)
def test_remove_last_element_of_a_list_with_two_elements_returns_true(
self):
self.l.add_first(1)
self.l.add_first(2)
self.assertTrue(self.l.remove(1))
def test_remove_last_element_of_a_list_with_two_elements_doesnt_change_head(
self):
self.l.add_first(1)
self.l.add_first(2)
self.l.remove(1)
self.assertTrue(self.l.get_first().get_element(), 2)
def test_remove_last_element_of_a_list_with_two_elements_breaks_the_link_with_head(
self):
self.l.add_first(1)
n = self.l.add_first(2)
self.l.remove(1)
self.assertEquals(n.get_next(), None)
def test_remove_element_of_a_list_returns_true(self):
self.l.add_first(1)
self.l.add_first(2)
self.l.add_first(3)
self.assertTrue(self.l.remove(2))
def test_remove_element_of_a_list_updates_link_between_nodes(self):
self.l.add_first(1)
self.l.add_first(2)
self.l.add_first(3)
self.l.remove(2)
v = TestLinkedList.get_next_element(self.l.get_first())
self.assertEquals(v, 1)
def test_remove_first_element_changes_the_head_node(self):
self.l.add_first(1)
n = self.l.add_first(2)
self.l.add_first(3)
self.l.remove(3)
self.assertEquals(self.l.get_first(), n)
def test_list_nodes_from_empty_list_returns_nothing(self):
r = set()
for node in self.l.get_elements():
r.add(node)
self.assertEquals(r, set())
def test_list_nodes_iterates_through_all_list(self):
self.l.add_first(1)
self.l.add_first(2)
self.l.add_first(3)
r = set()
for node in self.l.get_elements():
r.add(node)
self.assertEquals(r, set([1, 2, 3]))
