public void ClearTest() { var queue = new DefaultPriorityQueue <TestNode>(TestNodeComparer.Instance, 0); AssertEmptyQueue(queue); TestNode a = new TestNode(5); TestNode b = new TestNode(10); TestNode c = new TestNode(2); TestNode d = new TestNode(6); AssertEnqueue(queue, a); AssertEnqueue(queue, b); AssertEnqueue(queue, c); AssertEnqueue(queue, d); queue.Clear(); AssertEmptyQueue(queue); // Test that elements can be re-inserted after the clear operation AssertEnqueue(queue, a); Assert.Same(a, queue.Peek()); AssertEnqueue(queue, b); Assert.Same(a, queue.Peek()); AssertEnqueue(queue, c); Assert.Same(c, queue.Peek()); AssertEnqueue(queue, d); Assert.Same(c, queue.Peek()); }
public void ClearIgnoringIndexesTest() { var queue = new DefaultPriorityQueue <TestNode>(TestNodeComparer.Instance, 0); AssertEmptyQueue(queue); TestNode a = new TestNode(5); TestNode b = new TestNode(10); TestNode c = new TestNode(2); TestNode d = new TestNode(6); TestNode e = new TestNode(11); AssertEnqueue(queue, a); AssertEnqueue(queue, b); AssertEnqueue(queue, c); AssertEnqueue(queue, d); queue.ClearIgnoringIndexes(); AssertEmptyQueue(queue); // Elements cannot be re-inserted but new ones can. Assert.Throws <ArgumentException>(() => queue.TryEnqueue(a)); AssertEnqueue(queue, e); Assert.Same(e, queue.Peek()); }
private static void AssertEnqueue(DefaultPriorityQueue <TestNode> queue, TestNode item) { Assert.True(queue.TryEnqueue(item)); Assert.True(queue.Contains(item)); // An element can not be inserted more than 1 time. Assert.Throws <ArgumentException>(() => queue.Enqueue(item)); }
private static void AssertEmptyQueue(DefaultPriorityQueue <TestNode> queue) { Assert.False(queue.TryPeek(out _)); Assert.False(queue.TryDequeue(out _)); Assert.Equal(0, queue.Count); Assert.True(queue.IsEmpty); }
public void TestZeroInitialSize() { var queue = new DefaultPriorityQueue <TestNode>(TestNodeComparer.Instance, 0); AssertEmptyQueue(queue); TestNode e = new TestNode(1); AssertEnqueue(queue, e); Assert.Same(e, queue.Peek()); Assert.Equal(1, queue.Count); Assert.False(queue.IsEmpty); Assert.Same(e, queue.Dequeue()); AssertEmptyQueue(queue); }
public void PriorityQueueRemoveTest() { var queue = new DefaultPriorityQueue <TestNode>(TestNodeComparer.Instance, 4); AssertEmptyQueue(queue); TestNode a = new TestNode(5); TestNode b = new TestNode(10); TestNode c = new TestNode(2); TestNode d = new TestNode(6); TestNode notInQueue = new TestNode(-1); AssertEnqueue(queue, a); AssertEnqueue(queue, b); AssertEnqueue(queue, c); AssertEnqueue(queue, d); // Remove an element that isn't in the queue. Assert.False(queue.TryRemove(notInQueue)); Assert.Same(c, queue.Peek()); Assert.Equal(4, queue.Count); // Remove the last element in the array, when the array is non-empty. Assert.True(queue.TryRemove(b)); Assert.Same(c, queue.Peek()); Assert.Equal(3, queue.Count); // Re-insert the element after removal AssertEnqueue(queue, b); Assert.Same(c, queue.Peek()); Assert.Equal(4, queue.Count); // Repeat remove the last element in the array, when the array is non-empty. Assert.True(queue.TryRemove(b)); Assert.Same(c, queue.Peek()); Assert.Equal(3, queue.Count); // Remove the head of the queue. Assert.True(queue.TryRemove(c)); Assert.Same(a, queue.Peek()); Assert.Equal(2, queue.Count); Assert.True(queue.TryRemove(a)); Assert.Same(d, queue.Peek()); Assert.Equal(1, queue.Count); Assert.True(queue.TryRemove(d)); AssertEmptyQueue(queue); }
public void PriorityQueueOrderTest(int[] input, int[] expectedOutput) { var queue = new DefaultPriorityQueue <TestNode>(TestNodeComparer.Instance); foreach (int value in input) { queue.TryEnqueue(new TestNode(value)); } for (int index = 0; index < expectedOutput.Length; index++) { var item = queue.Dequeue(); Assert.Equal(expectedOutput[index], item.Value); } Assert.Equal(0, queue.Count); }
public void PriorityChangeTest() { var queue = new DefaultPriorityQueue <TestNode>(TestNodeComparer.Instance, 0); AssertEmptyQueue(queue); TestNode a = new TestNode(10); TestNode b = new TestNode(20); TestNode c = new TestNode(30); TestNode d = new TestNode(25); TestNode e = new TestNode(23); TestNode f = new TestNode(15); queue.TryEnqueue(a); queue.TryEnqueue(b); queue.TryEnqueue(c); queue.TryEnqueue(d); queue.TryEnqueue(e); queue.TryEnqueue(f); e.Value = 35; queue.PriorityChanged(e); a.Value = 40; queue.PriorityChanged(a); a.Value = 31; queue.PriorityChanged(a); d.Value = 10; queue.PriorityChanged(d); f.Value = 5; queue.PriorityChanged(f); var expectedOrderList = new List <TestNode>(new[] { a, b, c, d, e, f }); expectedOrderList.Sort(TestNodeComparer.Instance); Assert.Equal(expectedOrderList.Count, queue.Count); Assert.Equal(expectedOrderList.Count <= 0, queue.IsEmpty); for (var idx = 0; idx < expectedOrderList.Count; idx++) { Assert.Equal(expectedOrderList[idx], queue.Dequeue()); } AssertEmptyQueue(queue); }
public void EnqueueTest() { var queue = new DefaultPriorityQueue <TestNode>(TestNodeComparer.Instance, 0); AssertEmptyQueue(queue); TestNode a = new TestNode(5); TestNode b = new TestNode(10); TestNode c = new TestNode(2); TestNode d = new TestNode(7); TestNode e = new TestNode(6); AssertEnqueue(queue, a); AssertEnqueue(queue, b); AssertEnqueue(queue, c); AssertEnqueue(queue, d); // Remove the first element Assert.Same(c, queue.Peek()); Assert.Same(c, queue.Dequeue()); Assert.Equal(3, queue.Count); // Test that offering another element preserves the priority queue semantics. AssertEnqueue(queue, e); Assert.Equal(4, queue.Count); Assert.Same(a, queue.Peek()); Assert.Same(a, queue.Dequeue()); Assert.Equal(3, queue.Count); // Keep removing the remaining elements Assert.Same(e, queue.Peek()); Assert.Same(e, queue.Dequeue()); Assert.Equal(2, queue.Count); Assert.Same(d, queue.Peek()); Assert.Same(d, queue.Dequeue()); Assert.Equal(1, queue.Count); Assert.Same(b, queue.Peek()); Assert.Same(b, queue.Dequeue()); AssertEmptyQueue(queue); }