linked_list_practice.py

class Node:
    def __init__(self, data, p_node=None, n_node=None):
        self.p_node = p_node
        self.n_node = n_node
        self.data = data

class LList:
    def __init__(self):
        self.length = 0
        self.first = None
        self.last = None

    #Serves three roles, can prepend, insert, and append values to the list
    def insert(self, data, index=0):
        if self.length == 0:
            self.first = self.last = Node(data)
        if self.length > 0:
            if index == 0:
                new_first = Node(data, n_node=self.first)
                self.first.p_node = new_first
                self.first = new_first
            if index < self.length:
                count = 0
                current_node = self.first
                while count < index - 1:
                    current_node = current_node.n_node
                    count += 1
                new_node = Node(data=data, p_node=current_node, n_node=current_node.n_node)
                next_node = current_node.n_node
                next_node.p_node = new_node
                current_node.n_node = new_node
            if index == self.length:
                new_last = Node(data, p_node=self.last)
                self.last.n_node = new_last
                self.last = new_last
        self.length += 1
#Need to cover modifying first, middle, and last elements

    def remove(self, index):
        #Empty list case
        if self.length == 0:
            raise Exception('List is empty')
        if index > self.length:
            raise Exception('Index out of bounds')
        else:
            #first case
            if index == 0:
                if self.first.n_node:
                    new_first = self.first.n_node
                    new_first.p_node = None
                    self.first = new_first
                else:
                    self.first = self.last = None
            #middle case
            elif index < self.length - 1:
                count = 0
                current_node = self.first
                while count < index:
                    current_node = current_node.n_node
                    count += 1
                new_current = current_node.p_node
                new_next = current_node.n_node
                new_current.n_node = new_next
                new_next.p_node = new_current
            #last case
            elif index == self.length - 1:
                self.last = self.last.p_node
                self.last.n_node = None
        self.length -= 1

    def find(self, index):
        if index < self.length:
            current_node = self.first
            count = 0
            while count < index:
                current_node = current_node.n_node
                count += 1
            return current_node.data
        else:
            return f'Index out of bounds:  Length = {self.length}, Index = {index}'

linked_list_practice_tests.py

import unittest
import linked_list_practice

class TestDList(unittest.TestCase):

    def test_empty_list(self):
        emptpy_d_list = linked_list_practice.LList()
        self.assertEqual(0, emptpy_d_list.length)
        self.assertEqual(None, emptpy_d_list.first)
        self.assertEqual(None, emptpy_d_list.last)

    def test_single_elem_list(self):
        one_el_list = linked_list_practice.LList()
        one_el_list.insert(1234)
        self.assertEqual(1234, one_el_list.first.data)
        self.assertEqual(1234, one_el_list.last.data)
        self.assertEqual(1, one_el_list.length)

    def test_2_elem_list(self):
        two_el_list = linked_list_practice.LList()
        two_el_list.insert(5678, 0)
        two_el_list.insert(1234, 0)
        self.assertEqual(2, two_el_list.length)
        self.assertEqual(1234, two_el_list.first.data)
        self.assertEqual(5678, two_el_list.last.data)

    def test_multi_elem_list(self):
        multi_elem_list = linked_list_practice.LList()
        multi_elem_list.insert(1234, 0)
        self.assertEqual(1, multi_elem_list.length)
        self.assertEqual(1234, multi_elem_list.first.data)
        multi_elem_list.insert(5678, 1)
        self.assertEqual(2, multi_elem_list.length)
        self.assertEqual(multi_elem_list.first, multi_elem_list.last.p_node)
        multi_elem_list.insert(9101112, 2)
        multi_elem_list.insert('Hello', 1)
        multi_elem_list.insert('World', 2)
        self.assertEqual(1234, multi_elem_list.first.data)
        self.assertEqual(9101112, multi_elem_list.last.data)
        self.assertEqual('Hello', multi_elem_list.find(1))
        self.assertEqual('World', multi_elem_list.find(2))
        self.assertEqual(5678, multi_elem_list.find(3))

    def test_remove(self):
        single_elem_list = linked_list_practice.LList()
        single_elem_list.insert(999, 0)
        single_elem_list.remove(0)
        multi_elem_list = linked_list_practice.LList()
        for i in range(10):
            multi_elem_list.insert(i, i)
        #Test removal of head and tail
        multi_elem_list.remove(9)
        multi_elem_list.remove(0)
        self.assertEqual(1, multi_elem_list.find(0))
        self.assertEqual(8, multi_elem_list.find(7))
        self.assertEqual(8, multi_elem_list.length)
        #Test removal of element in list
        multi_elem_list.remove(1)
        self.assertEqual(3, multi_elem_list.find(1))
        multi_elem_list.remove(5)
        self.assertEqual(8, multi_elem_list.find(5))
        #depopulate the list
        for i in range(multi_elem_list.length):
            multi_elem_list.remove(0)




if __name__ == '__main__':
    unittest.main()