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())
def test_size():
q = Queue(range(4))
for expected in range(4, 0, -1):
assert q.size() == expected
q.dequeue()
# queue is now empty
assert q.size() == 0
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 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_size_of_depopulated_queue(self):
"""Take the size of a queue that has been populated and then had
some items dequeued."""
q = Queue()
for val in self.values:
q.queue(val)
q.dequeue()
self.assertEqual(q.size(), len(self.values) - 1)
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 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')
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 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 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_size_of_empty_queue_popped_from(self):
"""Take the size of a queue that has been dequeued from its empty
state."""
q = Queue()
self.assertRaises(EmptyError, q.dequeue)
self.assertEqual(q.size(), 0)
def test_size_of_populated_queue(self):
"""Take the size of a populated queue."""
q = Queue()
for val in self.values:
q.queue(val)
self.assertEqual(q.size(), len(self.values))
def test_size_of_empty_queue(self):
"""Take the size of an empty queue."""
q = Queue()
self.assertTrue(q.head is None)
self.assertTrue(q.tail is None)
self.assertEquals(q.size(), 0)
