public void GetEnumerator_AtCapacityAndItemEnqueuedWhilstIterating_IterationCountNeverExceedsCapacity() { List <int> initialValues = Enumerable.Range(1, Random.Next(10, 10000)).Select(n => Random.Next()).ToList(); long capacity = initialValues.Count; CyclicConcurrentQueue <int> cyclicConcurrentQueue = CreateCyclicConcurrentQueue(initialValues, capacity); List <int> iterationResult = new List <int>(); List <int> enqueuedValues = Enumerable.Range(1, Random.Next(1, 100)).Select(n => Random.Next()).ToList(); using (IEnumerator <int> enumerator = cyclicConcurrentQueue.GetEnumerator()) { //Start iterating a single time enumerator.MoveNext(); iterationResult.Add(enumerator.Current); //Add extra values foreach (int enqueuedValue in enqueuedValues) { cyclicConcurrentQueue.Enqueue(enqueuedValue); } //Finish iterating while (enumerator.MoveNext()) { iterationResult.Add(enumerator.Current); } } Assert.IsTrue( capacity >= iterationResult.Count, "Iteration count ({0}) should always be smaller than the capacity ({1})", iterationResult.Count, capacity); }
public void Count_OneEntryAddedUsingEnqueue_IsOne() { long capacity = Random.Next(10, MaxCapacity); CyclicConcurrentQueue <bool> cyclicConcurrentQueue = CreateCyclicConcurrentQueue <bool>(capacity); cyclicConcurrentQueue.Enqueue(Random.NextDouble() < 0.5); Assert.AreEqual(1, cyclicConcurrentQueue.Count()); }
public void TryDequeue_SomethingQueued_OutputsLeastRecentlyEnqueuedItem() { long capacity = Random.Next(10, MaxCapacity); IEnumerable <int> enqueuedItems = Enumerable.Range(1, Random.Next(2, (int)capacity - 1)).Select(n => Random.Next()); CyclicConcurrentQueue <int> cyclicConcurrentQueue = CreateCyclicConcurrentQueue <int>(capacity); int firstItem = Random.Next(); cyclicConcurrentQueue.Enqueue(firstItem); foreach (int enqueuedItem in enqueuedItems) { cyclicConcurrentQueue.Enqueue(enqueuedItem); } int dequeued; cyclicConcurrentQueue.TryDequeue(out dequeued); Assert.AreEqual(firstItem, dequeued); }
public void TryPeek_ItemsQueued_OutputsLeastRecentlyEnqueuedItem() { long capacity = Random.Next(10, MaxCapacity); //Note: Using random choice for each number takes too long IEnumerable <int> enqueuedItems = Enumerable.Range(1, Random.Next(2, (int)capacity - 1)); //.Select(n=>Random.Next()); CyclicConcurrentQueue <int> cyclicConcurrentQueue = CreateCyclicConcurrentQueue <int>(capacity); int firstItem = Random.Next(); cyclicConcurrentQueue.Enqueue(firstItem); foreach (int enqueuedItem in enqueuedItems) { cyclicConcurrentQueue.Enqueue(enqueuedItem); } int peeked; cyclicConcurrentQueue.TryPeek(out peeked); Assert.AreEqual(firstItem, peeked); }
public void TryPeek_SomethingQueued_ReturnsTrue() { long capacity = Random.Next(10, MaxCapacity); CyclicConcurrentQueue <int> cyclicConcurrentQueue = CreateCyclicConcurrentQueue <int>(capacity); cyclicConcurrentQueue.Enqueue(Random.Next()); int peeked; Assert.IsTrue(cyclicConcurrentQueue.TryPeek(out peeked)); }
public void Count_MoreAddedUsingEnqueueThanCapacityHolds_IsSameAsCapacity() { long capacity = Random.Next(10, 10000); int overlap = Random.Next(1, 9); CyclicConcurrentQueue <int> cyclicConcurrentQueue = CreateCyclicConcurrentQueue <int>(capacity); for (int i = 0; i < capacity + overlap; i++) { cyclicConcurrentQueue.Enqueue(Random.Next()); } Assert.AreEqual(capacity, cyclicConcurrentQueue.Count()); }
public void Count_MultipleEntriesAddedUsingEnqueue_IsOne() { long capacity = Random.Next(10, MaxCapacity); int count = Random.Next(2, capacity > 10000 ? 10000 : (int)capacity); CyclicConcurrentQueue <bool> cyclicConcurrentQueue = CreateCyclicConcurrentQueue <bool>(capacity); for (int i = 0; i < count; i++) { cyclicConcurrentQueue.Enqueue(Random.NextDouble() < 0.5); } Assert.AreEqual(count, cyclicConcurrentQueue.Count()); }
public void TryPeek_SomethingQueued_OutputsSameValueWhenCalledTwice() { long capacity = Random.Next(10, MaxCapacity); int enqueued = Random.Next(); CyclicConcurrentQueue <int> cyclicConcurrentQueue = CreateCyclicConcurrentQueue <int>(capacity); cyclicConcurrentQueue.Enqueue(enqueued); int peeked1, peeked2; cyclicConcurrentQueue.TryPeek(out peeked1); cyclicConcurrentQueue.TryPeek(out peeked2); Assert.AreEqual(peeked1, peeked2); }
public void ToList_ItemsEnqueuedToExceedCapacity_EarlierValuesOverridenWhenPastCapacity() { List <int> values = Enumerable.Range(1, Random.Next(100, 1000)).Select(n => Random.Next()).ToList(); long capacity = Random.Next(20, values.Count / 2); CyclicConcurrentQueue <int> cyclicConcurrentQueue = CreateCyclicConcurrentQueue <int>(capacity); foreach (int value in values) { cyclicConcurrentQueue.Enqueue(value); } List <int> expectedValues = values.Skip(values.Count - (int)capacity).ToList(); CollectionAssert.AreEqual(expectedValues, cyclicConcurrentQueue.ToList()); }
public void ToList_InitialCollectionAndItemsEnqueuedWithinCapacity_MatchesInitialCollectionAndExtraItemAtEnd() { List <int> initialValues = Enumerable.Range(1, Random.Next(10, 100)).Select(n => Random.Next()).ToList(); List <int> addedValues = Enumerable.Range(1, Random.Next(10, 100)).Select(n => Random.Next()).ToList(); long capacity = initialValues.Count + addedValues.Count + Random.Next(1, 100); CyclicConcurrentQueue <int> cyclicConcurrentQueue = CreateCyclicConcurrentQueue(initialValues, capacity); foreach (int addedValue in addedValues) { cyclicConcurrentQueue.Enqueue(addedValue); } List <int> expectedValues = initialValues.Concat(addedValues).ToList(); CollectionAssert.AreEqual(expectedValues, cyclicConcurrentQueue.ToList()); }
public void TryDequeue_SomethingQueuedThenDequeuedAlready_ReturnsFalse() { long capacity = Random.Next(10, MaxCapacity); CyclicConcurrentQueue <int> cyclicConcurrentQueue = CreateCyclicConcurrentQueue <int>(capacity); cyclicConcurrentQueue.Enqueue(Random.Next()); int dequeued; // Remove the enqueued item, and mark the test inconclusive if it fails if (!cyclicConcurrentQueue.TryDequeue(out dequeued)) { Assert.Inconclusive("Could not successfully dequeue an item."); } // We should now have and empty queue again. Assert.IsFalse(cyclicConcurrentQueue.TryDequeue(out dequeued)); }
public void GetEnumerator_ItemEnqueuedAfterGetAndBeforeIterating_EnqueuedValueIncludedInIteration() { List <int> initialValues = Enumerable.Range(1, Random.Next(10, 10000)).Select(n => Random.Next()).ToList(); long capacity = Random.Next(10, MaxCapacity); CyclicConcurrentQueue <int> cyclicConcurrentQueue = CreateCyclicConcurrentQueue(initialValues, capacity); List <int> iterationResult = new List <int>(); int enqueued = Random.Next(); using (IEnumerator <int> enumerator = cyclicConcurrentQueue.GetEnumerator()) { cyclicConcurrentQueue.Enqueue(enqueued); while (enumerator.MoveNext()) { iterationResult.Add(enumerator.Current); } } Assert.AreEqual(enqueued, iterationResult.Last()); }
ToList_ItemsEnqueuedToExceedCapacityThenItemsDequeued_EarlierValuesOverridenWhenPastCapacityThenQueueShortenedOnDequeue () { List <int> values = Enumerable.Range(1, Random.Next(100, 1000)).Select(n => Random.Next()).ToList(); long capacity = Random.Next(20, values.Count / 2); int amountToDequeue = Random.Next(1, (int)capacity / 2); CyclicConcurrentQueue <int> cyclicConcurrentQueue = CreateCyclicConcurrentQueue <int>(capacity); foreach (int value in values) { cyclicConcurrentQueue.Enqueue(value); } for (int i = 0; i < amountToDequeue; i++) { int dequeued; Assert.IsTrue( cyclicConcurrentQueue.TryDequeue(out dequeued), "This test should always succeed when attempting to Dequeue elements."); } List <int> expectedValues = values.Skip(values.Count - (int)capacity).Skip(amountToDequeue).ToList(); CollectionAssert.AreEqual(expectedValues, cyclicConcurrentQueue.ToList()); }