protected PooledStack <T> GenericStackFactory()
{
var stack = new PooledStack <T>();
RegisterForDispose(stack);
return(stack);
}
protected override ICollection NonGenericICollectionFactory()
{
var stack = new PooledStack <string>();
RegisterForDispose(stack);
return(stack);
}
public void Stack_Generic_Constructor_int(int count)
{
PooledStack <T> stack = new PooledStack <T>(count);
RegisterForDispose(stack);
Assert.Equal(Array.Empty <T>(), stack.ToArray());
}
public void Stack_Generic_Constructor_InitialValues()
{
var stack = new PooledStack <T>();
Assert.Equal(0, stack.Count);
Assert.Equal(0, stack.ToArray().Length);
Assert.NotNull(((ICollection)stack).SyncRoot);
}
public void Stack_Generic_Constructor_IEnumerable(EnumerableType enumerableType, int setLength, int enumerableLength, int numberOfMatchingElements, int numberOfDuplicateElements)
{
IEnumerable <T> enumerable = CreateEnumerable(enumerableType, null, enumerableLength, 0, numberOfDuplicateElements);
PooledStack <T> stack = new PooledStack <T>(enumerable);
RegisterForDispose(stack);
Assert.Equal(enumerable.ToArray().Reverse(), stack.ToArray());
}
public void Stack_Generic_TrimExcess_Repeatedly(int count)
{
PooledStack <T> stack = GenericStackFactory(count);
List <T> expected = stack.ToList();
stack.TrimExcess();
stack.TrimExcess();
stack.TrimExcess();
Assert.Equal(expected, stack);
}
public void Stack_Generic_Pop_AllElements(int count)
{
PooledStack <T> stack = GenericStackFactory(count);
List <T> elements = stack.ToList();
foreach (T element in elements)
{
Assert.Equal(element, stack.Pop());
}
}
protected static PooledStack <int> CreatePooled(int size)
{
var rand = new Random(RAND_SEED);
var stack = new PooledStack <int>(size);
for (int i = 0; i < size; i++)
{
stack.Push(rand.Next());
}
return(stack);
}
public HitTestEnumerator(IVisualNode root, Func <IVisual, bool>?filter, Point point, IVisualNode sceneRoot)
{
_nodeStack = new PooledStack <Entry>();
_nodeStack.Push(new Entry(root, false, null, true));
_filter = filter;
_point = point;
_sceneRoot = sceneRoot;
_current = null;
}
public void Stack_Generic_RemoveWhere(int count)
{
PooledStack <T> stack = GenericStackFactory(count);
var startingCount = stack.Count;
var expected = stack.Where(x => !RemoveWherePredicate(x)).ToPooledList();
stack.RemoveWhere(RemoveWherePredicate);
Assert.Equal(expected.Count, stack.Count);
Assert.Equal(expected, stack);
expected.Dispose();
}
public void Stack_Generic_TryPop_AllElements(int count)
{
PooledStack <T> stack = GenericStackFactory(count);
List <T> elements = stack.ToList();
foreach (T element in elements)
{
Assert.True(stack.TryPop(out T result));
Assert.Equal(element, result);
}
}
public void IterationSetup()
{
if (Type == StackType.Int)
{
intStack = new Stack <int>(numbers);
intPooled = new PooledStack <int>(numbers);
}
else
{
stringStack = new Stack <string>(strings);
stringPooled = new PooledStack <string>(strings);
}
}
protected PooledStack <T> GenericStackFactory(int count)
{
PooledStack <T> stack = new PooledStack <T>(count);
RegisterForDispose(stack);
int seed = count * 34;
for (int i = 0; i < count; i++)
{
stack.Push(CreateT(seed++));
}
return(stack);
}
public void Stack_Generic_TrimExcess_AfterClearingAndAddingAllElementsBack(int count)
{
if (count > 0)
{
PooledStack <T> stack = GenericStackFactory(count);
stack.TrimExcess();
stack.Clear();
stack.TrimExcess();
Assert.Equal(0, stack.Count);
AddToCollection(stack, count);
stack.TrimExcess();
Assert.Equal(count, stack.Count);
}
}
public void Stack_Generic_TrimExcess_AfterRemovingOneElement(int count)
{
if (count > 0)
{
PooledStack <T> stack = GenericStackFactory(count);
List <T> expected = stack.ToList();
T elementToRemove = stack.ElementAt(0);
stack.TrimExcess();
stack.Pop();
expected.RemoveAt(0);
stack.TrimExcess();
Assert.Equal(expected, stack);
}
}
public void GlobalSetup()
{
if (EmptyStack)
{
intStack = new Stack <int>();
stringStack = new Stack <string>();
intPooled = new PooledStack <int>();
stringPooled = new PooledStack <string>();
}
numbers = CreateArray(N);
if (Type == StackType.String)
{
strings = Array.ConvertAll(numbers, x => x.ToString());
}
}
private static void PooledStack_Simple_Impl(StackPool <string> pool)
{
for (var i = 0; i < 100; i++)
{
using var obj = i % 2 == 0 ? pool.New() : PooledStack <string> .New(pool);
var stack = obj.Stack;
Assert.AreEqual(0, stack.Count);
stack.Push("qux");
stack.Push("foo");
stack.Push("bar");
stack.Push("baz");
Assert.IsTrue(exp.SequenceEqual(stack));
}
}
public void PooledStack_GlobalPool()
{
for (var i = 0; i < 100; i++)
{
using var obj = PooledStack <string> .New();
var stack = obj.Stack;
Assert.AreEqual(0, stack.Count);
stack.Push("qux");
stack.Push("foo");
stack.Push("bar");
stack.Push("baz");
Assert.IsTrue(exp.SequenceEqual(stack));
}
}
public void PooledStack_GetInstance()
{
for (var i = 0; i < 100; i++)
{
var stack = PooledStack <string> .GetInstance();
Assert.AreEqual(0, stack.Count);
stack.Push("qux");
stack.Push("foo");
stack.Push("bar");
stack.Push("baz");
Assert.IsTrue(exp.SequenceEqual(stack));
stack.Free();
}
}
public void PooledICollectionConstructor()
{
if (Type == StackType.Int)
{
PooledStack <int> stack;
for (int i = 0; i < 1000; i++)
{
stack = new PooledStack <int>(intList);
stack.Dispose();
}
}
else
{
PooledStack <string> stack;
for (int i = 0; i < 1000; i++)
{
stack = new PooledStack <string>(stringList);
stack.Dispose();
}
}
}
public void PooledPush()
{
if (Type == StackType.Int)
{
var stack = new PooledStack <int>();
for (int i = 0; i < N; i++)
{
stack.Push(intArray[i]);
}
stack.Dispose();
}
else
{
var stack = new PooledStack <string>();
for (int i = 0; i < N; i++)
{
stack.Push(stringArray[i]);
}
stack.Dispose();
}
}
public void PooledIEnumerableConstructor()
{
if (Type == StackType.Int)
{
PooledStack <int> stack;
for (int i = 0; i < 1000; i++)
{
stack = new PooledStack <int>(IntEnumerable());
stack.Dispose();
}
}
else
{
PooledStack <string> stack;
for (int i = 0; i < 1000; i++)
{
stack = new PooledStack <string>(StringEnumerable());
stack.Dispose();
}
}
}
public void PooledStack_GottenTooBig()
{
var bigPool = StackPool <int> .Create(1, 16, 2048);
var smallPool = StackPool <int> .Create(1, 16, 16);
TooBig(() => PooledStack <int> .New(), h => h.Stack, (h, n) => { for (var i = 0; i < n; i++)
{
h.Push(i);
}
}, 1024);
TooBig(() => bigPool.New(), h => h.Stack, (h, n) => { for (var i = 0; i < n; i++)
{
h.Push(i);
}
}, 2048);
TooBig(() => smallPool.New(), h => h.Stack, (h, n) => { for (var i = 0; i < n; i++)
{
h.Push(i);
}
}, 16);
}
public void Stack_Generic_TrimExcess_OnValidStackThatHasntBeenRemovedFrom(int count)
{
PooledStack <T> stack = GenericStackFactory(count);
stack.TrimExcess();
}
public void Stack_Generic_ToArray(int count)
{
PooledStack <T> stack = GenericStackFactory(count);
Assert.Equal(Enumerable.ToArray(stack), stack.ToArray());
}
