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