def test_dequeue_one():
food = Queue()
food.enqueue('bacon')
food.enqueue('cheese')
food.dequeue()
assert 'cheese' == food.peek_queue()
def test_error_deque():
q = Queue()
q.enqueue("apple")
q.dequeue()
q.dequeue()
actual = q.peek()
expected = "empty queue"
assert actual == expected
def test_queue_exception():
queue = Queue()
exc = "Method not allowed on empty collection."
with pytest.raises(InvalidOperationError) as error1:
queue.peek()
with pytest.raises(InvalidOperationError) as error2:
queue.dequeue()
assert str(error1.value) == exc and str(error2.value) == exc
def test_peek_post_dequeue():
q = Queue()
q.enqueue("apples")
q.enqueue("bananas")
q.dequeue()
actual = q.peek()
expected = "bananas"
assert actual == expected
def test_queue_dequeue():
testing_queue = Queue()
testing_queue.enqueue(1)
testing_queue.enqueue(2)
testing_queue.dequeue()
expected = 2
actual = testing_queue.peek()
assert actual == expected
def test_dequeue():
q = Queue()
q.enqueue(1)
q.enqueue(2)
q.enqueue(3)
q.dequeue()
assert q.length == 2
assert q.front.value == 2
def test_queue_dequeue_new_front():
line = Queue()
line.enqueue('Steve')
line.enqueue('Ted')
line.enqueue('Mary')
line.enqueue('Pam')
line.dequeue()
assert line.front.data == 'Ted'
def test_dequeue_one():
q = Queue()
q.enqueue('A')
q.enqueue('B')
q.enqueue('C')
q.dequeue()
expected = 'B'
actual = q.peek()
assert expected == actual
def test_dequeue():
q = Queue()
q.enqueue('1')
q.enqueue('2')
q.enqueue('3')
assert q.dequeue() == '1'
assert q.dequeue() == '2'
assert q.dequeue() == '3'
assert q.peek() == None
def test_enqueue_empty_queue():
q = Queue()
q.enqueue(1)
q.enqueue(2)
q.enqueue(3)
q.dequeue()
q.dequeue()
q.dequeue()
assert q.length == 0
def test_exhausted():
q = Queue()
q.enqueue("apple")
q.enqueue("banana")
q.enqueue("cucumber")
q.dequeue()
q.dequeue()
q.dequeue()
actual = q.is_empty()
expected = True
assert actual == expected
def test_dequeue_empty():
"""
Can successfully empty a queue after multiple dequeues
"""
food = Queue()
food.enqueue('bacon')
food.enqueue('cheese')
food.dequeue()
food.dequeue()
assert 'No Value.' == food.peek_queue()
def test_dequeue():
q = Queue()
q.enqueue("apple")
q.enqueue("banana")
actual = q.dequeue()
expected = "apple"
assert actual == expected
def test_dequeue_to_empty():
queue = Queue()
queue.enqueue(1)
queue.enqueue(2)
one = queue.dequeue()
two = queue.dequeue()
assert one.value == 1 and two.value == 2
def breadth_first(self, starting_vertex):
"""
Method to do breadth-first traversal on a graph.
Input: starting vertex
Output: list of vertices in the breadth-first order
"""
vertices = []
breadth = Queue()
if starting_vertex not in self._adjacency_list:
raise ValueError
breadth.enqueue(starting_vertex)
while not breadth.is_empty():
front = breadth.dequeue()
vertices.append(front)
for neighbor in self.get_neighbors(front):
if not neighbor[0].visited:
neighbor[0].visited = True
breadth.enqueue(neighbor[0])
for node in self._adjacency_list:
node.visited = False
return vertices
def test_dequeue_when_full():
q = Queue()
q.enqueue("apples")
q.enqueue("bananas")
actual = q.dequeue()
expected = "apples"
assert actual == expected
def test_dequeue():
q = Queue()
q.enqueue('1')
q.enqueue('2')
q.enqueue('3')
assert q.dequeue().__str__() == '1 -> None'
assert q.dequeue().__str__() == '2 -> None'
def breadth_add(self, value):
"""Method that takes in a value, and creates nodes with given value in level order"""
node = Node(value)
if not self.root:
self.root = node
return
q = Queue()
q.enqueue(self.root)
while not q.is_empty():
current = q.dequeue()
if current.left:
q.enqueue(current.left)
else:
current.left = node
break
if current.right:
q.enqueue(current.right)
else:
current.right = node
break
def test_one_dequeue():
"""Can successfully dequeue an item.
"""
line = Queue()
line.enqueue('Pam')
line.enqueue('Jim')
line.enqueue('Dwight')
expected = 'Pam'
actual = line.dequeue()
assert expected == actual
class AnimalShelter:
"""Class with dog queue and cat queue"""
def __init__(self):
self.dog = Queue()
self.cat = Queue()
def fifo_enqueue(self, animal):
"""Method that takes in an animal as an argument, and adds animal if cat or dog, to it's respective queues."""
if animal.get('type') == 'cat':
self.cat.enqueue(animal)
if animal.get('type') == 'dog':
self.dog.enqueue(animal)
def fifo_dequeue(self, preference):
"""Method that takes in a preference, where a cat or dog is selected, removed their respective queues, and returned"""
if preference == 'cat':
return self.cat.dequeue()
if preference == 'dog':
return self.dog.dequeue()
else:
return None
def breadth_first(self, item):
queue = Queue()
queue.enqueue(item)
seen =[]
while queue.peek_queue():
current = queue.dequeue()
if current.visited == False:
seen.append(current.value)
current.visited = True
for i in current.list:
if not i[0].visited:
queue.enqueue(i[0])
return seen
def breadth_first(tree, action_func):
# early return if empty tree
if tree is None or tree.root is None:
return
q = Queue()
q.enqueue(tree.root)
while True:
b, node = q.peek()
if b == False:
break
q.dequeue(node)
if node.left:
q.enqueue(node.left)
if node.right:
q.enqueue(node.right)
action_func(node.value)
def breadth_first(self, node):
nodes = []
breadth = Queue()
breadth.enqueue(node)
visited = {node: True}
while not breadth.is_empty():
front = breadth.dequeue()
nodes.append(front.value)
for el in self.adjacency_list[front]:
print(el.node.value)
if el.node not in visited:
visited[el.node] = True
breadth.enqueue(el.node)
return nodes
def breadth_first(self):
temp_queue = Queue()
results = []
if not self.root:
return "No bueno"
temp_queue.enqueue(self.root)
while temp_queue.peek():
current_node = temp_queue.dequeue()
results.append(current_node.value.value)
if current_node.value.left:
temp_queue.enqueue(current_node.value.left)
if current_node.value.right:
temp_queue.enqueue(current_node.value.right)
return results
def breadth_first(tree, node=None, array=None):
q = Queue()
if not array:
array = []
if tree.root:
q.enqueue(tree.root)
while q.peek():
front_node = q.dequeue()
array.append(front_node.data)
if front_node.left:
q.enqueue(front_node.left)
if front_node.right:
q.enqueue(front_node.right)
return array
def test_dequeue_when_empty():
q = Queue()
with pytest.raises(InvalidOperationError):
q.dequeue()
def test_dequeue_empty():
q = Queue()
with pytest.raises(Exception):
q.dequeue()
def test_queue_empty_dequeue():
testing_queue = Queue()
with pytest.raises(EmptyQueueException):
assert testing_queue.dequeue()
class AnimalShelter():
q = None # Queue
def __init__(self):
# create internal data structs
self.q = Queue()
def enqueue(self, animal: Animal):
# add animal to shelter
self.q.enqueue(animal.serialize())
def dequeue(self, pref: AnimalType = None) -> Animal:
# grab animal that has been in queue the longest, optionally provide parameter
# No Pref First
if pref == None:
b, val = self.q.peek()
if not b:
return None
if self.q.dequeue(val):
return Animal.Factory(val)
else:
stack = Stack()
# Find the Animal we Want (deq, push to stack)
found = False
b, val = self.q.peek()
while b:
animal = Animal.Factory(val)
if animal.animaltype == pref:
found = True
break
stack.push(val)
self.q.dequeue(val)
b, val = self.q.peek()
if found:
# Pop off stack and enqueue back to queue
# record the current count, as we need to cycle the enq (back of line) to the front
c = self.q.count()
b, val = stack.peek()
while b:
val = stack.pop()
self.q.enqueue(val)
b, val = stack.peek()
# cycle the back of the list to the front
diff = self.q.count() - c
for x in range(diff):
val = self.q.peek()
self.q.dequeue(val)
self.q.enqueue(val)
return animal
else:
return None
def test_dequeue():
queue = Queue()
queue.enqueue(1)
assert queue.dequeue().value == 1
