def test_dequeue_when_full():
q = Queue()
q.enqueue("apples")
q.enqueue("bananas")
actual = q.dequeue()
expected = "apples"
assert actual == expected
def test_enqueue_two():
q = Queue()
q.enqueue("apples")
q.enqueue("bananas")
actual = q.peek()
expected = "apples"
assert actual == expected
def test_dequeue():
q = Queue()
for i in range(1, 4):
q.enqueue(i)
assert q.dequeue() == 1
assert q.dequeue() == 2
assert q.dequeue() == 3
def hotPotato(nameList, num):
"""
Return the name of the last person remaining after repetitive counting by num.
In this game children line up in a circle and pass an item from neighbor to neighbor as fast as they can.
At a certain point in the game, the action is stopped and the child who has the potato is removed from the circle.
Play continues until only one child is left.
INPUT
------
namelist : Players name
num : number of times item is passed
RETURN
------
player who is left after all iterations
"""
q = Queue(); numCount = 0
for i in range(len(nameList)):
q.enqueue(nameList[i])
while(q.size() > 1):
for i in range(num):
temp_removed_item = q.dequeue()
q.enqueue(temp_removed_item)
removed_item = q.dequeue()
print("Players remaining : ",q.items)
numCount += 1
return q.items[0]
def test_peek():
queue = Queue()
queue.enqueue("a")
queue.enqueue("n")
assert queue.peek() == "a"
assert len(queue) == 2
def test_dequeue():
q = Queue()
q.enqueue("apple")
q.enqueue("banana")
actual = q.dequeue()
expected = "apple"
assert actual == expected
def test_dequeue():
queue = Queue()
queue.enqueue("a")
queue.enqueue("b")
assert queue.dequeue() == "a"
assert len(queue) == 1
def test_iter():
queue = Queue()
queue.enqueue("a")
queue.enqueue("b")
queue.enqueue("c")
assert [item for item in queue] == ["a", "b", "c"]
def test_length_queue(self):
my_queue = Queue()
my_queue.enqueue(5)
my_queue.enqueue(7)
my_queue.enqueue(9)
self.assertTrue(
len(my_queue) == 3, "length of the queue was not as expected")
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_remove(self):
my_queue = Queue()
my_queue.enqueue(5)
my_queue.enqueue(7)
my_queue.enqueue(9)
deque_test = my_queue.dequeue()
self.assertEqual(5, deque_test,
"dequeue did not remove the first item")
def search_bfs(start_node):
q = Queue()
q.enqueue(start_node)
while not q.is_empty():
n = q.dequeue()
if not n.visited:
visit(n)
n.visited = True
for i in n.get_connections():
q.enqueue(i)
def test_size():
q = Queue()
assert q.size() == 0
for i in range(1, 4):
q.enqueue(i)
assert q.size() == 3
q.dequeue()
assert q.size() == 2
q.dequeue()
assert q.size() == 1
def test_dequeue():
u"""Asserts nodes are properly removed."""
q = Queue()
for val in value_tuple:
q.enqueue(val)
for val in value_tuple:
if q.list.head_node:
assert q.dequeue() == val
else:
with pytest.raises(LookupError):
q.dequeue()
def test_len(self):
# Arrange
my_queue = Queue()
my_queue.enqueue(1)
my_queue.enqueue(2)
# Act
len1 = len(my_queue)
# Assert
self.assertEqual(2, len1, "your lengths do not match yo :(")
def test_enqueue(self):
queue = Queue()
queue.enqueue(1)
queue.enqueue(2)
assert len(queue) == 2
assert queue.front() == 1
queue.enqueue([3, 4, 5])
assert len(queue) == 5
assert queue.front() == 1
def _bfs(self):
search_queue = Queue()
search_queue.enqueue(self.source)
self.marked.add(self.source)
while not search_queue.is_empty():
current = search_queue.dequeue()
neighbors = self.graph.adjacent(current)
for neighbor in neighbors:
if neighbor not in self.marked:
search_queue.enqueue(neighbor)
self.marked.add(neighbor)
self.edge_to[neighbor] = current
def hot_potato(namelist, num):
sim_queue = Queue()
for name in namelist:
sim_queue.enqueue(name)
while sim_queue.size() > 1:
for i in range(num):
sim_queue.enqueue(sim_queue.dequeue())
print "removing %s" % sim_queue.dequeue()
return sim_queue.dequeue()
def test_enqueue_len(self):
#Arrange
my_queue = Queue()
my_queue.enqueue(1)
my_queue.enqueue(2)
my_queue.enqueue(3)
#Act
length = my_queue.__len__()
#Assert
self.assertEqual(3, length, "len did not return correct length")
def test_enqueue(self):
# Arrange
my_queue = Queue()
my_queue.enqueue(1)
my_queue.enqueue(2)
# Act
enqueue1 = my_queue.dequeue()
enqueue2 = my_queue.dequeue()
# Assert
self.assertEqual(2, enqueue1, "first enqueue did not match")
self.assertEqual(1, enqueue2, "second enqueue did not match")
class TestQueue(TestCase):
def setUp(self):
super().setUp()
self.queue = Queue()
def test_enqueue_dequeue(self):
self.queue.enqueue(1)
self.queue.enqueue(2)
self.assertEqual(self.queue.dequeue(), 1)
self.assertEqual(self.queue.dequeue(), 2)
def test_peek(self):
self.queue.enqueue(1)
self.queue.enqueue(2)
self.assertEqual(self.queue.peek(), 1)
self.assertEqual(self.queue.size(), 2)
def test_size(self):
self.queue.enqueue(1)
self.queue.enqueue(2)
self.assertEqual(self.queue.size(), 2)
def test_is_empty(self):
self.assertTrue(self.queue.is_empty())
self.queue.enqueue(1)
self.assertFalse(self.queue.is_empty())
self.queue.dequeue()
self.assertTrue(self.queue.is_empty())
class testDequeue(unittest.TestCase):
def setUp(self):
self.q = Queue()
def testEmptyQueue(self):
self.assertRaises(IndexError, self.q.dequeue)
def testQueueOfOne(self):
self.q.enqueue(10)
self.assertEqual(self.q.dequeue(), 10)
self.assertEqual(self.q.head, None)
self.assertEqual(self.q.tail, None)
def testLongQueue(self):
self.q.enqueue(10)
self.q.enqueue(11)
self.q.enqueue(12)
self.q.enqueue(13)
self.q.enqueue(14)
self.q.enqueue(15)
self.assertEqual(self.q.dequeue(), 10)
self.assertEqual(self.q.head.val, 15)
self.assertEqual(self.q.tail.val, 11)
self.assertEqual(self.q.dequeue(), 11)
self.assertEqual(self.q.head.val, 15)
self.assertEqual(self.q.tail.val, 12)
def breadth_first(self):
queue = Queue()
collection = []
queue.enqueue(self.root)
while not queue.is_empty():
node = queue.dequeue()
collection.append(node.value)
for child in node.children:
queue.enqueue(child)
return collection
def bfs(g, start):
start.set_distance(0)
start.set_pred(None)
vq = Queue()
vq.enqueue(start)
while vq.size() > 0:
current_vert = vq.dequeue()
for nbr in current_vert.get_connections():
if nbr.get_color() == 'white':
nbr.set_color('gray')
nbr.set_distance(current_vert.get_distance() + 1)
nbr.set_pred(current_vert)
vq.enqueue(nbr)
current_vert.set_color('black')
def test_dequeue(self):
# Arrange
my_queue = Queue()
my_queue.enqueue(1)
my_queue.enqueue(2)
# Act
dequeue1 = my_queue.dequeue()
dequeue2 = my_queue.dequeue()
# Assert
self.assertEqual(1, dequeue1, "The value is not correct")
self.assertEqual(2, dequeue2, "The value is not correct")
def find_path(graph, start_val, end_val):
ns = graph.get_node(start_val)
ne = graph.get_node(end_val)
q = Queue()
q.enqueue(ns)
found = False
while not q.is_empty() and not found:
n = q.dequeue()
for c in n.get_connections():
if not c.visited:
if c == ne:
found = True
else:
q.enqueue(c)
n.visited = True
return found
def breadth_first_search(graph: List[int], source_vertex: int,
target_vertex: int) -> List[int]:
vertices_to_visit = Queue()
vertices_to_visit.enqueue(source_vertex)
distances = {source_vertex: 0}
while not vertices_to_visit.is_empty():
current_vertex = vertices_to_visit.dequeue()
for neighbor in range(1, graph[current_vertex] + 1):
neighbor_index = current_vertex + neighbor
if neighbor_index < len(graph):
if neighbor_index not in distances:
distances[neighbor_index] = distances[current_vertex] + 1
if neighbor_index == target_vertex:
return distances[target_vertex]
vertices_to_visit.enqueue(neighbor_index)
def test_dequeue(self):
queue = Queue()
queue.enqueue("item1")
assert len(queue) > 0
assert queue.front() == "item1"
dequeued_value = queue.dequeue()
assert dequeued_value == "item1"
assert len(queue) == 0
assert queue.front() == None
dequeued_value = queue.dequeue()
assert dequeued_value == None
assert len(queue) == 0
assert queue.front() == None
def bfs(start):
"""
:param start: instance VertexForBFS
:return: None
"""
start.distance = 0
start.prev_vertex = None
vertex_queue = Queue()
vertex_queue.enqueue(start)
while vertex_queue.size() > 0:
current_vertex = vertex_queue.dequeue()
for nbr in current_vertex.get_connections():
if nbr.color == 'white':
nbr.color = 'gray'
nbr.distance = current_vertex.distance + 1
nbr.prev_vertex = current_vertex
vertex_queue.enqueue(nbr)
current_vertex.color = 'black'
def breadth_first_traversal(self, start):
if start not in self.nodes():
raise KeyError
node = start
q = Queue()
q.enqueue(node)
traversed = []
while len(traversed) < len(self.nodes()):
try:
node = q.dequeue()
print node
traversed.insert(0, node)
children = self.neighbors(node)
for child in children:
if child not in traversed:
q.enqueue(child)
except LookupError:
break
traversed.reverse()
return traversed
def breadth_first_traversal(self, start):
if start not in self.nodes():
raise KeyError
node = start
q = Queue()
q.enqueue(node)
traversed = []
while len(traversed) < len(self.nodes()):
try:
node = q.dequeue()
print node
traversed.insert(0, node)
children = self.neighbors(node)
for child in children:
if child not in traversed:
q.enqueue(child)
except LookupError:
break
traversed.reverse()
return traversed
def simulation(num_seconds, ppm):
printer = Printer(ppm)
print_queue = Queue()
waiting_times = []
for current_second in range(num_seconds):
if new_print_task():
task = Task(current_second)
print_queue.enqueue(task)
if not printer.busy() and not print_queue.is_empty():
next_task = print_queue.dequeue()
waiting_times.append(next_task.waitTime(current_second))
printer.start_next(next_task)
printer.tick()
average_wait = sum(waiting_times) / len(waiting_times)
#print("Average Wait %6.2f secs %3d tasks remaining."%(average_wait,print_queue.size()))
return average_wait
class testEnqueue(unittest.TestCase):
def setUp(self):
self.q = Queue()
def testEmptyQueue(self):
self.q.enqueue(10)
self.assertEqual(self.q.head.val, 10)
self.assertEqual(self.q.tail.val, 10)
def testQueueOfOne(self):
self.q.enqueue(10)
self.q.enqueue(11)
self.assertEqual(self.q.head.val, 11)
self.assertEqual(self.q.tail.val, 10)
def testLongQueue(self):
self.q.enqueue(10)
self.q.enqueue(11)
self.q.enqueue(12)
self.q.enqueue(13)
self.q.enqueue(14)
self.q.enqueue(15)
self.assertEqual(self.q.head.val, 15)
self.assertEqual(self.q.tail.val, 10)
def test_enqueue():
q = Queue()
q.enqueue(1)
assert q.head.value == 1
assert q.head.next is None
assert q.tail.value == 1
q.enqueue(2)
assert q.head.value == 1
assert q.head.next.value == 2
assert q.tail.value == 2
q.enqueue(3)
assert q.head.value == 1
assert q.head.next.value == 2
assert q.tail.value == 3
class testSize(unittest.TestCase):
def setUp(self):
self.q = Queue()
def testEmptyQueue(self):
self.assertEqual(self.q.size(), 0)
def testQueueOfOne(self):
self.q.enqueue(10)
self.assertEqual(self.q.size(), 1)
self.q.dequeue()
self.assertEqual(self.q.size(), 0)
def testLongQueue(self):
self.q.enqueue(10)
self.q.enqueue(11)
self.q.enqueue(12)
self.q.enqueue(13)
self.q.enqueue(14)
self.q.enqueue(15)
self.assertEqual(self.q.size(), 6)
self.q.dequeue()
self.q.dequeue()
self.assertEqual(self.q.size(), 4)
def testQueue(self):
queue = Queue()
self.assertTrue(queue.isEmpty())
self.assertEqual(0, queue.size)
queue.enqueue(5)
self.assertFalse(queue.isEmpty())
self.assertEqual(1, queue.size)
queue.enqueue(6)
self.assertEqual(2, queue.size)
self.assertEqual(5, queue.dequeue())
self.assertEqual(1, queue.size)
self.assertEqual(6, queue.dequeue())
self.assertEqual(0, queue.size)
self.assertTrue(queue.isEmpty())
queue.enqueue(8)
queue.clear()
self.assertEqual(0, queue.size)
self.assertTrue(queue.isEmpty())
def test_enqueue_empty(self):
my_queue = Queue()
my_queue.enqueue('1')
self.assertEqual('1', my_queue.head.val)
def test_size_not_empty(self):
my_queue = Queue()
my_queue.enqueue('4')
my_queue.enqueue('3')
my_queue.enqueue('2')
self.assertEqual(3, my_queue.get_size())
def test_dequeue_not_empty(self):
my_queue = Queue()
my_queue.enqueue('4')
my_queue.enqueue('3')
my_queue.enqueue('2')
self.assertEqual('4', my_queue.dequeue())
def test_enqueue_not_empty(self):
my_queue = Queue()
my_queue.enqueue('1')
my_queue.enqueue('2')
self.assertEqual(('1', '2'), (my_queue.head.val, my_queue.tail.val))
def test_enqueue():
u"""Asserts nodes are added and hold their own value."""
q = Queue()
for val in value_tuple:
q.enqueue(val)
assert q.list.head_node.value == val
def test_size():
u"""Asserts size of Queue remains as expected during enqueue process."""
q = Queue()
for i, val in enumerate(value_tuple, 1):
q.enqueue(val)
assert q.size() == i
def test_enqueue(items):
q = Queue()
for item in items:
q.enqueue(item)
for item in items:
assert q.dequeue() == item
