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