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()