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_NoInitialCollection_IsZero()
{
long capacity = Random.Next(10, MaxCapacity);
CyclicConcurrentQueue <bool> cyclicConcurrentQueue = CreateCyclicConcurrentQueue <bool>(capacity);
Assert.AreEqual(0, cyclicConcurrentQueue.Count());
}
/// <summary>
/// Initializes a new instance of the <see cref="ScheduledAction" /> class.
/// </summary>
/// <param name="schedule">The schedule.</param>
/// <param name="maximumHistory">The maximum history.</param>
/// <param name="maximumDuration">The maximum duration.</param>
/// <param name="returnType">Type of the return (if a function).</param>
protected ScheduledAction(
[NotNull] ISchedule schedule,
int maximumHistory,
Duration maximumDuration,
[CanBeNull] Type returnType)
{
if (schedule == null)
{
throw new ArgumentNullException("schedule");
}
if (maximumHistory <= 0)
{
throw new ArgumentOutOfRangeException("maximumHistory");
}
_enabled = 1;
LastExecutionFinished = Instant.MinValue;
_schedule = schedule;
MaximumHistory = maximumHistory;
ReturnType = returnType;
HistoryQueue = new CyclicConcurrentQueue <ScheduledActionResult>(MaximumHistory);
int md;
unchecked
{
md = (int)(maximumDuration.Ticks / NodaConstants.TicksPerMillisecond);
}
MaximumDurationMs = md < 0 ? 0 : md;
}
public void ToArray_InitialCollectionSmallerThanCapacity_MatchesInitialCollection()
{
List <Guid> initialValues = Enumerable.Range(1, Random.Next(10, 100)).Select(n => Guid.NewGuid()).ToList();
long capacity = initialValues.Count + (long)(Random.NextDouble() * (MaxCapacity - initialValues.Count));
CyclicConcurrentQueue <Guid> cyclicConcurrentQueue = CreateCyclicConcurrentQueue(initialValues, capacity);
CollectionAssert.AreEqual(initialValues.ToArray(), cyclicConcurrentQueue.ToArray());
}
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 TryPeek_NothingQueued_ReturnsFalse()
{
long capacity = Random.Next(10, MaxCapacity);
CyclicConcurrentQueue <int> cyclicConcurrentQueue = CreateCyclicConcurrentQueue <int>(capacity);
int peeked;
Assert.IsFalse(cyclicConcurrentQueue.TryPeek(out peeked));
}
public void Enqueue_CalledInParallel_AllValuesAdded()
{
List <int> values = Enumerable.Range(1, Random.Next(10, 10000)).Select(n => Random.Next()).ToList();
long capacity = values.Count + Random.Next(1, 1000);
CyclicConcurrentQueue <int> cyclicConcurrentQueue = CreateCyclicConcurrentQueue <int>(capacity);
Parallel.ForEach(values, cyclicConcurrentQueue.Enqueue);
CollectionAssert.AreEquivalent(values, cyclicConcurrentQueue);
}
public void ToArray_InitialCollectionLargerThanCapacity_MatchesEndPortionOfInitialCollection()
{
List <Guid> initialValues = Enumerable.Range(1, Random.Next(10, 100)).Select(n => Guid.NewGuid()).ToList();
long capacity = Random.Next(5, initialValues.Count);
CyclicConcurrentQueue <Guid> cyclicConcurrentQueue = CreateCyclicConcurrentQueue(initialValues, capacity);
CollectionAssert.AreEqual(
initialValues.Skip(initialValues.Count - (int)capacity).ToArray(),
cyclicConcurrentQueue.ToArray());
}
public void TryDequeue_SomethingQueued_ReturnsTrue()
{
long capacity = Random.Next(10, MaxCapacity);
CyclicConcurrentQueue <int> cyclicConcurrentQueue = CreateCyclicConcurrentQueue <int>(capacity);
cyclicConcurrentQueue.Enqueue(Random.Next());
int dequeued;
Assert.IsTrue(cyclicConcurrentQueue.TryDequeue(out dequeued));
}
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 Count_SomethingPeekedSuccessfully_ValueStaysTheSame()
{
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);
int previousCount = cyclicConcurrentQueue.Count();
int peeked;
if (cyclicConcurrentQueue.TryPeek(out peeked))
{
Assert.AreEqual(previousCount, cyclicConcurrentQueue.Count());
}
else
{
Assert.Inconclusive("Could not successfully peek at an item.");
}
}
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 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());
}
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 TryDequeue_CalledInParallelForEveryElement_AllValuesRemovedExactlyOnce()
{
List <Guid> values = Enumerable.Range(1, Random.Next(10, 10000)).Select(n => Guid.NewGuid()).ToList();
long capacity = values.Count + Random.Next(1, 1000);
CyclicConcurrentQueue <Guid> cyclicConcurrentQueue = CreateCyclicConcurrentQueue(values, capacity);
ConcurrentBag <Guid> dequeuedValues = new ConcurrentBag <Guid>();
Parallel.For(
0,
values.Count,
i =>
{
Guid value;
cyclicConcurrentQueue.TryDequeue(out value);
dequeuedValues.Add(value);
});
CollectionAssert.AreEquivalent(values, dequeuedValues);
Assert.AreEqual(0, cyclicConcurrentQueue.Count);
}
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());
}
public void Constructor_CapacityMaxLong_ThrowsArgumentOutOfRangeException()
{
CyclicConcurrentQueue <Guid> cyclicConcurrentQueue = CreateCyclicConcurrentQueue <Guid>(long.MaxValue);
}
public void Constructor_CapacityNegotive_ThrowsArgumentOutOfRangeException()
{
CyclicConcurrentQueue <Guid> cyclicConcurrentQueue = CreateCyclicConcurrentQueue <Guid>(-Random.Next());
}
public void Constructor_CapacityZero_ThrowsArgumentOutOfRangeException()
{
CyclicConcurrentQueue <Guid> cyclicConcurrentQueue = CreateCyclicConcurrentQueue <Guid>(0);
}
public void Constructor_CapacityAboveRange_ThrowsArgumentOutOfRangeException()
{
long invalidCapacity = CyclicConcurrentQueue <byte> .MaxCapacity + Random.Next();
CyclicConcurrentQueue <byte> cyclicConcurrentQueue = CreateCyclicConcurrentQueue <byte>(invalidCapacity);
}
