class DeleteFromMiddleDescListWithMultipleValuesTestCase(unittest.TestCase):
    def setUp(self) -> None:
        self.ol = OrderedList(False)
        for i in range(0, 6):
            self.ol.add(i)

    def test(self):
        self.assertEqual(6, self.ol.len())
        self.assertEqual(6, self.ol.len_reverse())

        nodes = []
        for i in self.ol.get_all():
            nodes.append(i.value)

        self.assertListEqual(nodes, [5, 4, 3, 2, 1, 0])

        self.ol.delete(3)

        self.assertEqual(5, self.ol.len())
        self.assertEqual(5, self.ol.len_reverse())

        nodes = []
        for i in self.ol.get_all():
            nodes.append(i.value)

        self.assertListEqual(nodes, [5, 4, 2, 1, 0])

        node_4 = self.ol.find(4)
        node_2 = self.ol.find(2)

        self.assertEqual(node_2, node_4.next)
        self.assertEqual(node_4, node_2.prev)
class AddToEmptyListTestCase(unittest.TestCase):
    def test_asc(self):
        self.ol = OrderedList(True)

        self.assertEqual(0, self.ol.len())
        self.assertEqual(0, self.ol.len_reverse())
        self.assertIsNone(self.ol.head)
        self.assertIsNone(self.ol.tail)

        self.ol.add(1)

        self.assertEqual(1, self.ol.len())
        self.assertEqual(1, self.ol.len_reverse())
        self.assertEqual(1, self.ol.head.value)
        self.assertEqual(1, self.ol.tail.value)
        self.assertEqual(1, self.ol.get_all()[0].value)

    def test_desc(self):
        self.ol = OrderedList(False)

        self.assertEqual(0, self.ol.len())
        self.assertEqual(0, self.ol.len_reverse())
        self.assertIsNone(self.ol.head)
        self.assertIsNone(self.ol.tail)

        self.ol.add(1)

        self.assertEqual(1, self.ol.len())
        self.assertEqual(1, self.ol.len_reverse())
        self.assertEqual(1, self.ol.head.value)
        self.assertEqual(1, self.ol.tail.value)
        self.assertEqual(1, self.ol.get_all()[0].value)
class AddDifferentValuesToDescListTestCase(unittest.TestCase):
    def setUp(self) -> None:
        self.ol = OrderedList(False)

    def test(self):
        self.assertEqual(0, self.ol.len())
        self.assertEqual(0, self.ol.len_reverse())

        self.assertIsNone(self.ol.head)
        self.assertIsNone(self.ol.tail)

        self.ol.add(100)
        self.ol.add(5)
        self.ol.add(34)
        self.ol.add(210)
        self.ol.add(34)
        self.ol.add(20)
        self.ol.add(0)

        self.assertEqual(7, self.ol.len())
        self.assertEqual(7, self.ol.len_reverse())
        self.assertEqual(210, self.ol.head.value)
        self.assertEqual(100, self.ol.head.next.value)
        self.assertEqual(self.ol.find(210), self.ol.head)
        self.assertEqual(self.ol.find(0), self.ol.tail)

        nodes = []
        for i in self.ol.get_all():
            nodes.append(i.value)

        self.assertListEqual(nodes, [210, 100, 34, 34, 20, 5, 0])
class AddToMiddleAscListTestCase(unittest.TestCase):
    def setUp(self) -> None:
        self.ol = OrderedList(True)

        for i in range(0, 6):
            self.ol.add(i)

    def test(self):
        self.assertEqual(6, self.ol.len())
        self.assertEqual(6, self.ol.len_reverse())
        self.assertEqual(0, self.ol.head.value)
        self.assertEqual(5, self.ol.tail.value)
        self.assertIsNone(self.ol.head.prev)
        self.assertIsNone(self.ol.tail.next)
        self.assertEqual(0, self.ol.head.next.prev.value)

        self.ol.add(4)

        nodes = []
        for i in self.ol.get_all():
            nodes.append(i.value)

        self.assertListEqual(nodes, [0, 1, 2, 3, 4, 4, 5])

        self.assertEqual(7, self.ol.len())
        self.assertEqual(7, self.ol.len_reverse())
        self.assertEqual(0, self.ol.head.value)
        self.assertEqual(5, self.ol.tail.value)
        self.assertIsNone(self.ol.head.prev)
        self.assertIsNone(self.ol.tail.next)
class AddToHeadDescListWithMultipleValuesTestCase(unittest.TestCase):
    def setUp(self) -> None:
        self.ol = OrderedList(False)
        for i in range(0, 6):
            self.ol.add(i)

    def test(self):
        self.assertEqual(6, self.ol.len())
        self.assertEqual(6, self.ol.len_reverse())
        self.assertEqual(5, self.ol.head.value)
        self.assertEqual(4, self.ol.head.next.value)
        self.assertEqual(5, self.ol.head.next.prev.value)
        self.assertEqual(0, self.ol.tail.value)
        self.assertEqual(1, self.ol.tail.prev.value)
        self.assertEqual(0, self.ol.tail.prev.next.value)

        self.assertIsNone(self.ol.head.prev)
        self.assertIsNone(self.ol.tail.next)

        self.ol.add(100)

        self.assertEqual(7, self.ol.len())
        self.assertEqual(7, self.ol.len_reverse())
        self.assertEqual(100, self.ol.head.value)
        self.assertEqual(5, self.ol.head.next.value)
        self.assertEqual(100, self.ol.head.next.prev.value)
        self.assertEqual(self.ol.find(100), self.ol.head)

        nodes = []
        for i in self.ol.get_all():
            nodes.append(i.value)

        self.assertListEqual(nodes, [100, 5, 4, 3, 2, 1, 0])
Esempio n. 6
0
    def test_add_ascending(self):
        ol = OrderedList(asc=True)

        items = [4, 6, 2, 8, 5]

        for item in items:
            ol.add(item)
        items.sort()
        self.assertEqual([node.value for node in ol.get_all()], items)
Esempio n. 7
0
    def test_delete_descending_begin(self):
        ol = OrderedList(asc=False)

        items = [4, 6, 2, 8, 5]

        for item in items:
            ol.add(item)

        items.sort(reverse=True)
        items.remove(2)

        ol.delete(2)

        self.assertEqual([node.value for node in ol.get_all()], items)
Esempio n. 8
0
    def test_delete_ascending_end(self):
        ol = OrderedList(asc=True)

        items = [4, 6, 2, 8, 5]

        for item in items:
            ol.add(item)

        items.sort()
        items.remove(8)

        ol.delete(8)

        self.assertEqual([node.value for node in ol.get_all()], items)