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);
}
