public void Queue_Generic_EnqueueAndDequeue(int capacity, int items)
{
int seed = 53134;
var q = new PooledQueue <T>(capacity);
RegisterForDispose(q);
Assert.Equal(0, q.Count);
// Enqueue some values and make sure the count is correct
List <T> source = (List <T>)CreateEnumerable(EnumerableType.List, null, items, 0, 0);
foreach (T val in source)
{
q.Enqueue(val);
}
Assert.Equal(source, q);
// Dequeue to make sure the values are removed in the right order and the count is updated
for (int i = 0; i < items; i++)
{
T itemToRemove = source[0];
source.RemoveAt(0);
Assert.Equal(itemToRemove, q.Dequeue());
Assert.Equal(items - i - 1, q.Count);
}
// Can't dequeue when empty
Assert.Throws <InvalidOperationException>(() => q.Dequeue());
// But can still be used after a failure and after bouncing at empty
T itemToAdd = CreateT(seed++);
q.Enqueue(itemToAdd);
Assert.Equal(itemToAdd, q.Dequeue());
}
public void TestAllocateThenPopTwice()
{
var queue = new PooledQueue <int>();
var span1 = queue.AllocateRight(2);
span1[0] = 0;
span1[1] = 1;
Assert.Equal(0, queue.PopLeft());
Assert.Equal(1, queue.PopLeft());
var span2 = queue.AllocateRight(2);
span2[0] = 2;
span2[1] = 3;
Assert.Equal(2, queue.PopLeft());
Assert.Equal(3, queue.PopLeft());
queue.Dispose();
}
/// <summary>
/// Yields all of the nodes in the tree represented by <paramref name="value"/> in a breadth-first traversal order.
///
/// <para>
/// This is a breadth-first pre-order traversal.
/// </para>
///
/// </summary>
/// <typeparam name="T">The rewritable tree type</typeparam>
/// <param name="rewriter">The rewriter</param>
/// <param name="value">The value to traverse</param>
/// <returns>An enumerable containing all of the nodes in the tree represented by <paramref name="value"/> in a breadth-first traversal order.</returns>
public static IEnumerable <T> SelfAndDescendantsBreadthFirst <T>(this IRewriter <T> rewriter, T value)
{
if (rewriter == null)
{
throw new ArgumentNullException(nameof(rewriter));
}
IEnumerable <T> Iterator()
{
var queue = new PooledQueue <T>();
queue.AllocateRight(1)[0] = value;
try
{
while (queue.Count != 0)
{
var x = queue.PopLeft();
yield return(x);
var count = rewriter.CountChildren(x);
var span = queue.AllocateRight(count);
rewriter.GetChildren(span, x);
}
}
finally
{
queue.Dispose();
}
}
return(Iterator());
}
public void Queue_Generic_Constructor_IEnumerable(EnumerableType enumerableType, int setLength, int enumerableLength, int numberOfMatchingElements, int numberOfDuplicateElements)
{
IEnumerable <T> enumerable = CreateEnumerable(enumerableType, null, enumerableLength, 0, numberOfDuplicateElements);
PooledQueue <T> queue = new PooledQueue <T>(enumerable);
RegisterForDispose(queue);
Assert.Equal(enumerable, queue);
}
public void Queue_Generic_Constructor_int(int count)
{
PooledQueue <T> queue = new PooledQueue <T>(count);
RegisterForDispose(queue);
Assert.Equal(Array.Empty <T>(), queue.ToArray());
queue.Clear();
Assert.Equal(Array.Empty <T>(), queue.ToArray());
}
public void Queue_Generic_ToArray_NonWrappedQueue(int count)
{
PooledQueue <T> collection = new PooledQueue <T>(count + 1);
RegisterForDispose(collection);
AddToCollection(collection, count);
T[] elements = collection.ToArray();
elements.Reverse();
Assert.True(Enumerable.SequenceEqual(elements, collection.ToArray <T>()));
}
public void Queue_Generic_TrimExcess_Repeatedly(int count)
{
PooledQueue <T> queue = GenericQueueFactory(count);;
List <T> expected = queue.ToList();
queue.TrimExcess();
queue.TrimExcess();
queue.TrimExcess();
Assert.True(queue.SequenceEqual(expected));
}
public void Queue_Generic_Dequeue_AllElements(int count)
{
PooledQueue <T> queue = GenericQueueFactory(count);
List <T> elements = queue.ToList();
foreach (T element in elements)
{
Assert.Equal(element, queue.Dequeue());
}
}
public void Queue_Generic_TryDequeue_AllElements(int count)
{
PooledQueue <T> queue = GenericQueueFactory(count);
List <T> elements = queue.ToList();
foreach (T element in elements)
{
Assert.True(queue.TryDequeue(out T result));
Assert.Equal(element, result);
}
}
protected static PooledQueue <int> CreatePooled(int size)
{
var rand = new Random(RAND_SEED);
var queue = new PooledQueue <int>(size);
for (int i = 0; i < size; i++)
{
queue.Enqueue(rand.Next());
}
return(queue);
}
public void IterationSetup()
{
if (Type == QueueType.Int)
{
intQueue = new Queue <int>(numbers);
intPooled = new PooledQueue <int>(numbers);
}
else
{
stringQueue = new Queue <string>(strings);
stringPooled = new PooledQueue <string>(strings);
}
}
public void TrimExcess(int items, int capacity)
{
var q = new PooledQueue <int>(capacity);
RegisterForDispose(q);
for (int i = 0; i < items; i++)
{
q.Enqueue(i);
}
q.TrimExcess();
Assert.Equal(items, q.Count);
Assert.Equal(Enumerable.Range(0, items), q);
}
protected PooledQueue <T> GenericQueueFactory(int count)
{
PooledQueue <T> queue = new PooledQueue <T>(count);
RegisterForDispose(queue);
int seed = count * 34;
for (int i = 0; i < count; i++)
{
queue.Enqueue(CreateT(seed++));
}
return(queue);
}
public void Queue_Generic_TrimExcess_AfterRemovingOneElement(int count)
{
if (count > 0)
{
PooledQueue <T> queue = GenericQueueFactory(count);;
List <T> expected = queue.ToList();
queue.TrimExcess();
T removed = queue.Dequeue();
expected.Remove(removed);
queue.TrimExcess();
Assert.True(queue.SequenceEqual(expected));
}
}
public void TestOverfillBuffer()
{
var queue = new PooledQueue <int>();
var span1 = queue.AllocateRight(513);
span1.Fill(1);
for (var i = 0; i < 513; i++)
{
Assert.Equal(1, queue.PopLeft());
}
queue.Dispose();
}
public void Clear_Wrapped(bool initializeFromCollection)
{
// Try to exercise special case of clearing when we've wrapped around
PooledQueue <string> q = CreateQueueAtCapacity(initializeFromCollection, i => i.ToString(), size: 4);
Assert.Equal("0", q.Dequeue());
Assert.Equal("1", q.Dequeue());
q.Enqueue("5");
q.Enqueue("6");
Assert.Equal(4, q.Count);
q.Clear();
Assert.Equal(0, q.Count);
Assert.False(q.GetEnumerator().MoveNext());
}
public void Peek()
{
var q = new PooledQueue <int>();
RegisterForDispose(q);
Assert.Throws <InvalidOperationException>(() => q.Peek());
q.Enqueue(1);
Assert.Equal(1, q.Peek());
q.Enqueue(2);
Assert.Equal(1, q.Peek());
Assert.Equal(1, q.Dequeue());
Assert.Equal(2, q.Peek());
Assert.Equal(2, q.Dequeue());
}
public void Queue_Generic_TrimExcess_AfterClearingAndAddingAllElementsBack(int count)
{
if (count > 0)
{
PooledQueue <T> queue = GenericQueueFactory(count);;
queue.TrimExcess();
queue.Clear();
queue.TrimExcess();
Assert.Equal(0, queue.Count);
AddToCollection(queue, count);
queue.TrimExcess();
Assert.Equal(count, queue.Count);
}
}
public void TestAllocateThenPop()
{
var queue = new PooledQueue <int>();
var span = queue.AllocateRight(3);
span[0] = 0;
span[1] = 1;
span[2] = 2;
Assert.Equal(0, queue.PopLeft());
Assert.Equal(1, queue.PopLeft());
Assert.Equal(2, queue.PopLeft());
queue.Dispose();
}
public void GlobalSetup()
{
if (EmptyQueue)
{
intQueue = new Queue <int>();
stringQueue = new Queue <string>();
intPooled = new PooledQueue <int>();
stringPooled = new PooledQueue <string>();
}
numbers = CreateArray(N);
if (Type == QueueType.String)
{
strings = Array.ConvertAll(numbers, x => x.ToString());
}
}
public void ToArray_Wrapped(bool initializeFromCollection)
{
// Create a queue whose head has wrapped around
PooledQueue <string> q = CreateQueueAtCapacity(initializeFromCollection, i => i.ToString(), size: 4);
Assert.Equal("0", q.Dequeue());
Assert.Equal("1", q.Dequeue());
q.Enqueue("4");
q.Enqueue("5");
Assert.Equal(4, q.Count);
string[] arr = q.ToArray();
for (int i = 0; i < 4; i++)
{
Assert.Equal("" + (i + 2), arr[i]);
}
}
private static void PooledQueue_Simple_Impl(QueuePool <string> pool)
{
for (var i = 0; i < 100; i++)
{
using var obj = i % 2 == 0 ? pool.New() : PooledQueue <string> .New(pool);
var queue = obj.Queue;
Assert.AreEqual(0, queue.Count);
queue.Enqueue("qux");
queue.Enqueue("foo");
queue.Enqueue("bar");
queue.Enqueue("baz");
Assert.IsTrue(exp.SequenceEqual(queue));
}
}
public void PooledQueue_GetInstance()
{
for (var i = 0; i < 100; i++)
{
var queue = PooledQueue <string> .GetInstance();
Assert.AreEqual(0, queue.Count);
queue.Enqueue("qux");
queue.Enqueue("foo");
queue.Enqueue("bar");
queue.Enqueue("baz");
Assert.IsTrue(exp.SequenceEqual(queue));
queue.Free();
}
}
public void TestFillBufferThenContinueFilling()
{
var queue = new PooledQueue <int>();
var span1 = queue.AllocateRight(512);
span1.Fill(1);
var span2 = queue.AllocateRight(1);
span2.Fill(1);
for (var i = 0; i < 513; i++)
{
Assert.Equal(1, queue.PopLeft());
}
queue.Dispose();
}
public void PooledQueue_GlobalPool()
{
for (var i = 0; i < 100; i++)
{
using var obj = PooledQueue <string> .New();
var queue = obj.Queue;
Assert.AreEqual(0, queue.Count);
queue.Enqueue("qux");
queue.Enqueue("foo");
queue.Enqueue("bar");
queue.Enqueue("baz");
Assert.IsTrue(exp.SequenceEqual(queue));
}
}
/// <summary>
/// Helper function to create a Queue fulfilling the given specific parameters. The function will
/// create an Queue and then add values
/// to it until it is full. It will begin by adding the desired number of matching,
/// followed by random (deterministic) elements until the desired count is reached.
/// </summary>
protected IEnumerable<T> CreateQueue(IEnumerable<T> enumerableToMatchTo, int count, int numberOfMatchingElements, int numberOfDuplicateElements)
{
PooledQueue<T> queue = new PooledQueue<T>(count);
RegisterForDispose(queue);
int seed = 528;
int duplicateAdded = 0;
List<T> match = null;
// Enqueue Matching elements
if (enumerableToMatchTo != null)
{
match = enumerableToMatchTo.ToList();
for (int i = 0; i < numberOfMatchingElements; i++)
{
queue.Enqueue(match[i]);
while (duplicateAdded++ < numberOfDuplicateElements)
queue.Enqueue(match[i]);
}
}
// Enqueue elements to reach the desired count
while (queue.Count < count)
{
T toEnqueue = CreateT(seed++);
while (queue.Contains(toEnqueue) || (match != null && match.Contains(toEnqueue))) // Don't want any unexpectedly duplicate values
toEnqueue = CreateT(seed++);
queue.Enqueue(toEnqueue);
while (duplicateAdded++ < numberOfDuplicateElements)
queue.Enqueue(toEnqueue);
}
// Validate that the Enumerable fits the guidelines as expected
Debug.Assert(queue.Count == count);
if (match != null)
{
int actualMatchingCount = 0;
foreach (T lookingFor in match)
actualMatchingCount += queue.Contains(lookingFor) ? 1 : 0;
Assert.Equal(numberOfMatchingElements, actualMatchingCount);
}
return queue;
}
public void ICollection_CopyTo_Wrapped(bool initializeFromCollection)
{
// Create a queue whose head has wrapped around
PooledQueue <int> q = CreateQueueAtCapacity(initializeFromCollection, i => i, size: 4);
Assert.Equal(0, q.Dequeue());
Assert.Equal(1, q.Dequeue());
Assert.Equal(2, q.Count);
q.Enqueue(4);
q.Enqueue(5);
Assert.Equal(4, q.Count);
// Now copy; should require two copies under the covers
int[] arr = new int[4];
((ICollection)q).CopyTo(arr, 0);
for (int i = 0; i < 4; i++)
{
Assert.Equal(i + 2, arr[i]);
}
}
public void PooledEnqueue()
{
if (Type == QueueType.Int)
{
var queue = new PooledQueue <int>();
for (int i = 0; i < N; i++)
{
queue.Enqueue(intArray[i]);
}
queue.Dispose();
}
else
{
var queue = new PooledQueue <string>();
for (int i = 0; i < N; i++)
{
queue.Enqueue(stringArray[i]);
}
queue.Dispose();
}
}
public void PooledIEnumerableConstructor()
{
if (Type == QueueType.Int)
{
PooledQueue <int> queue;
for (int i = 0; i < 1000; i++)
{
queue = new PooledQueue <int>(IntEnumerable());
queue.Dispose();
}
}
else
{
PooledQueue <string> queue;
for (int i = 0; i < 1000; i++)
{
queue = new PooledQueue <string>(StringEnumerable());
queue.Dispose();
}
}
}
public void PooledICollectionConstructor()
{
if (Type == QueueType.Int)
{
PooledQueue <int> queue;
for (int i = 0; i < 1000; i++)
{
queue = new PooledQueue <int>(intList);
queue.Dispose();
}
}
else
{
PooledQueue <string> queue;
for (int i = 0; i < 1000; i++)
{
queue = new PooledQueue <string>(stringList);
queue.Dispose();
}
}
}