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