예제 #1
0
 def test_add_linked_list(self):
     ll1 = LinkedList()
     ll1.append(3)
     ll1.append(1)
     ll1.append(5)
     ll2 = LinkedList()
     ll2.append(5)
     ll2.append(9)
     ll2.append(2)
     self.assertEqual(LinkedList.add_linked_list(ll1, ll2).to_s(), '8 0 8')
     ll2.append(3)
     self.assertEqual(
         LinkedList.add_linked_list(ll1, ll2).to_s(), '8 0 8 3')
     ll1.append(1)
     ll1.append(1)
     ll1.append(1)
     ll1.append(1)
     self.assertEqual(
         LinkedList.add_linked_list(ll1, ll2).to_s(), '8 0 8 4 1 1 1')
예제 #2
0
class LinkedListTest(unittest.TestCase):
    def setUp(self):
        self.ll = LinkedList()

    def test_adding_element(self):
        self.ll.add_element(4)
        self.assertEqual(self.ll.size(), 1)

    def test_remove_element(self):
        self.ll.add_element(4)
        size = self.ll.size()
        self.ll.remove(0)
        size2 = self.ll.size()
        self.assertFalse(size == size2)

    def test_pprint(self):
        self.ll.add_element(4)
        self.ll.add_element(5)
        self.ll.add_element(6)
        self.ll.add_element(7)
        self.assertEqual(self.ll.pprint(), "4->5->6->7")

    def test_to_list(self):
        self.ll.add_element(4)
        self.ll.add_element(5)
        self.ll.add_element(6)
        self.ll.add_element(7)
        self.assertEqual(self.ll.to_list(), [4, 5, 6, 7])

    def test_add_at_index(self):
        self.ll.add_element(5)
        self.ll.add_element(6)
        self.ll.add_element(7)
        self.assertEqual(self.ll.add_at_index(2, 3), 3)

    def test_add_first(self):
        self.ll.add_element(5)
        self.ll.add_element(6)
        self.ll.add_element(7)
        self.assertEqual(self.ll.add_first(5), 5)

    def test_add_linked_list(self):
        ll_two = LinkedList()
        ll_two.add_element(6)
        ll_two.add_element(7)
        ll_two.add_element(8)
        self.ll.add_element(5)
        self.ll.add_element(6)
        self.ll.add_element(7)
        self.assertEqual(self.ll.add_linked_list(ll_two), 8)

    def test_add_list(self):
        self.ll.add_element(5)
        self.ll.add_element(6)
        self.ll.add_element(7)
        xs = [1, 2, 3]
        self.assertEqual(self.ll.add_list(xs), '5->6->7->1->2->3')

    def test_pop(self):
        self.ll.add_element(5)
        self.ll.add_element(6)
        self.ll.add_element(7)
        self.assertEqual(self.ll.pop(), 7)

    def test_reduce_to_unique(self):
        self.ll.add_element(5)
        self.ll.add_element(5)
        self.ll.add_element(5)
        self.ll.add_element(7)
        self.assertEqual(self.ll.reduce_to_unique(), '5->7')

    def test_ll_from_to(self):
        self.ll.add_element(5)
        self.ll.add_element(5)
        self.ll.add_element(7)
        self.assertEqual(self.ll.ll_from_to(1, 2), '5->7')
class LinkedListTest(unittest.TestCase):

    def setUp(self):
        self.ll = LinkedList()

    def test_adding_element(self):
        self.ll.add_element(4)
        self.assertEqual(self.ll.size(), 1)

    def test_remove_element(self):
        self.ll.add_element(4)
        size = self.ll.size()
        self.ll.remove(0)
        size2 = self.ll.size()
        self.assertFalse(size == size2)

    def test_len_dunder(self):
        self.assertEqual(0, len(self.ll))

    def test_size(self):
        self.ll = LinkedList(10)
        self.assertEqual(self.ll.size(), 10)

    def test_size_after_adding(self):
        self.ll.add_element(10)
        self.assertEqual(1,self.ll.size())

    def test_size_after_remove(self):
        self.ll.add_element(10)
        self.ll.remove(0)
        self.assertEqual(0, self.ll.size())

    def test_pprint(self):
        self.ll.add_element(10)
        self.ll.add_element(100)
        self.ll.add_element(1000)
        self.assertEqual('[10, 100, 1000]', self.ll.pprint())

    def test_to_list(self):
        self.ll.add_element(100)
        self.ll.add_element(1000)
        self.ll.add_element(100)
        self.ll.add_element(1000)
        self.assertEqual([100, 1000, 100, 1000], self.ll.to_list())

    def test_index(self):
        self.ll.add_element(100)
        self.ll.add_element(1000)
        self.assertEqual(1000, self.ll.index(1).value)

    def test_add_at_index(self):
        self.ll.add_element(100)
        self.ll.add_element(1000)
        self.ll.add_at_index(1, 69)
        self.assertEqual(69, self.ll.index(1).value)

    def test_add_first(self):
        self.ll.add_element(100)
        self.ll.add_first(69)
        self.assertEqual(69, self.ll.index(0).value)

    def test_add_list(self):
        self.ll.add_element(1)
        self.ll.add_list([10, 100, 1000])
        self.assertEqual([1, 10, 100, 1000], self.ll.to_list())

    def test_add_linked_list(self):
        self.ll.add_element(1)
        new_ll = LinkedList()
        new_ll.add_element(10)
        new_ll.add_element(100)
        self.ll.add_linked_list(new_ll)
        self.assertEqual([1, 10, 100], self.ll.to_list())

    def test_ll_from_to(self):
        self.ll.add_element(0)
        self.ll.add_list([1, 10, 100, 1000])
        self.assertEqual([10, 100], self.ll.ll_from_to(2, 3).to_list())

    def test_pop(self):
        self.ll.add_element(1)
        self.ll.add_element(10)
        self.ll.pop()
        self.assertEqual([1], self.ll.to_list())

    def reduce_to_unique(self):
        self.ll.add_element(1)
        self.ll.add_list([10, 100, 10])
        self.assertEqual([1, 10, 100], self.ll.reduce_to_unique())

    def test_set_element(self):
        self.ll.add_element(1)
        self.ll.add_list([10, 100, 1000])
        self.ll.set_element(2, 69)
        self.assertEqual(69, self.ll.index(2).value)
class LinkedListTest(unittest.TestCase):
    def setUp(self):
        self.ll = LinkedList()

    def test_eq(self):
        ll_2 = LinkedList()
        self.ll.add_element(5)
        self.ll.add_element(6)
        ll_2.add_element(5)
        ll_2.add_element(6)
        self.assertTrue(self.ll == ll_2)

    def test_adding_element(self):
        self.ll.add_element(4)
        self.assertEqual(self.ll.size(), 1)

    def test_remove_element(self):
        self.ll.add_element(4)
        size = self.ll.size()
        self.ll.remove(0)
        size2 = self.ll.size()
        self.assertFalse(size == size2)

    def test_remove_element_2(self):
        self.ll.add_element(5)
        self.ll.add_element(6)
        self.ll.add_element(7)
        self.ll.remove(1)
        self.assertEqual(self.ll.index(1), 7)

    def test_size_1(self):
        self.ll.add_element(5)
        self.ll.add_element(5)
        self.ll.add_element(5)
        self.assertEqual(self.ll.size(), 3)

    def test_size_2(self):
        self.ll.add_element(5)
        self.ll.add_element(5)
        self.ll.add_element(5)
        self.ll.pop()
        self.ll.pop()
        self.assertEqual(self.ll.size(), 1)

    def test_index(self):
        self.ll.add_element(5)
        self.ll.add_element(2)
        self.assertEqual(self.ll.index(0), 5)
        self.assertNotEqual(self.ll.index(1), 5)

    def test_remove_element_2(self):
        self.ll.add_element(5)
        self.ll.add_element(6)
        self.ll.add_element(7)
        self.ll.remove(1)
        self.assertEqual(self.ll.index(1), 7)

    def test_pprint(self):
        self.ll.add_element(5)
        self.ll.add_element(6)
        self.ll.add_element(7)
        self.assertEqual(self.ll.pprint(), "5 -> 6 -> 7")

    def test_to_list(self):
        self.ll.add_element(5)
        self.ll.add_element(6)
        self.ll.add_element(7)
        self.assertEqual(self.ll.to_list(), [5, 6, 7])

    def test_add_at_index(self):
        self.ll.add_element(5)
        self.ll.add_element(6)
        self.ll.add_at_index(1, 7)
        self.assertEqual(self.ll.index(1), 7)
        self.assertEqual(self.ll.index(2), 6)

    def test_add_first(self):
        self.ll.add_element(5)
        self.ll.add_element(6)
        self.ll.add_first(7)
        self.assertEqual(self.ll.index(0), 7)
        self.assertEqual(self.ll.index(1), 5)

    def test_add_linked_list(self):
        self.ll.add_element(5)
        self.ll.add_element(6)
        ll_2 = LinkedList()
        ll_2.add_element(7)
        ll_2.add_element(8)
        self.ll.add_linked_list(ll_2)
        self.assertEqual(self.ll.to_list(), [5, 6, 7, 8])

    def test_ll_from_to(self):
        self.ll.add_element(5)
        self.ll.add_element(6)
        self.ll.add_element(7)
        self.ll.add_element(8)
        from_to = self.ll.ll_from_to(1, 3)
        self.assertEqual(from_to.to_list(), [6, 7, 8])

    def test_pop(self):
        self.ll.add_element(5)
        self.ll.add_element(6)
        self.ll.add_element(7)
        self.ll.pop()
        size = self.ll.size()
        self.assertEqual(self.ll.index(size - 1), 6)

    def test_reduce_to_unique(self):
        self.ll.add_element(5)
        self.ll.add_element(6)
        self.ll.add_element(7)
        self.ll.add_element(5)
        self.ll.add_element(6)
        self.ll.add_element(7)
        self.ll.reduce_to_unique()
        self.assertEqual(self.ll.to_list(), [5, 6, 7])
class LinkedListTest(unittest.TestCase):
    def setUp(self):
        self.ll = LinkedList()

    def test_adding_element(self):
        self.ll.add_element(4)
        self.assertEqual(self.ll.size(), 1)

    def test_remove_element(self):
        self.ll.add_element(4)
        size = self.ll.size()
        self.ll.remove(0)
        size2 = self.ll.size()
        self.assertFalse(size == size2)

    def test_add_first_element(self):
        self.ll.add_first(30)  #check first el
        self.assertEqual(self.ll.head.value, 30)
        self.ll.add_first(12)  #check tail el after add second el
        self.assertEqual(self.ll.tail.value, 30)

    def test_get_index_of_element(self):
        node = self.ll.get_index(0)  #test empty list
        self.assertEqual(node, None)

        self.ll.add_element(1)  #test index with elements
        self.ll.add_element(2)
        self.ll.add_element(3)
        self.assertEqual(self.ll.get_index(1).value, 2)

    def test_to_list_func(self):
        self.ll.add_element(1)
        self.ll.add_element(4)
        self.ll.add_element(3)
        self.assertEqual(self.ll.to_list(), [1, 4, 3])

    def test_add_at_index(self):
        #invalid indexes
        self.assertFalse(self.ll.add_at_index(1, 3), False)
        self.assertEqual(self.ll.add_at_index(0, 5), None)

    def test_ll_from_to(self):
        self.ll.add_list([1, 2, 3, 4, 5, 6, 7])
        new_ll = self.ll.ll_from_to(3, 6)
        self.assertEqual(new_ll.head.value, 4)
        self.assertEqual(new_ll.tail.value, 7)
        self.assertEqual(new_ll.to_list(), [4, 5, 6, 7])

    def test_pop_func(self):
        # test tail of the list is it pop one el
        self.ll.add_list([1, 2, 3])
        self.ll.pop()
        self.assertEqual(self.ll.tail.value, 2)
        self.ll.pop()
        self.assertEqual(self.ll.tail.value, 1)

    def test_reduce_to_unique(self):
        orig_list = [0, 0, 1, 0, 0, 1, 2, 3, 2]
        expected_list = [0, 1, 2, 3]
        self.ll.add_list(orig_list)
        self.assertEqual(self.ll.to_list(), orig_list)
        unique_ll = self.ll.reduce_to_unique()
        self.assertNotEqual(unique_ll.to_list(), orig_list)
        self.assertEqual(unique_ll.to_list(), expected_list)

    def test_add_to_linked_list(self):
        new_ll = LinkedList()
        new_ll.add_element(1)
        new_ll.add_element(2)
        new_ll.add_element(3)
        self.ll.add_element(0)
        self.ll.add_linked_list(new_ll)
        self.assertEqual(self.ll.head.value, 0)
        self.assertEqual(self.ll.tail.value, 3)
        self.assertEqual(self.ll.to_list(), [0, 1, 2, 3])