def test_equality_repeat():
"""DoublyLinkedList with different number of occurences should NOT be equal"""
a_list = DoublyLinkedList()
a_list.push(0).push(1).push(2)
another_list = DoublyLinkedList()
another_list.push(0).push(0).push(1).push(2)
assert id(another_list) != id(a_list)
assert another_list != a_list
def test_equality():
"""DoublyLinkedList with same elements in order should be equal"""
a_list = DoublyLinkedList()
a_list.push(0).push(1).push(2)
another_list = DoublyLinkedList()
another_list.push(0).push(1).push(2)
assert id(another_list) != id(a_list)
assert another_list == a_list
def test_equality_unorder():
"""DoublyLinkedList with same elements in different order should NOT be equal"""
a_list = DoublyLinkedList()
a_list.push(0).push(1).push(2)
another_list = DoublyLinkedList()
another_list.push(1).push(2).push(0)
assert id(another_list) != id(a_list)
assert another_list != a_list
def test_insert_get(self):
l = DoublyLinkedList()
l.insert("two")
l.insert(1.0)
l.insert(0)
self.assertEqual(len(l), 3)
self.assertEqual(l._head.data, 0)
self.assertEqual(l._head._next.data, 1.0)
self.assertEqual(l._head._next._next.data, "two")
self.assertEqual(l._head._next._next, l._tail)
self.assertEqual(l._head._next, l._tail._prev)
self.assertIsNone(l._head._prev)
self.assertIsNone(l._tail._next)
self.assertEqual(l.get(0), 0)
self.assertEqual(l.get(1), 1.0)
self.assertEqual(l.get(2), "two")
self.assertEqual(l.get(-1), "two")
self.assertEqual(l.get(-3), 0)
bad = False
try:
l.get(4)
except ValueError:
bad = True
self.assertTrue(bad)
bad = False
try:
l.get(-4)
except ValueError:
bad = True
self.assertTrue(bad)
def test_iterable():
"""DoublyLinkedList should be Iterable"""
a_list = DoublyLinkedList()
assert isinstance(a_list, Iterable)
an_iter = iter(a_list)
assert isinstance(an_iter, Iterable)
assert isinstance(an_iter, Iterator)
def test_get(self):
l = DoublyLinkedList()
self.assertIsNone(l.get(1))
l.append(1)
self.assertEqual(1, l.get(0))
l.append(2)
self.assertEqual(2, l.get(1))
def test_pop_one_from_one():
"""One element should be removed from a list of size one after pop"""
a_list = DoublyLinkedList()
a_list.push(0)
value = a_list.pop()
assert value == 0
assert not a_list
def test_contains():
"""__contains__ method should be used by 'in' statements"""
a_list = DoublyLinkedList([0, 1, 2])
assert 0 in a_list
assert 1 in a_list
assert 2 in a_list
assert 42 not in a_list
def test_creation_empty():
"""An empty list should have its attributes set"""
a_list = DoublyLinkedList()
assert not a_list
assert hasattr(a_list, "start")
assert hasattr(a_list, "end")
assert hasattr(a_list, "length")
def test_push_two():
"""Two elements should be added to an empty list"""
a_list = DoublyLinkedList()
a_list.push(0)
a_list.push(1)
assert len(a_list) == 2
assert a_list.start.next == a_list.end
assert a_list.end.prev == a_list.start
def test_equality_other_class():
"""DoublyLinkedList equality with another class should return NotImplemented"""
a_list = DoublyLinkedList()
assert a_list.__eq__(0) == NotImplemented
assert a_list.__eq__(True) == NotImplemented
assert a_list.__eq__(()) == NotImplemented
assert a_list.__eq__("test") == NotImplemented
assert a_list.__eq__([]) == NotImplemented
def __init__(self, head=None):
self._linked_list = DoublyLinkedList(head)
self._front = self._linked_list.head()
self._rear = self._linked_list.get_end()
if not head:
self._size = 0
else:
self._size = self.get_linked_list().get_length()
def test_index(self):
l = DoublyLinkedList()
self.assertIsNone(l.index(1))
l.append(1)
l.append(1)
self.assertEqual(0, l.index(1))
l.append(2)
self.assertEqual(2, l.index(2))
def test_delete(self):
l = DoublyLinkedList(1, 2, 3)
self.assertEqual(1, l.head.data)
l.delete(1)
self.assertEqual(2, l.head.data)
l.delete(3)
self.assertEqual(2, l.head.data)
self.assertEqual(2, l.tail.data)
def test_pop_one_from_three():
"""One element should be removed from a list of size three after pop"""
a_list = DoublyLinkedList()
a_list.push(0).push(1).push(2)
a_value = a_list.pop()
assert a_value == 2
assert a_list.end.value == 1
assert a_list.start.value == 0
assert len(a_list) == 2
def test_pop(self):
l = DoublyLinkedList(0, 1, 2, 3, 4)
self.assertEqual(l.pop(), 0)
self.assertEqual(l.pop(1), 2)
self.assertEqual(len(l), 3)
self.assertEqual(l.pop(-1), 4)
for i in range(len(l)):
l.pop()
self.assertEqual(len(l), 0)
def test_pop_two_from_two():
"""Two elements should be removed from a list of size one after two pops"""
a_list = DoublyLinkedList()
a_list.push(0).push(1)
a_value = a_list.pop()
assert a_value == 1
another_value = a_list.pop()
assert another_value == 0
assert not a_list
def setUp(self):
self.n1 = Node(1)
self.n2 = Node(2)
self.n3 = Node(3)
self.n4 = Node(4)
self.n5 = Node(5)
self.empty_list = DoublyLinkedList()
self.empty_head = self.empty_list.head()
self.empty_tail = self.empty_list.get_end()
self.single_list = DoublyLinkedList(self.n4)
self.single_head = self.single_list.head()
self.single_tail = self.single_list.get_end()
self.linked_list = DoublyLinkedList(self.n1)
self.linked_list.append(self.n2)
self.head = self.linked_list.head()
self.tail = self.linked_list.get_end()
def test_append_get(self):
l = DoublyLinkedList(0, -1.0)
self.assertEqual(len(l), 2)
self.assertEqual(l.get(0), 0)
self.assertEqual(l.get(1), -1.0)
self.assertEqual(l._head.data, 0)
self.assertEqual(l._tail.data, -1.0)
self.assertEqual(l._head._next, l._tail)
self.assertEqual(l._tail._prev, l._head)
self.assertIsNone(l._head._prev)
self.assertIsNone(l._tail._next)
def __init__(self):
self.list = DoublyLinkedList()
self.iterList = iter(self.list)
def setUp(self):
self.linked_list = DoublyLinkedList()
self.helper = SharedListTestHelpers()
def test_insert(self):
l = DoublyLinkedList()
l.insert(1, 0)
self.assertEqual(1, l.head.data)
self.assertEqual(1, l.tail.data)
def test_empty_init(self):
l = DoublyLinkedList()
self.assertEqual(len(l), 0)
def test_insert_out_of_list(self):
l = DoublyLinkedList()
self.assertRaises(ValueError, lambda: l.insert(1, 1))
def test_append(self):
l = DoublyLinkedList()
l.append(1)
self.assertEqual(1, l.head.data)
self.assertEqual(1, l.tail.data)
def test_empty_list(self):
l = DoublyLinkedList()
self.assertIsNone(l.head)
self.assertIsNone(l.tail)
def test_linked_list(self):
data = [1, 2, 3, 4, 5]
l = DoublyLinkedList(*data)
self.assertEqual(1, l.head.data)
self.assertEqual(5, l.tail.data)
def test_get_with_negative_inx(self):
l = DoublyLinkedList()
self.assertRaises(ValueError, lambda: l.get(-1))
def test_iter(self):
to_iterate = list(range(10))
l = DoublyLinkedList(*to_iterate)
for i, j in zip(to_iterate, l):
self.assertTrue(i == j)
def __init__(self, top=None):
self._linked_list = DoublyLinkedList(top)