public void GetEnumerator()
{
// Create a new priority queue.
ConcurrentPriorityQueue <int> queue = new ConcurrentPriorityQueue <int>();
// Enqueue a few elements into the queue.
queue.Enqueue(1.0, 2);
queue.Enqueue(3.0, 6);
queue.Enqueue(2.0, 4);
// Use the enumerator of queue (using disposes it when we're finished).
using (IEnumerator <PriorityValuePair <int> > enumerator = queue.GetEnumerator())
{
// Expect the first element to have the highest priority, and expect MoveNext() to
// return true until the last element. After the end of the heap is reached, it
// then returns false.
// Note: Since the heap implementing the queue internally doesn't guarantee the
// order of elements after the first, we can only be certain of the root element
// and after that we really can't be sure of the order -- just the length.
Assert.That(enumerator.MoveNext(), Is.True);
Assert.That(enumerator.Current.Value, Is.EqualTo(6));
Assert.That(enumerator.MoveNext(), Is.True);
Assert.That(enumerator.MoveNext(), Is.True);
Assert.That(enumerator.MoveNext(), Is.False);
}
}
public void SingleThreadTiming()
{
const int count = 1000000;
var target = new ConcurrentPriorityQueue <string, int>(2);
var watcher = new Stopwatch();
watcher.Start();
for (int i = 0; i < count; i++)
{
target.Enqueue("a", 1);
}
watcher.Stop();
Assert.AreEqual(count, target.Count);
Console.WriteLine("Enqueue {0} elements: {1}", count, watcher.Elapsed);
watcher.Restart();
// ReSharper disable once UnusedVariable
var enumerator = target.GetEnumerator();
watcher.Stop();
Console.WriteLine("Get enumerator for {0} elements: {1}", count, watcher.Elapsed);
watcher.Restart();
for (int i = 0; i < count; i++)
{
target.Dequeue();
}
watcher.Stop();
Assert.AreEqual(0, target.Count);
Console.WriteLine("Dequeue {0} elements: {1}", count, watcher.Elapsed);
watcher.Start();
for (int i = 0; i < 2 * count; i++)
{
target.Enqueue("a", 1);
}
watcher.Stop();
Assert.AreEqual(2 * count, target.Count);
Console.WriteLine("Enqueue twice the capacity of {0} elements: {1}", count, watcher.Elapsed);
}
public void SingleThreadTiming()
{
const int count = 1000000;
var target = new ConcurrentPriorityQueue<int>(2);
var watcher = new Stopwatch();
watcher.Start();
for (int i = 0; i < count; i++)
{
target.Add(i);
}
watcher.Stop();
Assert.AreEqual(count, target.Count);
Console.WriteLine("Add {0} elements: {1}", count, watcher.Elapsed);
watcher.Restart();
// ReSharper disable once UnusedVariable
var enumerator = target.GetEnumerator();
watcher.Stop();
Console.WriteLine("Get enumerator for {0} elements: {1}", count, watcher.Elapsed);
watcher.Restart();
for (int i = 0; i < count; i++)
{
target.Take();
}
watcher.Stop();
Assert.AreEqual(0, target.Count);
Console.WriteLine("Take {0} elements: {1}", count, watcher.Elapsed);
watcher.Start();
for (int i = 0; i < 2 * count; i++)
{
target.Add(i);
}
watcher.Stop();
Assert.AreEqual(2 * count, target.Count);
Console.WriteLine("Add twice the capacity of {0} elements: {1}", count, watcher.Elapsed);
}
