public static PerformActionOnAllStackWrappers ( Stack stack, Action |
||
stack | Stack | |
action | Action |
|
return | void |
public static void TestGetEnumerator(int count) { Stack stack1 = Helpers.CreateIntStack(count); Helpers.PerformActionOnAllStackWrappers(stack1, stack2 => { IEnumerator enumerator1 = stack2.GetEnumerator(); IEnumerator enumerator2 = stack2.GetEnumerator(); IEnumerator[] enumerators = { enumerator1, enumerator2 }; foreach (IEnumerator enumerator in enumerators) { for (int i = 0; i < 2; i++) { int counter = 0; while (enumerator.MoveNext()) { counter++; Assert.NotNull(enumerator.Current); } Assert.Equal(count, counter); enumerator.Reset(); } } }); }
public static void Pop_EmptyStack_ThrowsInvalidOperationException() { var stack1 = new Stack(); Helpers.PerformActionOnAllStackWrappers(stack1, stack2 => { Assert.Throws <InvalidOperationException>(() => stack2.Pop()); // Empty stack }); }
public static void TestPop_Invalid() { var stack1 = new Stack(); Helpers.PerformActionOnAllStackWrappers(stack1, stack2 => { Assert.Throws <InvalidOperationException>(() => stack2.Pop()); }); }
public static void Clear() { Stack stack1 = Helpers.CreateIntStack(100); Helpers.PerformActionOnAllStackWrappers(stack1, stack2 => { stack2.Clear(); Assert.Equal(0, stack2.Count); stack2.Clear(); Assert.Equal(0, stack2.Count); }); }
public static void Pop(int pushCount, int popCount) { Stack stack1 = Helpers.CreateIntStack(pushCount); Helpers.PerformActionOnAllStackWrappers(stack1, stack2 => { for (int i = 0; i < popCount; i++) { Assert.Equal(pushCount - i - 1, stack2.Pop()); Assert.Equal(pushCount - i - 1, stack2.Count); } Assert.Equal(pushCount - popCount, stack2.Count); }); }
public static void Push(int count) { var stack1 = new Stack(); Helpers.PerformActionOnAllStackWrappers(stack1, stack2 => { for (int i = 0; i < count; i++) { stack2.Push(i); Assert.Equal(i + 1, stack2.Count); } Assert.Equal(count, stack2.Count); }); }
public static void Push_Null() { var stack1 = new Stack(); Helpers.PerformActionOnAllStackWrappers(stack1, stack2 => { stack2.Push(null); stack2.Push(-1); stack2.Push(null); Assert.True(stack2.Contains(null)); Assert.True(stack2.Contains(-1)); }); }
public static void CopyTo_Invalid() { Stack stack1 = Helpers.CreateIntStack(100); Helpers.PerformActionOnAllStackWrappers(stack1, stack2 => { AssertExtensions.Throws <ArgumentNullException>("array", () => stack2.CopyTo(null, 0)); // Array is null AssertExtensions.Throws <ArgumentException>("array", null, () => stack2.CopyTo(new object[10, 10], 0)); // Array is multidimensional AssertExtensions.Throws <ArgumentOutOfRangeException>("index", () => stack2.CopyTo(new object[100], -1)); // Index < 0 AssertExtensions.Throws <ArgumentException>(null, () => stack2.CopyTo(new object[0], 0)); // Index >= array.Count AssertExtensions.Throws <ArgumentException>(null, () => stack2.CopyTo(new object[100], 1)); // Index + array.Count > stack.Count AssertExtensions.Throws <ArgumentException>(null, () => stack2.CopyTo(new object[150], 51)); // Index + array.Count > stack.Count }); }
public static void CopyTo_IntArray(int count, int index) { Stack stack1 = Helpers.CreateIntStack(count); Helpers.PerformActionOnAllStackWrappers(stack1, stack2 => { int[] iArray = new int[index + count]; stack2.CopyTo(iArray, index); Assert.Equal(index + count, iArray.Length); for (int i = index; i < count; i++) { Assert.Equal(stack2.Pop(), iArray[i]); } }); }
public static void ToArray(int count) { Stack stack1 = Helpers.CreateIntStack(count); Helpers.PerformActionOnAllStackWrappers(stack1, stack2 => { object[] array = stack2.ToArray(); Assert.Equal(stack2.Count, array.Length); for (int i = 0; i < array.Length; i++) { Assert.Equal(stack2.Pop(), array[i]); } }); }
public static void Pop_Null() { var stack1 = new Stack(); Helpers.PerformActionOnAllStackWrappers(stack1, stack2 => { stack2.Push(null); stack2.Push(-1); stack2.Push(null); Assert.Null(stack2.Pop()); Assert.Equal(-1, stack2.Pop()); Assert.Null(stack2.Pop()); }); }
public static void Clone_IsShallowCopy() { var stack1 = new Stack(); stack1.Push(new Foo(10)); Helpers.PerformActionOnAllStackWrappers(stack1, stack2 => { Stack stackClone = (Stack)stack2.Clone(); Foo a1 = (Foo)stack2.Pop(); a1.IntValue = 50; Foo a2 = (Foo)stackClone.Pop(); Assert.Equal(50, a1.IntValue); }); }
public static void Clone(int count) { Stack stack1 = Helpers.CreateIntStack(count); Helpers.PerformActionOnAllStackWrappers(stack1, stack2 => { Stack stackClone = (Stack)stack2.Clone(); Assert.Equal(stack2.Count, stackClone.Count); Assert.Equal(stack2.IsSynchronized, stackClone.IsSynchronized); for (int i = 0; i < stackClone.Count; i++) { Assert.Equal(stack2.Pop(), stackClone.Pop()); } }); }
public static void Peek() { int count = 100; Stack stack1 = Helpers.CreateIntStack(count); Helpers.PerformActionOnAllStackWrappers(stack1, stack2 => { for (int i = 0; i < count; i++) { int peek1 = (int)stack2.Peek(); int peek2 = (int)stack2.Peek(); Assert.Equal(peek1, peek2); Assert.Equal(stack2.Pop(), peek1); Assert.Equal(count - i - 1, peek1); } }); }
public static void GetEnumerator_Invalid() { Stack stack1 = Helpers.CreateIntStack(100); Helpers.PerformActionOnAllStackWrappers(stack1, stack2 => { IEnumerator enumerator = stack2.GetEnumerator(); // Index < 0 Assert.Throws <InvalidOperationException>(() => enumerator.Current); // Index > dictionary.Count while (enumerator.MoveNext()) { ; } Assert.False(enumerator.MoveNext()); Assert.Throws <InvalidOperationException>(() => enumerator.Current); // Current throws after resetting enumerator.Reset(); Assert.True(enumerator.MoveNext()); enumerator.Reset(); Assert.Throws <InvalidOperationException>(() => enumerator.Current); // MoveNext and Reset throws after stack is modified, but current doesn't enumerator = stack2.GetEnumerator(); enumerator.MoveNext(); stack2.Push("hi"); Assert.Throws <InvalidOperationException>(() => enumerator.MoveNext()); Assert.Throws <InvalidOperationException>(() => enumerator.Reset()); Assert.NotNull(enumerator.Current); enumerator = stack2.GetEnumerator(); enumerator.MoveNext(); stack2.Pop(); Assert.Throws <InvalidOperationException>(() => enumerator.MoveNext()); Assert.Throws <InvalidOperationException>(() => enumerator.Reset()); Assert.NotNull(enumerator.Current); }); }
public static void Contains() { Stack stack1 = Helpers.CreateIntStack(100); Helpers.PerformActionOnAllStackWrappers(stack1, stack2 => { for (int i = 0; i < stack2.Count; i++) { Assert.True(stack2.Contains(i)); } Assert.False(stack2.Contains(101)); Assert.False(stack2.Contains("hello")); Assert.False(stack2.Contains(null)); stack2.Push(null); Assert.True(stack2.Contains(null)); Assert.False(stack2.Contains(-1)); // We have a null item in the list, so the algorithm may use a different branch }); }
public static void GetEnumerator(int count) { Stack stack1 = Helpers.CreateIntStack(count); Helpers.PerformActionOnAllStackWrappers(stack1, stack2 => { Assert.NotSame(stack2.GetEnumerator(), stack2.GetEnumerator()); IEnumerator enumerator = stack2.GetEnumerator(); for (int i = 0; i < 2; i++) { int counter = 0; while (enumerator.MoveNext()) { counter++; Assert.NotNull(enumerator.Current); } Assert.Equal(count, counter); enumerator.Reset(); } }); }
public static void Peek_EmptyStack_ThrowsInvalidOperationException() { var stack1 = new Stack(); Helpers.PerformActionOnAllStackWrappers(stack1, stack2 => { Assert.Throws <InvalidOperationException>(() => stack2.Peek()); // Empty stack for (int i = 0; i < 1000; i++) { stack2.Push(i); } for (int i = 0; i < 1000; i++) { stack2.Pop(); } Assert.Throws <InvalidOperationException>(() => stack2.Peek()); // Empty stack }); }