public void CanFixedCapacity0()
{
const int capacity = 0;
var pq = new TestPriorityQueue <char>(capacity);
Assert.Equal(0, pq.Capacity);
Assert.Equal(0, pq.Count);
Assert.Throws <InvalidOperationException>(() => pq.Top()); // queue empty
Assert.Throws <InvalidOperationException>(() => pq.Pop()); // queue empty
// With capacity zero, all additions immediately overflow:
Assert.Equal('z', pq.AddWithOverflow('z'));
Assert.Equal('a', pq.AddWithOverflow('a'));
Assert.Throws <InvalidOperationException>(() => pq.Add('b')); // queue full
}
public void CanFixedCapacity7()
{
// Capacity 7: complete binary tree
const int capacity = 7;
var pq = new TestPriorityQueue <char>(capacity);
Assert.Equal(7, pq.Capacity);
Assert.Equal(0, pq.Count);
pq.Add('e');
Assert.Equal('e', pq.Top());
pq.Add('g');
Assert.Equal('e', pq.Top());
pq.Add('b');
Assert.Equal('b', pq.Top());
pq.Add('c');
Assert.Equal('b', pq.Top());
pq.Add('a');
Assert.Equal('a', pq.Top());
pq.Add('f');
Assert.Equal('a', pq.Top());
pq.Add('d');
Assert.Equal('a', pq.Top());
Assert.Equal(7, pq.Count);
Assert.Equal('a', pq.Top());
Assert.Equal('a', pq.AddWithOverflow('x')); // 'a' drops out
Assert.Equal('a', pq.AddWithOverflow('a')); // 'a' never gets in...
Assert.Equal(7, pq.Count);
Assert.Equal('b', pq.Top());
Assert.Equal('b', pq.Pop());
Assert.Equal('c', pq.Pop());
Assert.Equal('d', pq.Pop());
Assert.Equal('e', pq.Pop());
Assert.Equal('f', pq.Pop());
Assert.Equal('g', pq.Pop());
Assert.Equal('x', pq.Top());
Assert.Equal('x', pq.Pop());
Assert.Equal(0, pq.Count);
Assert.Throws <InvalidOperationException>(() => pq.Pop()); // queue empty
}
public void CanFixedCapacity6()
{
// Capacity 6: incomplete binary tree
const int capacity = 6;
var pq = new TestPriorityQueue <char>(capacity);
Assert.AreEqual(6, pq.Capacity);
Assert.AreEqual(0, pq.Count);
pq.Add('e');
Assert.AreEqual('e', pq.Top());
pq.Add('b');
Assert.AreEqual('b', pq.Top());
pq.Add('c');
Assert.AreEqual('b', pq.Top());
pq.Add('a');
Assert.AreEqual('a', pq.Top());
pq.Add('f');
Assert.AreEqual('a', pq.Top());
pq.Add('d');
Assert.AreEqual('a', pq.Top());
Assert.AreEqual(6, pq.Count);
Assert.AreEqual('a', pq.AddWithOverflow('x'));
Assert.AreEqual('a', pq.AddWithOverflow('a'));
Assert.AreEqual(6, pq.Count);
Assert.AreEqual('b', pq.Top());
Assert.AreEqual('b', pq.Pop());
Assert.AreEqual('c', pq.Pop());
Assert.AreEqual('d', pq.Pop());
Assert.AreEqual('e', pq.Pop());
Assert.AreEqual('f', pq.Pop());
Assert.AreEqual('x', pq.Pop());
Assert.AreEqual(0, pq.Count);
var ex = Assert.Catch(() => pq.Pop());
Console.WriteLine("Expected: {0}", ex.Message);
}
public void CanFixedCapacity6()
{
// Capacity 6: incomplete binary tree
const int capacity = 6;
var pq = new TestPriorityQueue <char>(capacity);
Assert.Equal(6, pq.Capacity);
Assert.Equal(0, pq.Count);
pq.Add('e');
Assert.Equal('e', pq.Top());
pq.Add('b');
Assert.Equal('b', pq.Top());
pq.Add('c');
Assert.Equal('b', pq.Top());
pq.Add('a');
Assert.Equal('a', pq.Top());
pq.Add('f');
Assert.Equal('a', pq.Top());
pq.Add('d');
Assert.Equal('a', pq.Top());
Assert.Equal(6, pq.Count);
Assert.Equal('a', pq.AddWithOverflow('x'));
Assert.Equal('a', pq.AddWithOverflow('a'));
Assert.Equal(6, pq.Count);
Assert.Equal('b', pq.Top());
Assert.Equal('b', pq.Pop());
Assert.Equal('c', pq.Pop());
Assert.Equal('d', pq.Pop());
Assert.Equal('e', pq.Pop());
Assert.Equal('f', pq.Pop());
Assert.Equal('x', pq.Pop());
Assert.Equal(0, pq.Count);
Assert.Throws <InvalidOperationException>(() => pq.Pop()); // queueu empty
}
public void PerformanceTest()
{
const int capacity = 100 * 1000;
const int count = 100 * capacity;
var random = new Random(12345);
var startTime1 = DateTime.Now;
var pq1 = new TestPriorityQueue <int>(capacity);
for (int i = 0; i < count; i++)
{
int value = random.Next();
pq1.AddWithOverflow(value);
}
Assert.AreEqual(Math.Min(capacity, count), pq1.Count);
while (pq1.Count > 0)
{
pq1.Pop();
}
var elapsed1 = DateTime.Now - startTime1;
Console.WriteLine("Capacity={0:N0} Count={1:N0} AddWithOverflow/Pop Elapsed={2}",
capacity, count, elapsed1);
var startTime2 = DateTime.Now;
var pq2 = new TestPriorityQueue <int>(); // unbounded
for (int i = 0; i < count; i++)
{
int value = random.Next();
pq2.Add(value);
}
Assert.AreEqual(count, pq2.Count);
while (pq2.Count > 0)
{
pq2.Pop();
}
var elapsed2 = DateTime.Now - startTime2;
Console.WriteLine("Capacity=unbounded Count={0:N0} Add/Pop Elapsed={1}",
count, elapsed2);
Assert.Less(elapsed1, TimeSpan.FromSeconds(1), "Too slow");
Assert.Less(elapsed2, TimeSpan.FromSeconds(12), "Too slow");
}
public void CanFixedCapacity0()
{
const int capacity = 0;
var pq = new TestPriorityQueue <char>(capacity);
Assert.AreEqual(0, pq.Capacity);
Assert.AreEqual(0, pq.Count);
var ex1 = Assert.Catch(() => pq.Top());
Console.WriteLine("Expected: {0}", ex1.Message);
var ex2 = Assert.Catch(() => pq.Pop());
Console.WriteLine("Expected: {0}", ex2.Message);
// With capacity zero, all additions immediately overflow:
Assert.AreEqual('z', pq.AddWithOverflow('z'));
Assert.AreEqual('a', pq.AddWithOverflow('a'));
var ex3 = Assert.Catch(() => pq.Add('b'));
Console.WriteLine("Expected: {0}", ex3.Message);
}
public void CanEnumerateFixedEmptyQueue()
{
var pq = new TestPriorityQueue <char>(0); // fixed capacity
var enumerator = pq.GetEnumerator();
Assert.Empty(Iterate(enumerator));
pq.AddWithOverflow('x');
Assert.Equal(0, pq.Count); // still empty
enumerator.Reset();
Assert.Empty(Iterate(enumerator));
enumerator.Dispose();
}
public void CanEnumerateFixedEmptyQueue()
{
// ReSharper disable once CollectionNeverUpdated.Local
var pq = new TestPriorityQueue <char>(0); // fixed capacity
var enumerator = pq.GetEnumerator();
IterateEmpty(enumerator);
pq.AddWithOverflow('x');
Assert.AreEqual(0, pq.Count); // still empty
enumerator.Reset();
IterateEmpty(enumerator);
enumerator.Dispose();
}
public void CannotEnumerateChangingQueue()
{
const string items = "hello";
var pq = new TestPriorityQueue <char>(items.Length + 1);
foreach (var c in items)
{
pq.Add(c);
}
var iter = pq.GetEnumerator();
Assert.True(iter.MoveNext());
pq.Add('x'); // modify (will fill up capacity)
var ex1 = Assert.Catch <InvalidOperationException>(() => iter.MoveNext());
Console.WriteLine("Expected after Add: {0}", ex1.Message);
iter.Reset();
Assert.True(iter.MoveNext());
pq.AddWithOverflow('y'); // modify (will overflow)
var ex2 = Assert.Catch <InvalidOperationException>(() => iter.MoveNext());
Console.WriteLine("Expected after AddWithOverflow: {0}", ex2.Message);
iter.Reset();
Assert.True(iter.MoveNext());
pq.Pop(); // modify
var ex3 = Assert.Catch <InvalidOperationException>(() => iter.MoveNext());
Console.WriteLine("Expected after Pop: {0}", ex3.Message);
iter.Reset();
Assert.True(iter.MoveNext());
pq.Clear(); // modify
var ex4 = Assert.Catch <InvalidOperationException>(() => iter.MoveNext());
Console.WriteLine("Expected after Clear: {0}", ex4.Message);
iter.Dispose();
}
public void CannotEnumerateChangingQueue()
{
const string items = "hello";
var pq = new TestPriorityQueue <char>(items.Length + 1);
foreach (var c in items)
{
pq.Add(c);
}
var iter = pq.GetEnumerator();
Assert.True(iter.MoveNext());
pq.Add('x'); // modify (will fill up capacity)
Assert.Throws <InvalidOperationException>(() => iter.MoveNext());
iter.Reset();
Assert.True(iter.MoveNext());
pq.AddWithOverflow('y'); // modify (will overflow)
Assert.Throws <InvalidOperationException>(() => iter.MoveNext());
iter.Reset();
Assert.True(iter.MoveNext());
pq.Pop(); // modify
Assert.Throws <InvalidOperationException>(() => iter.MoveNext());
iter.Reset();
Assert.True(iter.MoveNext());
pq.Clear(); // modify
Assert.Throws <InvalidOperationException>(() => iter.MoveNext());
iter.Dispose();
}
