[TestMethod] //получение элемента из пустго стека public void PopEmptyTest() { int n = 3; StackArray<object> data = new StackArray<object>(n); data.Pop(); }
public void FullStackArrayTests0() { var stackArray = new StackArray <int>(5); for (var i = 0; i < 5; i++) { Assert.True(stackArray.Count == i); stackArray.Push(i * 2); } Assert.True(stackArray.IsFull); Assert.False(stackArray.IsEmpty); Assert.Throws <InvalidOperationException>(() => stackArray.Push(10)); Assert.Throws <InvalidOperationException>(() => stackArray.Push(12)); Assert.True(stackArray.Peek() == 8); Assert.True(stackArray.Pop() == 8); Assert.True(stackArray.Count == 4); Assert.True(stackArray.Length == 5); Assert.False(stackArray.IsFull); Assert.False(stackArray.IsEmpty); stackArray.Push(8); Assert.True(stackArray.Peek() == 8); Assert.Throws <InvalidOperationException>(() => stackArray.Push(10)); Assert.True(stackArray.IsFull); Assert.False(stackArray.IsEmpty); Assert.True(stackArray.Length == 5); Assert.True(stackArray.Count == 5); }
public ElementHandlerResult AddChild(StackArray <string> openElements, string childName) { if (Array.IndexOf(closers, childName) == -1) { return(ElementHandlerResult.Continue); } for (var index = openElements.Count; index > 0; index--) { var openElement = openElements[index - 1]; if (Array.IndexOf(parents, openElement) != -1) { return(ElementHandlerResult.Continue); } if (openElement.Equals(Name)) { break; } } if (Array.IndexOf(closers, childName) != -1) { if (Array.IndexOf(peers, childName) != -1) { return(ElementHandlerResult.CloseElementAndBreak); } return(ElementHandlerResult.CloseElement); } return(ElementHandlerResult.Continue); }
private static void printStack(StackArray <int> stack) { foreach (var item in stack) { Console.WriteLine(item); } }
[TestMethod] //получение элемента из пустго стека public void PopEmptyTest() { int n = 3; StackArray <object> data = new StackArray <object>(n); data.Pop(); }
static void Main(string[] args) { Console.WriteLine("Array based stack"); IStack stk = new StackArray(4); DemoStack(stk); Console.WriteLine("Double Linked List based stack"); stk = new StackDoublyLinkedList(); DemoStack(stk); Console.WriteLine("Circular Linked List based stack"); stk = new StackCircularLinkedList(); DemoStack(stk); int[] Input = { 10, 9, 8, 4, 13, 7, 12, 4, 6, 2 }; for (int i = 0; i < Input.Length; i++) { Console.Write(Input[i] + " "); } Console.WriteLine(""); int[] Span = ArraySpan.CalculateSpan(Input); for (int i = 0; i < Span.Length; i++) { Console.Write(Span[i] + " "); } Console.ReadLine(); }
static void Main(string[] args) { var ht = new HashTable<int, int>(); var ll = new MyLinkedList<int>(); var stackLL = new StackLL<int>(); var stackArr = new StackArray<int>(); var queueArr = new QueueArr<int>(); }
public ElementHandlerResult AddChild(StackArray <string> openElements, string childName) { if (!HtmlConverter.IsInlineElement(childName)) { return(ElementHandlerResult.CloseElement); } return(ElementHandlerResult.Continue); }
public void EmptyStackExceptionTest() { IStack stack = new Stack(); stack.Pop(); stack = new StackArray(); stack.Pop(); }
// StackArray [Benchmark] public void StackArray_Push() { IStack <Person> stack = new StackArray <Person>(); foreach (Person person in RandomTestData) { stack.Push(person); } }
[Benchmark] public void StackArray_PushWithCapacity() { IStack <Person> stack = new StackArray <Person>(RandomTestData.Length); foreach (Person person in RandomTestData) { stack.Push(person); } }
[TestMethod] //Тест заполнения стека public void PushTest() { int n = 3; StackArray <object> data = new StackArray <object>(n); data.Push(8); data.Push(6); data.Push(10); }
[TestMethod] //Тест заполнения стека public void PushTest() { int n = 3; StackArray<object> data = new StackArray<object>(n); data.Push(8); data.Push(6); data.Push(10); }
public void Add() { IStack <Person> stack = new StackArray <Person>(); foreach (Person person in RandomTestData) { stack.Push(person); } }
public void PushElements() { var stack = new StackArray <int>(); for (int i = 0; i < MAX_SIZE; i++) { stack.Push(i); } }
public void ConstructorTest() { Stack stack = new StackArray(12); int initialSize = getInitialSize(stack); Assert.AreEqual(12, initialSize); int stackSize = getArraySize(stack); Assert.AreEqual(initialSize, stackSize); }
public void DefaultConstructorTest() { var stack = new StackArray(); int initialSize = getInitialSize(stack); Assert.AreEqual(10, initialSize); int stackSize = getArraySize(stack); Assert.AreEqual(initialSize, stackSize); }
public void ResizeTest() { var stack = new StackArray(); for (var i = 0; i < 1000; ++i) { stack.Push(i); } Assert.AreEqual(999, stack.Pop()); }
public void PushWithCapacity() { IStack <int> stack = new StackArray <int>(PushCount); int pushCount = PushCount; for (int i = 0; i < pushCount; i++) { stack.Push(i); } }
public void Get_GetFromEmptyStack() { // Arrange StackArray <int> sut = new StackArray <int>(); // Act // Assert Assert.Throws <DataStructureIsEmptyOnReadExeption>(() => sut.Get()); }
[TestMethod] //IDisposable public void DisposeTest() { int n = 3; StackArray<object> data = new StackArray<object>(n); data.Push(8); data.Push(6); data.Push(10); data.Dispose(); }
[TestMethod] //IEnumerable public void EnumerableTest() { int n = 3; StackArray<object> data = new StackArray<object>(n); data.Push(8); data.Push(6); data.Push(10); data.GetEnumerator(); }
[TestMethod] //IEnumerable public void EnumerableTest() { int n = 3; StackArray <object> data = new StackArray <object>(n); data.Push(8); data.Push(6); data.Push(10); data.GetEnumerator(); }
[TestMethod] //IDisposable public void DisposeTest() { int n = 3; StackArray <object> data = new StackArray <object>(n); data.Push(8); data.Push(6); data.Push(10); data.Dispose(); }
public void StackSizeIncreases() { var stack = new StackArray <int>(); for (int i = 0; i < MAX_SIZE; i++) { stack.Push(i); } Assert.AreEqual(MAX_SIZE, stack.Size()); }
static void Main(string[] args) { var s = new StackArray(5); s.push(12); s.push(11); s.push(113); s.push(413); s.push(4131); s.display(); }
[TestMethod] public void Push_Pop_Testing() { void Test <T>(T[] values) { Towel.Sort.Shuffle(values); IStack <T> stack = new StackArray <T>(); values.Stepper(x => stack.Push(x)); Array.Reverse(values); values.Stepper(x => x.Equals(stack.Pop())); }
public void Implement_Stack_Using_Array() { StackArray stack = new StackArray(100, output); stack.push(2); stack.push(3); Assert.Equal(3, stack.pop()); stack.push(4); Assert.Equal(4, stack.pop()); stack.printStack(); }
public void TestStack() { var stack = new StackArray <int>(); stack.Push(10); stack.Push(20); Assert.Equal(2, stack.Count); Assert.False(stack.IsEmpty); Assert.Equal(20, stack.Pop()); Assert.Equal(10, stack.Pop()); Assert.True(stack.IsEmpty); }
public void IsEmpty_EmptyStackArrayShouldReturnTrue() { // Arrange StackArray <int> sut = new StackArray <int>(); bool expected = true; // Act bool actual = sut.IsEmpty(); // Assert Assert.Equal(expected, actual); }
// methods #region public StackArray<T> Clone() /// <summary>Creates a shallow clone of this data structure.</summary> /// <returns>A shallow clone of this data structure.</returns> public StackArray <T> Clone() { StackArray <T> clone = new StackArray <T>(); clone._stack = new T[this._stack.Length]; for (int i = 0; i < this._count; i++) { clone._stack[i] = this._stack[i]; } clone._minimumCapacity = this._minimumCapacity; clone._count = this._count; return(clone); }
public void Indexer_SetFromWrongIndexShouldThrowExeption() { // Arrange StackArray <double> sut = new StackArray <double>(); sut.Add(1); sut.Add(2); // Act // Assert Assert.Throws <IndexOutOfRangeException>(() => sut[5] = 10); }
public void PopReturnsValue() { var stack = new StackArray <int>(); for (int i = 0; i < MAX_SIZE; i++) { stack.Push(i); } for (int i = MAX_SIZE - 1; i > 0; i--) { Assert.AreEqual(i, stack.Pop()); } }
private StackArray<Struct, S005<Struct>> InitArray(StackArray<Struct, S005<Struct>> array) { for (var i = 0; i < 5; i++) { var s = new Struct(); s.Number = i; var gcMemory = GC.GetTotalMemory(false); array[i] = s; Assert.AreEqual(gcMemory, GC.GetTotalMemory(false), "Set index is allocating on heap."); } return array; }
public void Filter_FilterShouldWork() { // Arrange StackArray <int> sut = new StackArray <int> { 2, 8, 7, 12, 23, 14, 1, 25, 17, 5 }; int[] expected = { 5, 14, 12, 7, 8 }; // Act IEnumerable <int> actual = sut.Filter(item => item >= 5 && item <= 14); // Assert Assert.Equal(expected, actual); }
public void StackSizeDecreases() { var stack = new StackArray <int>(); for (int i = 0; i < MAX_SIZE; i++) { stack.Push(i); } for (int i = MAX_SIZE; i > 0; i--) { stack.Pop(); } Assert.AreEqual(0, stack.Size()); }
public void Clear_ClearStackWithSomeElementsShouldWork() { // Arrange StackArray <int> sut = new StackArray <int>(); int expected = 0; // Act sut.Add(42); sut.Add(17); sut.Add(int.MaxValue); sut.Clear(); int actual = sut.Size(); // Assert Assert.Equal(expected, actual); }
public void Initialize() { stack = new StackArray(); }