def test_singly_linked_list_not_equal(self):
     """
     Test operator "equal" - inverted.
     """
     a_list1 = singly_linked_list.SinglyLinkedList()
     a_list2 = singly_linked_list.SinglyLinkedList()
     a_list1.append('a')
     a_list1.append('b')
     a_list1.append('c')
     a_list2.append('a')
     a_list2.append('b')
     a_list2.append('d')
     self.assertNotEqual(a_list1, a_list2)
    def test_singly_linked_list_element_remove_first_two(self):
        """
        Testing removing a linked list element from a linked
        list. In this test the linked list contains two
        elements prior to removing the first element.

        Before removing:
        list = [a] -> [b]
        After removing:
        list = [b]
        """
        a_list = singly_linked_list.SinglyLinkedList()
        elem1 = singly_linked_list.SinglyLinkedListElement(a_list, 'b', None)
        elem0 = singly_linked_list.SinglyLinkedListElement(a_list, 'a', elem1)

        a_list.append(elem0.get_data())
        a_list.append(elem1.get_data())

        elem0.remove()

        res = []
        res.append(a_list[0])

        ref = []
        ref.append(elem1)

        t_1 = a_list.get_head() == a_list[0]
        t_2 = a_list.get_tail() == a_list[0]
        t_3 = elem1.get_next() == None
        t_4 = len(a_list) == 1
        t_5 = ref == res
        test = t_1 and t_2 and t_3 and t_4 and t_5
        self.assertTrue(test)
 def test_singly_linked_list_insert_at_empty(self):
     """
     Test method "insert_at".
     """
     a_list = singly_linked_list.SinglyLinkedList()
     a_list.insert_at(0, 'b')
     self.assertEqual('b', a_list[0].get_data())
 def test_singly_linked_list_copy_equal(self):
     """
     Test operator "copy".
     """
     a_list1 = singly_linked_list.SinglyLinkedList()
     a_list1.append('a')
     a_list1.append('b')
     a_list1.append('c')
     a_list2 = copy.copy(a_list1)
     #         print ""
     #         print l1
     #         print l2
     #         print len( l1 )
     #         print len( l2 )
     #         print l1[0]
     #         print l2[0]
     #         print l1[1]
     #         print l2[1]
     #         print l1[2]
     #         print l2[2]
     #         print l1.get_head()
     #         print l2.get_head()
     #         print l1.get_tail()
     #         # NOTE: it appears that the tail is different!!!
     #         print l2.get_tail()
     self.assertEqual(a_list1, a_list2)
    def test_singly_linked_list_element_insert_before_first_one(self):
        """
        Testing inserting a linked list element into a linked
        list. In this test the linked list contains a single
        element prior to the insertion of the second element
        and the new element is inserted before the first element.

        Before inserting:
        list = [b]
        After inserting:
        list = [a] -> [b]
        """
        a_list = singly_linked_list.SinglyLinkedList()
        elem1 = singly_linked_list.SinglyLinkedListElement(a_list, 'b', None)
        elemx = singly_linked_list.SinglyLinkedListElement(a_list, 'a', elem1)
        a_list.append(elem1.get_data())

        elem1.insert_before('a')

        res = []
        res.append(a_list[0])
        res.append(a_list[1])

        ref = []
        ref.append(elemx)
        ref.append(elem1)

        t_1 = a_list.get_head() == a_list[0]
        t_2 = a_list.get_tail() == a_list[1]
        t_3 = a_list[0].get_next() == a_list[1]
        t_4 = a_list[1].get_next() == None
        t_5 = len(a_list) == 2
        t_6 = ref == res
        test = t_1 and t_2 and t_3 and t_4 and t_5 and t_6
        self.assertTrue(test)
 def test_singly_linked_list_element_get_data(self):
     """
     Test method (list element) "get_data".
     """
     a_list = singly_linked_list.SinglyLinkedList()
     elem = singly_linked_list.SinglyLinkedListElement(a_list, 'a', None)
     self.assertEqual('a', elem.get_data())
 def test_singly_linked_list_clear(self):
     """
     Test method "clear".
     """
     a_list = singly_linked_list.SinglyLinkedList()
     a_list.append('a')
     a_list.clear()
     self.assertTrue(a_list.is_empty())
 def test_singly_linked_list_element_copy_equal(self):
     """
     Test operator (list element) "copy".
     """
     a_list = singly_linked_list.SinglyLinkedList()
     elem = singly_linked_list.SinglyLinkedListElement(a_list, 'a', None)
     e_copy = copy.copy(elem)
     self.assertEqual(elem, e_copy)
 def test_singly_linked_list_element_not_equal(self):
     """
     Test operator (list element) "equal" - inverted.
     """
     a_list = singly_linked_list.SinglyLinkedList()
     elem1 = singly_linked_list.SinglyLinkedListElement(a_list, 'a', None)
     elem2 = singly_linked_list.SinglyLinkedListElement(a_list, 'b', None)
     self.assertNotEqual(elem1, elem2)
 def test_singly_linked_list_element_get_next(self):
     """
     Test method (list element) "get_next".
     """
     a_list = singly_linked_list.SinglyLinkedList()
     elem2 = singly_linked_list.SinglyLinkedListElement(a_list, 'b', None)
     elem1 = singly_linked_list.SinglyLinkedListElement(a_list, 'a', elem2)
     self.assertEqual(elem2, elem1.get_next())
 def test_singly_linked_list_element_copy_not_equal(self):
     """
     Test operator (list element) "copy" - inverted.
     """
     a_list = singly_linked_list.SinglyLinkedList()
     elem = singly_linked_list.SinglyLinkedListElement(a_list, 'a', None)
     e_copy = copy.copy(elem)
     elem.data = 'aa'
     self.assertNotEqual(elem, e_copy)
 def test_singly_linked_list_insert_after_element(self):
     """
     Test method "insert_after_element".
     """
     a_list = singly_linked_list.SinglyLinkedList()
     a_list.append('a')
     a_list.append('b')
     a_list.append('c')
     elem2 = a_list[2]
     a_list.insert_after_element('cc', elem2)
     self.assertEqual('cc', a_list[3].get_data())
 def test_singly_linked_list_copy_not_equal(self):
     """
     Test operator "copy" - inverted.
     """
     a_list1 = singly_linked_list.SinglyLinkedList()
     a_list1.append('a')
     a_list1.append('b')
     a_list1.append('c')
     a_list2 = copy.copy(a_list1)
     a_list1[len(a_list1) - 1] = 'cc'
     self.assertNotEqual(a_list1, a_list2)
 def test_singly_linked_list_insert_at_middle(self):
     """
     Test method "insert_at".
     """
     a_list = singly_linked_list.SinglyLinkedList()
     a_list.append('a')
     a_list.append('b')
     a_list.append('c')
     a_list.append('d')
     a_list.append('e')
     a_list.insert_at(2, 'cc')
     self.assertEqual('cc', a_list[2].get_data())
 def test_singly_linked_list_insert_at_head(self):
     """
     Test method "insert_at".
     """
     a_list = singly_linked_list.SinglyLinkedList()
     a_list.append('a')
     a_list.append('b')
     a_list.append('c')
     a_list.insert_at(0, 'aa')
     t_1 = 'aa' == a_list.get_head().data
     t_2 = a_list[0] == a_list.get_head()
     t_3 = a_list[len(a_list) - 1] == a_list.get_tail()
     test = t_1 and t_2 and t_3
     self.assertTrue(test)
    def test_singly_linked_list_element_remove_end(self):
        """
        Testing removing a linked list element from a linked
        list. In this test the linked list contains five
        elements prior to removing. The element being removed
        is the last element.

        Before removing:
        list = [a] -> [b] -> [c] -> [d] -> [e]
        After removing:
        list = [a] -> [b] -> [c] -> [d]
        """
        a_list = singly_linked_list.SinglyLinkedList()
        elem4 = singly_linked_list.SinglyLinkedListElement(a_list, 'e', None)
        elem3 = singly_linked_list.SinglyLinkedListElement(a_list, 'd', elem4)
        elem2 = singly_linked_list.SinglyLinkedListElement(a_list, 'c', elem3)
        elem1 = singly_linked_list.SinglyLinkedListElement(a_list, 'b', elem2)
        elem0 = singly_linked_list.SinglyLinkedListElement(a_list, 'a', elem1)

        a_list.append(elem0.get_data())
        a_list.append(elem1.get_data())
        a_list.append(elem2.get_data())
        a_list.append(elem3.get_data())
        a_list.append(elem4.get_data())

        elem4.remove()

        res = []
        res.append(a_list[0])
        res.append(a_list[1])
        res.append(a_list[2])
        res.append(a_list[3])

        ref = []
        ref.append(elem0)
        ref.append(elem1)
        ref.append(elem2)
        ref.append(elem3)

        t_1 = a_list.get_head() == a_list[0]
        t_2 = a_list.get_tail() == a_list[3]
        t_3 = a_list[0].get_next() == a_list[1]
        t_4 = a_list[1].get_next() == a_list[2]
        t_5 = a_list[2].get_next() == a_list[3]
        t_6 = a_list[3].get_next() == None
        t_7 = len(a_list) == 4
        t_8 = ref == res
        test = t_1 and t_2 and t_3 and t_4 and t_5 and t_6 and t_7 and t_8
        self.assertTrue(test)
    def test_singly_linked_list_element_insert_empty(self):
        """
        Test method (list element) "insert".
        """
        a_list = singly_linked_list.SinglyLinkedList()
        elem1 = singly_linked_list.SinglyLinkedListElement(a_list, 'a', None)

        elem1.insert('b')

        test1 = a_list.get_head() == a_list[0]
        test2 = a_list.get_tail() == a_list[0]
        test3 = a_list[0].get_next() == None
        test4 = len(a_list) == 1
        test = test1 and test2 and test3 and test4
        self.assertTrue(test)
    def test_singly_linked_list_element_insert_before_middle(self):
        """
        Testing inserting a linked list element into a linked
        list. In this test the linked list contains three elements
        prior to the insertion of the fourh element and the new
        element is inserted before the third element.

        Before inserting:
        list = [a] -> [b] -> [d]
        After inserting:
        list = [a] -> [b] -> [c] -> [d]
        """
        a_list = singly_linked_list.SinglyLinkedList()
        elem2 = singly_linked_list.SinglyLinkedListElement(a_list, 'd', None)
        elemx = singly_linked_list.SinglyLinkedListElement(a_list, 'c', elem2)
        elem1 = singly_linked_list.SinglyLinkedListElement(a_list, 'b', elemx)
        elem0 = singly_linked_list.SinglyLinkedListElement(a_list, 'a', elem1)

        a_list.append(elem0.get_data())
        a_list.append(elem1.get_data())
        a_list.append(elem2.get_data())

        elem2.insert_before('c')

        res = []
        res.append(a_list[0])
        res.append(a_list[1])
        res.append(a_list[2])
        res.append(a_list[3])

        ref = []
        ref.append(elem0)
        ref.append(elem1)
        ref.append(elemx)
        ref.append(elem2)

        t_1 = a_list.get_head() == a_list[0]
        t_2 = a_list.get_tail() == a_list[3]
        t_3 = a_list[0].get_next() == a_list[1]
        t_4 = a_list[1].get_next() == a_list[2]
        t_5 = a_list[2].get_next() == a_list[3]
        t_6 = a_list[3].get_next() == None
        t_7 = len(a_list) == 4
        t_8 = ref == res
        test = t_1 and t_2 and t_3 and t_4 and t_5 and t_6 and t_7 and t_8
        self.assertTrue(test)
    def test_singly_linked_list_element_insert_middle(self):
        """
        Test method (list element) "insert".
        """
        a_list = singly_linked_list.SinglyLinkedList()
        elem5 = singly_linked_list.SinglyLinkedListElement(a_list, 'e', None)
        elem4 = singly_linked_list.SinglyLinkedListElement(a_list, 'd', elem5)
        elemx = singly_linked_list.SinglyLinkedListElement(a_list, 'cc', elem4)
        elem3 = singly_linked_list.SinglyLinkedListElement(a_list, 'c', elem4)
        elem2 = singly_linked_list.SinglyLinkedListElement(a_list, 'b', elem3)
        elem1 = singly_linked_list.SinglyLinkedListElement(a_list, 'a', elem2)

        a_list.append(elem1.get_data())
        a_list.append(elem2.get_data())
        a_list.append(elem3.get_data())
        a_list.append(elem4.get_data())
        a_list.append(elem5.get_data())

        elem3.insert('cc')

        res = []
        res.append(a_list[0])
        res.append(a_list[1])
        res.append(a_list[2])
        res.append(a_list[3])
        res.append(a_list[4])

        ref = []
        ref.append(elem1)
        ref.append(elem2)
        ref.append(elemx)
        ref.append(elem4)
        ref.append(elem5)

        t_1 = a_list.get_head() == a_list[0]
        t_2 = a_list.get_tail() == a_list[4]
        t_3 = a_list[0].get_next() == a_list[1]
        t_4 = a_list[1].get_next() == a_list[2]
        t_5 = a_list[2].get_next() == a_list[3]
        t_6 = a_list[3].get_next() == a_list[4]
        t_7 = a_list[4].get_next() == None
        t_8 = len(a_list) == 5
        t_9 = ref == res
        test = t_1 and t_2 and t_3 and t_4 and t_5 and t_6 and t_7 and t_8 and t_9
        self.assertTrue(test)
    def test_singly_linked_list_element_insert_head(self):
        """
        Test method (list element) "insert".
        """
        a_list = singly_linked_list.SinglyLinkedList()
        elem2 = singly_linked_list.SinglyLinkedListElement(a_list, 'c', None)
        elem1 = singly_linked_list.SinglyLinkedListElement(a_list, 'b', elem2)
        elem0 = singly_linked_list.SinglyLinkedListElement(a_list, 'a', elem1)

        a_list.append(elem0.get_data())
        a_list.append(elem1.get_data())
        a_list.append(elem2.get_data())
        elem0.insert('aa')

        test1 = a_list.get_head() == a_list[0]
        test2 = a_list.get_tail() == a_list[len(a_list) - 1]
        test3 = a_list[0].get_next() == elem1
        test4 = len(a_list) == 3
        test = test1 and test2 and test3 and test4
        self.assertTrue(test)
    def test_singly_linked_list_element_insert_after_first_two(self):
        """
        Testing inserting a linked list element into a linked
        list. In this test the linked list contains two elements
        prior to the insertion of the third element and the new
        element is inserted after the second element.

        Before inserting:
        list = [a] -> [b]
        After inserting:
        list = [a] -> [b] -> [c]
        """
        a_list = singly_linked_list.SinglyLinkedList()
        elemx = singly_linked_list.SinglyLinkedListElement(a_list, 'c', None)
        elem1 = singly_linked_list.SinglyLinkedListElement(a_list, 'b', elemx)
        elem0 = singly_linked_list.SinglyLinkedListElement(a_list, 'a', elem1)

        a_list.append(elem0.get_data())
        a_list.append(elem1.get_data())

        elem1.insert_after('c')

        res = []
        res.append(a_list[0])
        res.append(a_list[1])
        res.append(a_list[2])

        ref = []
        ref.append(elem0)
        ref.append(elem1)
        ref.append(elemx)

        t_1 = a_list.get_head() == a_list[0]
        t_2 = a_list.get_tail() == a_list[2]
        t_3 = a_list[0].get_next() == a_list[1]
        t_4 = a_list[1].get_next() == a_list[2]
        t_5 = a_list[2].get_next() == None
        t_6 = len(a_list) == 3
        t_7 = ref == res
        test = t_1 and t_2 and t_3 and t_4 and t_5 and t_6 and t_7
        self.assertTrue(test)
    def test_singly_linked_list_element_remove_not_present(self):
        """
        Testing removing a linked list element from a linked
        list. In this test the linked list contains two
        elements prior to removing. The element which should
        be removed is not in the list, so nothing should be
        removed and the pointers should be intact.

        Before removing:
        list = [a] -> [b]
        After removing:
        list = [a] -> [b]
        """

        a_list = singly_linked_list.SinglyLinkedList()
        elem2 = singly_linked_list.SinglyLinkedListElement(a_list, 'c', None)
        elem1 = singly_linked_list.SinglyLinkedListElement(a_list, 'b', elem2)
        elem0 = singly_linked_list.SinglyLinkedListElement(a_list, 'a', elem1)

        a_list.append(elem0.get_data())
        a_list.append(elem1.get_data())

        elem2.remove()

        res = []
        res.append(a_list[0])
        res.append(a_list[1])

        ref = []
        ref.append(elem0)
        ref.append(elem1)
        t_1 = a_list.get_head() == a_list[0]
        t_2 = a_list.get_tail() == a_list[1]
        t_3 = a_list[0].get_next() == a_list[1]
        t_4 = a_list[1].get_next() == None
        t_5 = len(a_list) == 2
        t_6 = ref == res
        test = t_1 and t_2 and t_3 and t_4 and t_5 and t_6
        self.assertTrue(test)
    def test_singly_linked_list_element_remove_first_one(self):
        """
        Testing removing a linked list element from a linked
        list. In this test the linked list contains a single
        element prior to removing this element.

        Before removing:
        list = [a]
        After removing:
        list = [None]
        """
        a_list = singly_linked_list.SinglyLinkedList()
        elem0 = singly_linked_list.SinglyLinkedListElement(a_list, 'a', None)

        a_list.append(elem0.get_data())

        elem0.remove()

        res = []
        ref = []
        t_1 = len(a_list) == 0
        t_2 = ref == res
        test = t_1 and t_2
        self.assertTrue(test)
    def test_array_list_remove_at_2(self):
        """
        Test of remove at methhod (association).
        """
        array = array_list.ArrayList(5)
        s_list1 = singly_linked_list.SinglyLinkedList()
        e11 = association.Association("e11", 11)
        e12 = association.Association("e12", 12)
        e13 = association.Association("e13", 13)
        s_list1.append(e11)
        s_list1.append(e12)
        s_list1.append(e13)

        s_list2 = singly_linked_list.SinglyLinkedList()
        e21 = association.Association("e21", 21)
        e22 = association.Association("e22", 22)
        e23 = association.Association("e23", 23)
        s_list2.append(e21)
        s_list2.append(e22)
        s_list2.append(e23)

        s_list3 = singly_linked_list.SinglyLinkedList()
        e31 = association.Association("e31", 31)
        e32 = association.Association("e32", 32)
        e33 = association.Association("e33", 33)
        s_list3.append(e31)
        s_list3.append(e32)
        s_list3.append(e33)

        s_list4 = singly_linked_list.SinglyLinkedList()
        e41 = association.Association("e41", 41)
        e42 = association.Association("e42", 42)
        e43 = association.Association("e43", 43)
        s_list4.append(e41)
        s_list4.append(e42)
        s_list4.append(e43)

        s_list5 = singly_linked_list.SinglyLinkedList()
        e51 = association.Association("e51", 51)
        e52 = association.Association("e52", 52)
        e53 = association.Association("e53", 53)
        s_list5.append(e51)
        s_list5.append(e52)
        s_list5.append(e53)

        array[0] = s_list1
        array[1] = s_list2
        array[2] = s_list3
        array[3] = s_list4
        array[4] = s_list5

        array[0].remove(e11)
        array[0].remove(e12)
        array[0].remove(e13)
        del array[0]

        ref = array_list.ArrayList(4)
        ref[0] = s_list2
        ref[1] = s_list3
        ref[2] = s_list4
        ref[3] = s_list5
        self.assertEqual(ref, array)
 def setUp(self):
     self.list1 = singly_linked_list.SinglyLinkedList()
     self.list1.append('b')
     self.list1.append('c')
     self.list1.append('d')
 def test_singly_linked_list_is_empty(self):
     """
     Test method "is_empty".
     """
     a_list = singly_linked_list.SinglyLinkedList()
     self.assertTrue(a_list.is_empty())