def test_dequeue(): queue = PriorityQueue() queue.enqueue("a") queue.enqueue("b") assert queue.dequeue() == "b" assert len(queue) == 1
def test_dequeue_empty_queue(): queue = PriorityQueue() with pytest.raises(IndexError) as exc: queue.dequeue() assert str(exc.value) == "dequeue from empty priority queue"
def test_peek_empty_queue(): queue = PriorityQueue() with pytest.raises(IndexError) as exc: queue.peek() assert str(exc.value) == "peek from empty priority queue"
def test_assign_priority_via_insert(): new_pq = PriorityQueue() for i in range(5): new_pq.insert(Job(priority=i+1)) new_pq.jobs[-1].time_created -= 100 new_pq.insert(Job(priority=6)) assert [job.priority for job in new_pq.jobs] == [8, 5, 6, 1, 4, 2]
def test_insert(self): pq = PriorityQueue() pq.add_element(1) self.assertTrue(pq.elements[0] == 1) for i in xrange(1, len(pq.elements)): self.assertTrue(pq.elements[i] is None)
def test_enqueue(items, expected_head): queue = PriorityQueue() for item in items: queue.enqueue(item) assert len(queue) == len(items) assert queue.peek() == expected_head
def test_priority_queue_empty(make_jobs): pq = PriorityQueue() assert pq.jobs == [] assert pq._operations == 0 pq = PriorityQueue(make_jobs) temp = [p.priority for p in pq.jobs] assert temp == [9, 9, 9, 7, 8, 3, 7, 3, 7, 4]
def test_peek(): queue = PriorityQueue() queue.enqueue("a") queue.enqueue("b") assert queue.peek() == "b" assert len(queue) == 2
def new_pq(): pq = PriorityQueue() for index, value in enumerate([3, 3, 4, 9, 7, 7, 9, 9, 7, 8]): pq.insert(Job(priority=value)) if not index % 3: pq._operations = 0 pq._operations = 0 return pq
def test_insert3(self): pq = PriorityQueue() pq.add_element(5) pq.add_element(4) pq.add_element(6) self.assertTrue(pq.elements[0] == 6) self.assertTrue(pq.elements[1] == 4) self.assertTrue(pq.elements[2] == 5) for i in xrange(3, len(pq.elements)): self.assertTrue(pq.elements[i] is None)
def test_assign_priority_via_pop(): new_pq = PriorityQueue() for _ in range(4): new_pq.insert(Job(priority=1)) new_pq.jobs[3].time_created -= 100 new_pq.pop() assert [job.priority for job in new_pq.jobs] == [6, 1, 1] new_pq.jobs[2].time_created -= 100 new_pq._operations = 4 new_pq.pop() assert [job.priority for job in new_pq.jobs] == [6, 1]
def test_assign_priority_via_pop(): new_pq = PriorityQueue() for i in range(5): new_pq.insert(Job(priority=i + 1)) new_pq.jobs[-1].time_created -= 100 new_pq.insert(Job(priority=6)) new_pq.pop() assert [job.priority for job in new_pq.jobs] == [6, 5, 1, 4, 2]
def search(start: Vertex.Vertex, goal: Vertex.Vertex, graph: Graph.Graph, f, g, h): f_score = dict(); f_score[start] = h(start, goal); g_score = collections.defaultdict(lambda: sys.maxsize); g_score[start] = 0; open_list = PriorityQueue.PriorityQueue(); open_list.add_task(start); came_from = dict(); discovered = collections.defaultdict(lambda: False); discovered[start] = True; while open_list: current = open_list.pop_task(); discovered[current] = True; if(current == goal): return generate_path.reconstruct_path(came_from, current); neighbors = current.get_neighbors(); for x in neighbors: tentative_gScore = g_score[current] + g(current, x); if tentative_gScore < g_score[x]: came_from[x] = current; g_score[x] = tentative_gScore; f_score[x] = f(g_score[x], h(x, goal)); if not discovered[x]: open_list.add_task(x, f_score[x]); return None;
def search(start: Vertex.Vertex, graph: Graph.Graph): unvisited_set = set(graph.vert_dict.values()) goal = set(graph.vert_dict.values()) f_score = collections.defaultdict(lambda: sys.maxsize) visited_set = set() f_score[start] = 0 open_list = PriorityQueue.PriorityQueue() open_list.add_task(start) came_from = dict() while open_list: current = open_list.pop_task() visited_set.add(current) unvisited_set.remove(current) if visited_set == goal: path = generate_path.reconstruct_path(came_from, current) path.append(list(graph.vert_dict.values())[0]) return path for x in unvisited_set: tentative_fscore = graph.vert_dict[current.get_id()].get_weight( x) + mst_heuristic(start, current, unvisited_set) if x not in open_list or x not in visited_set: f_score[x] = tentative_fscore open_list.add_task(x, f_score[x]) if x in open_list or x in visited_set and tentative_fscore < f_score[ x]: came_from[x] = current f_score[x] = tentative_fscore if (x in visited_set): unvisited_set.add(x) return None
def search(start, goal, map, f, g, h): f_score = dict() f_score[start] = h(start, goal) g_score = collections.defaultdict(lambda: sys.maxsize) g_score[start] = 0 open_list = PriorityQueue.PriorityQueue() open_list.add_task(start) came_from = dict() discovered = collections.defaultdict(lambda: False) discovered[start] = True while open_list: current = open_list.pop_task() discovered[current] = True if (current == goal): return generate_path.reconstruct_path(came_from, current) neighbors = current.get_neighbors() for x in neighbors: tentative_gScore = g_score[current] + g(current, x) if tentative_gScore < g_score[x]: came_from[x] = current g_score[x] = tentative_gScore f_score[x] = f(g_score[x], h(x, goal)) if not discovered[x]: open_list.add_task(x, f_score[x]) return None
def dijkstra(aGraph, start): pq = PriorityQueue() start.set_distance(0) pq.build_heap([(v, v.get_distance()) for v in aGraph]) while not pq.is_empty(): current_vert = pq.dequeue()[0] for next_vert in current_vert.get_connections(): new_dist = current_vert.get_distance() + current_vert.get_weight( next_vert) if new_dist < next_vert.get_distance(): next_vert.set_distance(new_dist) next_vert.set_pred(current_vert) pq.decrease_priority(next_vert, new_dist)
def test_iter(): queue = PriorityQueue() queue.enqueue("a") queue.enqueue("c") queue.enqueue("b") assert [item for item in queue] == ["c", "b", "a"]
def prim(aGraph, start): pq = PriorityQueue() for v in aGraph: v.set_distance(maxsize) v.set_pred(None) start.set_distance(0) pq.build_heap([(v, v.get_distance()) for v in aGraph]) while not pq.is_empty(): current_vert = pq.dequeue()[0] for next_vert in current_vert.get_connections(): new_cost = current_vert.get_weight(next_vert) if next_vert in pq and new_cost < next_vert.get_distance(): next_vert.set_distance(new_cost) next_vert.set_pred(current_vert) pq.decrease_priority(next_vert, new_cost)
def test_enqueue(self): queue = PriorityQueue() priority_item_one = PriorityItem("item1", 1) priority_item_two = PriorityItem("item2", 1) queue.enqueue(priority_item_one) queue.enqueue(priority_item_two) front = queue.front() assert len(queue) == 2 assert front.value == priority_item_one.value assert front.priority == priority_item_one.priority priority_item_three = PriorityItem("item3", 2) queue.enqueue(priority_item_three) front = queue.front() assert len(queue) == 3 assert front.value == priority_item_three.value assert front.priority == priority_item_three.priority
def test_delete(self): pq = PriorityQueue() pq.add_element(5) pq.add_element(4) pq.add_element(6) pq.add_element(6) pq.add_element(3) pq.add_element(7) self.assertTrue(pq.elements[0] == 7) self.assertTrue(pq.elements[1] == 6) self.assertTrue(pq.elements[2] == 6) self.assertTrue(pq.elements[3] == 4) self.assertTrue(pq.elements[4] == 3) self.assertTrue(pq.elements[5] == 5) for i in xrange(6, len(pq.elements)): self.assertTrue(pq.elements[i] is None) res = pq.pop() self.assertTrue(res == 7)
def mst(g: Graph.Graph): min_tree = Graph.Graph() open_list = PriorityQueue.PriorityQueue() cost = collections.defaultdict(lambda: sys.maxsize) for x in g.vert_dict.values(): open_list.add_task(x, cost[x]) edge = collections.defaultdict(lambda: False) while open_list: current = open_list.pop_task() min_tree.add_vertex(current.get_id()) if edge[current]: min_tree.add_edge(current.get_id(), edge[current][0].get_id(), edge[current][1]) for x in current.get_neighbors(): if x in open_list and current.get_weight(x) < cost[x]: cost[x] = current.get_weight(x) edge[x] = (current, cost[x]) open_list.add_task(x, cost[x]) return min_tree
class PriorityQueueTest(unittest.TestCase): def setUp(self): self.queue = PriorityQueue() @istest def starts_at_zero_size(self): self.assertEqual(0, len(self.queue)) @istest def can_push_an_elements(self): self.queue.push('a') self.assertEqual(1, len(self.queue)) @istest def can_push_multiple_elements(self): self.queue.push('a') self.queue.push('b') self.queue.push('c') self.assertEqual(3, len(self.queue)) @istest def can_pop_an_element(self): expected_element = 'a' self.queue.push(expected_element) self.assertEqual(expected_element, self.queue.pop()) self.assertEqual(0, len(self.queue)) @istest def can_pop_multiple_element(self): expected_output = set(['a', 'b', 'c']) for item in expected_output: self.queue.push(item) actual_output = set() while self.queue: actual_output.add(self.queue.pop()) self.assertEqual(expected_output, actual_output) self.assertEqual(0, len(self.queue)) @istest def can_pop_items_in_priority_order(self): self.queue.push('a', 10) self.queue.push('b', 50) self.queue.push('c', 1) self.assertEqual('c', self.queue.pop()) self.assertEqual('a', self.queue.pop()) self.assertEqual('b', self.queue.pop()) @istest def no_priority_defaults_to_lowest_priority(self): self.queue.push('a') self.queue.push('b', 99) self.assertEqual('b', self.queue.pop()) self.assertEqual('a', self.queue.pop()) @istest def remove_elements(self): self.queue.push('a', 9) self.queue.push('b', 99) self.queue.remove('a') self.assertEqual(1, len(self.queue)) self.assertEqual('b', self.queue.pop()) self.assertEqual(0, len(self.queue)) @istest def empty_queue_throws_key_error(self): with self.assertRaises(KeyError): self.queue.pop() with self.assertRaises(KeyError): self.queue.push('a') self.queue.pop() self.queue.pop() with self.assertRaises(KeyError): self.queue.push('b') self.queue.remove('b') self.queue.pop() @istest def can_update_priority(self): self.queue.push('a', 99) self.queue.push('b', 10) self.assertEqual(2, len(self.queue)) self.queue.update('a', 3) self.assertEqual(2, len(self.queue)) self.assertEqual('a', self.queue.pop()) self.assertEqual('b', self.queue.pop()) self.assertEqual(0, len(self.queue))
def setUp(self): self.queue = PriorityQueue()
def test_dequeue(self): queue = PriorityQueue() priority_item_one = PriorityItem("item1", 1) priority_item_two = PriorityItem("item2", 3) priority_item_three = PriorityItem("item3", 99) queue.enqueue(priority_item_one) front_item = queue.front() assert len(queue) == 1 assert front_item.value == priority_item_one.value assert front_item.priority == priority_item_one.priority dequed_value = queue.dequeue() assert len(queue) == 0 assert dequed_value.value == priority_item_one.value assert dequed_value.priority == priority_item_one.priority assert queue.dequeue() == None queue.enqueue(priority_item_three) queue.enqueue(priority_item_one) queue.enqueue(priority_item_two) assert queue.dequeue().value == priority_item_three.value assert queue.dequeue().value == priority_item_two.value assert queue.dequeue().value == priority_item_one.value
def test_batch_increment(self): pq = PriorityQueue() pq.add_element(Deneme('a', 1)) pq.add_element(Deneme('b', 5)) pq.add_element(Deneme('b', 10)) pq.add_element(Deneme('a', 7)) pq.add_element(Deneme('a', 9)) pq.add_element(Deneme('b', 12)) self.assertTrue(pq.elements[0].val == 12) self.assertTrue(pq.elements[1].val == 9) self.assertTrue(pq.elements[2].val == 10) self.assertTrue(pq.elements[3].val == 1) self.assertTrue(pq.elements[4].val == 7) self.assertTrue(pq.elements[5].val == 5) for i in xrange(6, len(pq.elements)): self.assertTrue(pq.elements[i] is None) def validate(obj): return obj.label == 'a' def update(obj): obj.val += 1 pq.batch_increment(validate, update) self.assertTrue(pq.elements[0].val == 12) self.assertTrue(pq.elements[1].val == 10) self.assertTrue(pq.elements[2].val == 10) self.assertTrue(pq.elements[3].val == 2) self.assertTrue(pq.elements[4].val == 8) self.assertTrue(pq.elements[5].val == 5)
def test_empty_pop(): pq = PriorityQueue() with pytest.raises(IndexError): pq.pop()
def test_priority_queue_sequence(make_jobs): pq = PriorityQueue(make_jobs) temp = [p.priority for p in pq.jobs] assert temp == [9, 9, 9, 7, 8, 3, 7, 3, 7, 4]