class Queue(object):
"""Create a queue data structure"""
def __init__(self):
self.container = DoubleLinkedList()
def enqueue(self, val):
"""Inserts value to queue"""
self.container.insert(val)
def dequeue(self):
"""Removes next item and returns it"""
return self.container.shift()
def peek(self):
"""Return next value in queue without dequeuing it"""
if self.container.tail_node is None:
return None
return self.container.tail_node.value
def size(self):
"""Return size of queue, 0 if empty"""
if self.container.head_node is None:
return 0
cursor = self.container.head_node
if self.container.head_node.next == self.container.tail_sentinal:
return 1
size = 1
while cursor.next != self.container.tail_sentinal:
size += 1
cursor = cursor.next
return size
def test_delete(self):
dll = DoubleLinkedList(array)
item1 = 1
item2 = 4
item3 = 6
current = dll.head
#delete first item
if dll.head.data == item1:
dll.head = dll.head.next
dll.head.prev = None
#delete last item
if dll.tail.data == item3:
dll.tail = dll.tail.prev
dll.tail.next = None
#delete item in the middle of dll
while current is not None:
if current.data == item2:
current.prev.next = current.next
current.next.prev = current.prev
current = current.next
assert dll.head.data == 2
assert dll.tail.data == 5
assert dll.head.next.next.data == 5
assert dll.tail.prev.data == 3
def test_eq(self):
dll_2 = DoubleLinkedList()
self.dll.add_element(5)
self.dll.add_element(6)
dll_2.add_element(5)
dll_2.add_element(6)
self.assertEqual(self.dll, dll_2)
def test_add_linked_list(self):
self.dll.add_element(5)
self.dll.add_element(6)
dll_2 = DoubleLinkedList()
dll_2.add_element(7)
dll_2.add_element(8)
self.dll.add_linked_list(dll_2)
self.assertEqual(self.dll.to_list(), [5, 6, 7, 8])
def test_contains(self):
"""Test method which check if element contains in list"""
l_list = DoubleLinkedList()
l_list.push(1234)
l_list.push(12)
l_list.push(1)
self.assertTrue(l_list.contains(12))
self.assertFalse(l_list.contains(2345))
def test_pop_singleton():
from double_linked_list import DoubleLinkedList
dll = DoubleLinkedList()
dll.append(5)
return_value = dll.pop()
assert return_value == 5
assert dll.head_node is None
assert dll.tail_node is None
def setUp(self):
my_list = [1, 2, 3]
self.dll = DoubleLinkedList()
# self.dll_2 = DoubleLinkedList()
# self.dll_3 = DoubleLinkedList()
self.dll.add_list(my_list)
def test_replace(self):
dll = DoubleLinkedList(array)
item1 = 5
item2 = 10
item3 = 45
assert dll.replace(item1, 1) == item1
assert dll.replace(item2, 4) == item2
assert dll.replace(item3, 6) == item3
assert dll.replace(34, 90) is None
def test_delete_when_no_this_element(self):
"""Test method which delete element from list, when no this element in the list"""
l_list = DoubleLinkedList()
l_list.push(1234)
l_list.push(12)
l_list.push(1)
with self.assertRaises(Exception) as context:
l_list.delete(123)
self.assertTrue('No this Element' in str(context.exception))
def test_unshift(self):
doubleLinkedList = DoubleLinkedList()
doubleLinkedList.push("sdfsf")
doubleLinkedList.push(1)
doubleLinkedList.unshift(3)
assert (list([
doubleLinkedList.pop(),
doubleLinkedList.pop(),
doubleLinkedList.pop()
]) == [1, "sdfsf", 3])
def test_delete_implementation(self):
dll = DoubleLinkedList(array)
assert dll.delete(1) == 1
assert dll.delete(4) == 4
assert dll.delete(6) == 6
assert dll.size == 3
assert dll.head.data == 2
assert dll.tail.data == 5
assert dll.tail.prev.data == 3
assert dll.head.next.data == 3
def test_pop():
from double_linked_list import DoubleLinkedList
dll = DoubleLinkedList()
dll.append(5)
dll.insert(10)
dll.append(15)
dll.insert(20)
return_value_1 = dll.pop()
assert return_value_1 == 20
assert dll.head_node.value == 10
def test_last(self):
doubleLinkedList = DoubleLinkedList()
doubleLinkedList.push("test1")
doubleLinkedList.push(1)
doubleLinkedList.push(2)
doubleLinkedList.delete("test1")
assert (doubleLinkedList.last().elem == 2)
def test_remove__first_value():
from double_linked_list import DoubleLinkedList
dll = DoubleLinkedList()
dll.insert(4)
dll.insert(2)
dll.insert(3)
dll.insert(2)
dll.insert(1)
dll.remove(2)
assert dll.head_node.next.value != 2
assert dll.tail_node.previous.value == 2
def test_shift():
from double_linked_list import DoubleLinkedList
dll = DoubleLinkedList()
dll.append(5)
dll.insert(10)
dll.append(15)
dll.insert(20)
# [20, 10, 5, 15]
return_value_1 = dll.shift()
assert return_value_1 == 15
assert dll.tail_node.value == 5
class DoubleLinkedListTests_add_list(unittest.TestCase):
def setUp(self):
self.dll = DoubleLinkedList()
def test_add_list(self):
# test_list
list_vals = [1, 2, 3]
self.dll.add_list(list_vals)
self.assertEqual(self.dll.head.value, 1)
self.assertEqual(self.dll.head.next.value, 2)
self.assertEqual(self.dll.head.next.next.value, 3)
def test_prepend_implementation(self):
dll = DoubleLinkedList()
assert dll.prepend(1) == 1
assert dll.prepend(2) == 2
assert dll.prepend(3) == 3
assert dll.head.data == 3
assert dll.tail.data == 1
assert dll.head.next.prev == dll.head
assert dll.tail.prev.next == dll.tail
assert dll.tail.next is None
assert dll.head.prev is None
assert dll.size == 3
def test_append():
# test multiple append calls
from double_linked_list import DoubleLinkedList
dll = DoubleLinkedList()
dll.append(4)
dll.append(8)
assert dll.head_node.value == 4
assert dll.head_node.next.value == 8
assert dll.head_node.previous == dll.head_sentinal
assert dll.tail_node.value == 8
assert dll.tail_node.next == dll.tail_sentinal
assert dll.tail_node.previous == dll.head_node
def test_insert_on_empty_list():
# test insert single element to empty list
from double_linked_list import DoubleLinkedList
dll = DoubleLinkedList()
dll.insert(5)
assert dll.head_node.value == 5
assert dll.head_node.next == dll.tail_sentinal
assert dll.head_node.previous == dll.head_sentinal
# list is 1 element long, so head and tail are that element
assert dll.tail_node.value == 5
assert dll.tail_node.next == dll.tail_sentinal
assert dll.tail_node.previous == dll.head_sentinal
def test_append_on_empty_list():
# test append single element on empty list
from double_linked_list import DoubleLinkedList
dll = DoubleLinkedList()
dll.append(4)
assert dll.tail_node.value == 4
assert dll.tail_node.next == dll.tail_sentinal
assert dll.tail_node.previous == dll.head_sentinal
# list is 1 element long, so head and tail are that element
assert dll.head_node.value == 4
assert dll.head_node.next == dll.tail_sentinal
assert dll.head_node.previous == dll.head_sentinal
def test_push_pop(self):
doubleLinkedList = DoubleLinkedList()
doubleLinkedList.push("sdfsf")
doubleLinkedList.push(1)
assert (list([
doubleLinkedList.pop(),
doubleLinkedList.pop(),
doubleLinkedList.pop()
]) == [1, "sdfsf", None])
def test_append_implementation(self):
dll = DoubleLinkedList(array)
assert dll.head.data == 1
assert dll.tail.data == 6
assert dll.head.prev is None
assert dll.tail.next is None
assert dll.head == dll.head.next.prev
assert dll.tail == dll.tail.prev.next
def test_remove_tail():
from double_linked_list import DoubleLinkedList
dll = DoubleLinkedList()
dll.insert(3)
dll.insert(2)
dll.insert(1)
assert dll.tail_node.value == 3
dll.remove(3)
assert dll.tail_node.value == 2
assert dll.tail_node.next == dll.tail_sentinal
def __init__(self):
number_of_bucket = 5
self.bucket = DoubleLinkedList()
self.hash_table = []
index = 0
while index < number_of_bucket:
self.hash_table.append(self.bucket)
index += 1
class Stack:
def __init__(self):
self.__list = DoubleLinkedList()
def push(self, value):
self.__list.add(value)
def pop(self):
val = self.__list.pop_back()
return val
def is_empty(self):
return self.__list.size == 0
def peek(self):
return self.__list.back()
def size(self):
return self.__list.size
def __len__(self):
return self.__list.size
class Queue:
def __init__(self):
self.__list = DoubleLinkedList()
def enque(self, value):
self.__list.add(value)
def deque(self):
val = self.__list.pop_front()
return val
def front(self):
return self.__list.front()
def __len__(self):
return self.__list.size
def size(self):
return self.__list.size
def is_empty(self):
return self.__list.size == 0
def test_init_hash_table(self):
size = 5
bucket = DoubleLinkedList()
ash_table = []
x = 0
while x<size:
ash_table.append(bucket)
x += 1
assert ash_table != None
assert ash_table[0] != None
assert ash_table[1] != None
assert ash_table[2] != None
assert ash_table[3] != None
assert ash_table[4] != None
def setUp(self):
self.dll = DoubleLinkedList()
self.all = DoubleLinkedList()
self.repeat = DoubleLinkedList()
all_val = [1, 1, 1, 1]
self.all.add_list(all_val)
repeat_val = [1, 1, 2, 5, 6, 1, 1, 1, 3, 1, 4, 9, 1, 1, 1]
self.repeat.add_list(repeat_val)
class DoubleLinkedListTest_reverse_list(unittest.TestCase):
def setUp(self):
my_list = [1, 2, 3]
self.dll = DoubleLinkedList()
self.dll.add_list(my_list)
def test_reverse_list(self):
self.dll.reverse_list()
self.assertEqual(self.dll.print(), 'HEAD >> 3 -> 2 -> 1 -> TAIL')
self.assertEqual(self.dll.print_reverse(), 'TAIL >> 1 -> 2 -> 3 -> HEAD')
def setUp(self):
not_found = [2, 3, 4]
self.dll_1 = DoubleLinkedList()
self.dll_1.add_list(not_found)
repeat_list = [1, 1, 1, 1, 2, 1, 1, 3, 1, 1, 1, 4, 1, 1, 1]
self.dll_2 = DoubleLinkedList()
self.dll_2.add_list(repeat_list)
all_removed = [1, 1, 1, 1]
self.dll_3 = DoubleLinkedList()
self.dll_3.add_list(all_removed)
def test_insert():
# test multiple insert calls
from double_linked_list import DoubleLinkedList
dll = DoubleLinkedList()
dll.insert(5)
dll.insert(10)
assert dll.head_node.value == 10
assert dll.head_node.next.value == 5
assert dll.head_node.previous == dll.head_sentinal
assert dll.tail_node.value == 5
assert dll.tail_node.next == dll.tail_sentinal
assert dll.tail_node.previous == dll.head_node
def __init__(self):
self.pellets = DoubleLinkedList()
self.blobs = DoubleLinkedList()
self.bullet_blobs = DoubleLinkedList()
self.blob_families = []
self.controllers = []
self.lastime = time.time()
for _ in range(SMALL_PELLET_NUM):
self.__generate_pellet()
for _ in range(LARGE_PELLET_NUM):
self.__generate_large_pellet()
def test_remove_value_not_in_list():
from double_linked_list import DoubleLinkedList
dll = DoubleLinkedList()
dll.append(5)
dll.insert(10)
dll.append(15)
dll.insert(20)
with pytest.raises(ValueError):
dll.remove('bananas')
def __init__(self):
self.container = DoubleLinkedList()
def test_pop_empty_list():
from double_linked_list import DoubleLinkedList
dll = DoubleLinkedList()
with pytest.raises(ValueError):
dll.pop()
