def test_peek_empty_queue():
queue = Queue()
with pytest.raises(IndexError) as exc:
queue.peek()
assert str(exc.value) == "peek from empty queue"
def test_peek():
queue = Queue()
queue.enqueue("a")
queue.enqueue("n")
assert queue.peek() == "a"
assert len(queue) == 2
def test_dequeue_empty_queue():
queue = Queue()
with pytest.raises(IndexError) as exc:
queue.dequeue()
assert str(exc.value) == "dequeue from empty queue"
def test_dequeue():
queue = Queue()
queue.enqueue("a")
queue.enqueue("b")
assert queue.dequeue() == "a"
assert len(queue) == 1
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 __init__(self, heap_size, heap_list):
self.current_elem = 0
self.heap_list = heap_list
self.end = heap_size - 1
self.count = 0
self.queue = Queue()
self.queue.push(0)
def __init__(self, truck_id, package_limit, speed, start_of_day,
hub_location):
"""
Create Truck Object
:param truck_id: id of the truck :int
:param package_limit: maximum number of packages truck can hold :int
:param speed: speed of truck in miles per hour :int
:param start_of_day: time of start of day :str
:param hub_location: location of hub :Location
:return: Truck Object
Worst Case Runtime Complexity: O(1)
Best Case Runtime Complexity: O(1)
"""
self._id = truck_id
self._package_limit = package_limit
self._speed = (speed / 60) / 60 # truck speed in miles per second
self._locations = Graph()
self._packages = []
self._start_of_day = start_of_day
self._locations.add_vertex(hub_location.name, hub_location)
self._route = Queue()
self._departure_time = None # departure time in seconds since start
self._distance_traveled = 0.0
self._current_location = None
self._next_location = None
self._route_done = False
def test_peek():
q = Queue(range(4))
for _ in range(4):
expected = q.peek()
assert expected == q.dequeue()
# queue is now empty
assert q.peek() is None
def test_dequeue_from_populated_queue(self):
"""Dequeue a value from a populated queue."""
q = Queue()
q.queue(self.single_value)
dequeued = q.dequeue()
self.assertEqual(dequeued, self.single_value)
self.assertTrue(isinstance(dequeued, type(self.single_value)))
def test_dequeue_last_item_from_queue(self):
"""Dequeue a value from a queue that contains only one item."""
q = Queue()
self.assertTrue(q.head is None)
self.assertTrue(q.tail is None)
q.queue(self.single_value)
q.dequeue()
self.assertTrue(q.head is None)
self.assertTrue(q.tail is None)
def test_queue_to_empty_queue(self):
"""Queue a value on an empty queue."""
q = Queue()
self.assertTrue(q.head is None)
self.assertTrue(q.tail is None)
q.queue(self.single_value)
self.assertEqual(q.head.value, self.single_value)
self.assertEqual(q.tail.value, self.single_value)
self.assertTrue(isinstance(q.head.value, type(self.single_value)))
def test_remove(self):
queue = Queue()
queue.add('one')
queue.add('two')
data = queue.remove()
self.assertEqual(data, 'one')
self.assertEqual(queue.first.data, 'two')
self.assertEqual(queue.last.data, 'two')
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_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_queue_to_populated_queue(self):
"""Queue a value on a populated queue."""
q = Queue()
self.assertTrue(q.head is None)
self.assertTrue(q.tail is None)
for val in self.values:
q.queue(val)
self.assertEqual(q.head.value, self.values[-1])
self.assertEqual(q.tail.value, self.values[0])
self.assertTrue(isinstance(q.head.value, type(self.values[-1])))
self.assertTrue(isinstance(q.tail.value, type(self.values[0])))
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_peek():
q = Queue()
q.enqueue("apple")
q.enqueue("banana")
q.enqueue("cucumber")
actual = q.peek()
expected = "apple"
assert actual == expected
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(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")
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 setup(self, num_trucks, packages_per_truck, truck_mph, start_of_day, end_of_day):
"""
Sets up simulations by loading and queueing up trucks
:param num_trucks: number of trucks available
:param packages_per_truck: number of packages per truck
:param truck_mph: speed of truck in miles per hour
:param start_of_day: start time of simulation
:param end_of_day: time of end of day
:return: None
Worst Case Runtime Complexity: O(N^2)
Best Case Runtime Complexity: O(N^2)
"""
truck_list = []
for truck_id in range(1, num_trucks + 1):
truck_list.append(Truck(truck_id, packages_per_truck, truck_mph, start_of_day, self.locations.get_vertex_by_index(0).data))
truck_queue = Queue()
for truck in Truck.sort_packages([x for x in self._packages], truck_list, start_of_day, end_of_day):
# Add location data for packages in truck
truck.set_locations(self.locations)
truck.find_route()
# Add truck to truck queue
self._trucks.push(truck)
def test_queue():
queue = Queue()
queue.push("foo")
queue.push("bar")
queue.push("baz")
assert "foo" == queue.pop()
assert "bar" == queue.pop()
assert "baz" == queue.pop()
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_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()
q.enqueue("apple")
q.enqueue("banana")
actual = q.dequeue()
expected = "apple"
assert actual == expected
def add_values_to_empty_tree(tree, values):
"""
Helper function to add given values to BinaryTree
"""
tree.root = Node(values.pop())
q = Queue()
q.enqueue(tree.root)
while values:
node = q.dequeue()
node.left = Node(values.pop())
node.right = Node(values.pop()) if values else None
q.enqueue(node.left)
q.enqueue(node.right)
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 __init__(self, start_time, delayed_flight_time, table_size):
"""
Create a Simulation Object
:param start_time: start time of simulation
:param delayed_flight_time: time delayed packages arrive on flight
:param table_size: size of the hashtable
Worst Case Runtime Complexity: O(1)
Best Case Runtime Complexity: O(1)
"""
self._start_time = start_time
self._clock = Clock(0, start_time)
self._packages = HashTable(table_size)
self._active_trucks = []
self._trucks = Queue()
self.simulation_over = False
self._delayed_flight_time = Clock.seconds_since_start(delayed_flight_time, start_time)
self._delayed_packages_departed = False
self._total_miles = 0.0
self.locations = Graph()
self.wrong_address_fixed = False
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 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
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():
q = Queue()
for i in range(1, 4):
q.enqueue(i)
assert q.dequeue() == 1
assert q.dequeue() == 2
assert q.dequeue() == 3
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 test_iter():
queue = Queue()
queue.enqueue("a")
queue.enqueue("b")
queue.enqueue("c")
assert [item for item in queue] == ["a", "b", "c"]
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)
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_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 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 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_size_empty(self):
my_queue = Queue()
self.assertEqual(0, 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_dequeue_empty(self):
my_queue = Queue()
self.failureException('Uh oh!! Queue is empty', my_queue.dequeue())
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 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_enqueue(items):
q = Queue()
for item in items:
q.enqueue(item)
for item in items:
assert q.dequeue() == item
def test_dequeue(items):
q = Queue(items)
for item in items:
assert q.dequeue() == item
with pytest.raises(IndexError):
q.dequeue()
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_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)
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 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)
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():
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_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 setUp(self):
self.q = Queue()
