public void DefaultInitTest()
        {
            MyStack <int> Stack = new MyArrayStack <int>();

            Assert.AreEqual(Stack.Count, 0);
            Assert.AreEqual((Stack as MyArrayStack <int>).Capacity, 10);
        }
 public void CustomCapacityInitTest()
 {
     int actualCapacity = 24;
     MyStack<int> Stack = new MyArrayStack<int>(actualCapacity);
     Assert.AreEqual(Stack.Count, 0);
     Assert.AreEqual((Stack as MyArrayStack<int>).Capacity, actualCapacity);
 }
 public void NotContainTest()
 {
     MyStack<int> Stack = new MyArrayStack<int>();
     Stack.Push(31);
     Stack.Push(9);
     Assert.AreEqual(Stack.Contains(63), false);
 }
Ejemplo n.º 4
0
 public void PushedStack_ShouldIncrementCountWithOne()
 {
     MyArrayStack<int> myStack = new MyArrayStack<int>();
     Assert.AreEqual(0, myStack.Count);
     myStack.Push(1);
     Assert.AreEqual(1, myStack.Count);
 }
 public void ContainTest()
 {
     MyStack<int> Stack = new MyArrayStack<int>();
     Stack.Push(31);
     Stack.Push(9);
     Assert.AreEqual(Stack.Contains(31), true);
 }
Ejemplo n.º 6
0
    static void Main()
    {
        MyArrayStack<int> myStack = new MyArrayStack<int>();

        for (int i = 1; i <= 10; i++)
        {
            myStack.Push(i);
        }

        Console.WriteLine("{0}", string.Join("-", myStack.ToArray()));

        foreach (var item in myStack)
        {
            Console.Write("{0}-", item);
        }

        Console.WriteLine();

        while (myStack.Count > 0)
        {
            Console.WriteLine(myStack.Pop());
        }

        Console.Read();
    }
        public void PushPopTest()
        {
            MyStack <int> Stack = new MyArrayStack <int>();

            Stack.Push(85);
            Stack.Push(48);
            Assert.AreEqual(Stack.Pop(), 48);
        }
        public void CustomCapacityInitTest()
        {
            int           actualCapacity = 24;
            MyStack <int> Stack          = new MyArrayStack <int>(actualCapacity);

            Assert.AreEqual(Stack.Count, 0);
            Assert.AreEqual((Stack as MyArrayStack <int>).Capacity, actualCapacity);
        }
        public void PeekTest()
        {
            MyStack <int> Stack = new MyArrayStack <int>();

            Stack.Push(98);
            Stack.Push(20);
            Assert.AreEqual(Stack.Peek(), 20);
        }
        public void ContainTest()
        {
            MyStack <int> Stack = new MyArrayStack <int>();

            Stack.Push(31);
            Stack.Push(9);
            Assert.AreEqual(Stack.Contains(31), true);
        }
        public void NotContainTest()
        {
            MyStack <int> Stack = new MyArrayStack <int>();

            Stack.Push(31);
            Stack.Push(9);
            Assert.AreEqual(Stack.Contains(63), false);
        }
 public void CopyConstructorTest()
 {
     MyStack<int> Stack = new MyArrayStack<int>();
     Stack.Push(1);
     Stack.Push(2);
     MyStack<int> Stack2 = new MyArrayStack<int>(Stack);
     Assert.AreEqual(Stack2, Stack);
 }
 public void ClearTest()
 {
     MyStack<int> Stack = new MyArrayStack<int>();
     Stack.Push(1);
     Stack.Push(2);
     Stack.Clear();
     Assert.AreEqual(Stack.Count, 0);
     Assert.AreEqual((Stack as MyArrayStack<int>).Capacity, 10);
 }
        public void ClearTest()
        {
            MyStack <int> Stack = new MyArrayStack <int>();

            Stack.Push(1);
            Stack.Push(2);
            Stack.Clear();
            Assert.AreEqual(Stack.Count, 0);
            Assert.AreEqual((Stack as MyArrayStack <int>).Capacity, 10);
        }
        public void PushMoreThanCapacityTest()
        {
            int           actualCapacity = 1;
            MyStack <int> Stack          = new MyArrayStack <int>(actualCapacity);

            Stack.Push(70);
            Stack.Push(52);
            Assert.AreEqual(Stack.Count, 2);
            Assert.AreEqual((Stack as MyArrayStack <int>).Capacity, actualCapacity + 10);
        }
 public void CopyToArray()
 {
     int[] array = new int[2];
     MyStack<int> Stack = new MyArrayStack<int>();
     Stack.Push(51);
     Stack.Push(94);
     Stack.CopyTo(array, 0);
     Assert.AreEqual(array[0], 51);
     Assert.AreEqual(array[1], 94);
 }
        public void CopyConstructorTest()
        {
            MyStack <int> Stack = new MyArrayStack <int>();

            Stack.Push(1);
            Stack.Push(2);
            MyStack <int> Stack2 = new MyArrayStack <int>(Stack);

            Assert.AreEqual(Stack2, Stack);
        }
Ejemplo n.º 18
0
        public void Should_Check_Is_Empty_False()
        {
            //arrange
            var stack = new MyArrayStack <int>(new[] { 1 });

            //act
            var result = stack.IsEmpty();

            //assert
            result.ShouldBeEquivalentTo(false);
        }
Ejemplo n.º 19
0
        public void Should_Create_With_Capacity()
        {
            //arrange

            //act
            var stack = new MyArrayStack <int>(5);

            //assert
            stack.Capacity.ShouldBeEquivalentTo(5);
            stack.Count.ShouldBeEquivalentTo(0);
        }
Ejemplo n.º 20
0
        public void Should_Create_With_Collection()
        {
            //arrange
            var array = new int[] { 1, 2, 3 };
            //act
            var stack = new MyArrayStack <int>(array);

            //assert
            stack.Capacity.ShouldBeEquivalentTo(array.Length);
            stack.Count.ShouldBeEquivalentTo(array.Length);
        }
Ejemplo n.º 21
0
    public void PushOneThousandElements_CountShouldBeOneThousand()
    {
        MyArrayStack<int> myStack = new MyArrayStack<int>();

        for (int i = 0; i < 1000; i++)
        {
            myStack.Push(i);
        }

        Assert.AreEqual(1000, myStack.Count);
    }
        public void Push_FirstItem_ShouldAddOneItem()
        {
            // Arrange
            var myArrayStack = new MyArrayStack <int>();

            // Act
            myArrayStack.Push(3);

            // Assert
            Assert.AreEqual(1, myArrayStack.Count);
        }
Ejemplo n.º 23
0
        public void Should_Pop_Throw_If_Stack_Is_Empty()
        {
            //arrange
            var stack = new MyArrayStack <int>();

            //act
            Action act = () => stack.Pop();

            //assert
            act.ShouldThrow <InvalidOperationException>();
        }
        public void CopyToArray()
        {
            int[]         array = new int[2];
            MyStack <int> Stack = new MyArrayStack <int>();

            Stack.Push(51);
            Stack.Push(94);
            Stack.CopyTo(array, 0);
            Assert.AreEqual(array[0], 51);
            Assert.AreEqual(array[1], 94);
        }
        public void Push_TwoItems_ShouldAddTwoitems()
        {
            // Arrange
            var myArrayStack = new MyArrayStack <int>();

            // Act
            myArrayStack.Push(1);
            myArrayStack.Push(2);

            // Assert
            Assert.AreEqual(2, myArrayStack.Count);
        }
 public void CustomCapacityLessThanZeroInitTest()
 {
     int actualCapacity = -83;
     try
     {
         MyStack<int> Stack = new MyArrayStack<int>(actualCapacity);
     }
     catch (ArgumentOutOfRangeException e)
     {
         StringAssert.Contains(e.Message, "Вместимость стека должна быть натуральным числом.");
     }
 }
        public void PeekFromEmptyTest()
        {
            MyStack <int> Stack = new MyArrayStack <int>();

            try
            {
                Stack.Peek();
            }
            catch (InvalidOperationException e)
            {
                StringAssert.Contains(e.Message, "Стек пуст.");
            }
        }
        public void CustomCapacityLessThanZeroInitTest()
        {
            int actualCapacity = -83;

            try
            {
                MyStack <int> Stack = new MyArrayStack <int>(actualCapacity);
            }
            catch (ArgumentOutOfRangeException e)
            {
                StringAssert.Contains(e.Message, "Вместимость стека должна быть натуральным числом.");
            }
        }
Ejemplo n.º 29
0
        public void Should_Peek()
        {
            //arrange
            var stack = new MyArrayStack <int>(new[] { 1 });

            //act
            var result = stack.Peek();

            //assert
            stack.Count.ShouldBeEquivalentTo(1);
            stack.Capacity.ShouldBeEquivalentTo(1);
            result.ShouldBeEquivalentTo(1);
        }
        public void Push_FiveItems_ShouldAddFiveItems()
        {
            // Arrange
            var myArrayStack = new MyArrayStack <int>();

            // Act
            myArrayStack.Push(1);
            myArrayStack.Push(2);
            myArrayStack.Push(3);
            myArrayStack.Push(4);
            myArrayStack.Push(5);

            // Assert
            Assert.AreEqual(5, myArrayStack.Count);
        }
Ejemplo n.º 31
0
        public void Should_Pop()
        {
            //arrange
            var stack = new MyArrayStack <int>(new[] { 1 });

            //act
            var    result = stack.Pop();
            Action act    = () => stack.Pop();

            //assert
            result.ShouldBeEquivalentTo(1);
            stack.Count.ShouldBeEquivalentTo(0);
            stack.Capacity.ShouldBeEquivalentTo(1);
            act.ShouldThrow <InvalidOperationException>();
        }
Ejemplo n.º 32
0
        public void Should_Push_Element_Change_Capacity()
        {
            //arrange
            var stack = new MyArrayStack <int>(new[] { 1, 2, 3, 4 });
            var data  = 1;

            //act
            stack.Push(data);
            var result = stack.Peek();

            //assert
            stack.Count.ShouldBeEquivalentTo(5);
            stack.Capacity.ShouldBeEquivalentTo(8);
            result.ShouldBeEquivalentTo(data);
        }
Ejemplo n.º 33
0
        public void Should_Push_Element()
        {
            //arrange
            var stack = new MyArrayStack <int>();
            var data  = 1;

            //act
            stack.Push(data);
            var result = stack.Peek();

            //assert
            stack.Count.ShouldBeEquivalentTo(1);
            stack.Capacity.ShouldBeEquivalentTo(4);
            result.ShouldBeEquivalentTo(data);
        }
Ejemplo n.º 34
0
        private void RearrangeStacks(MyArrayStack<T> first,
            MyArrayStack<T> second)
        {
            if (first == null || second == null)
                throw new ArgumentNullException();

            MyArrayStack<T> temp = new MyArrayStack<T>(second.Capacity);

            while (second.Count != 1)
                temp.Push(second.Pop());

            first.Push(second.Pop());

            while (temp.Count != 0)
                second.Push(temp.Pop());
        }
Ejemplo n.º 35
0
    public void TestToArrayMethod_ReturnedArrayShouldBeInReversedOrder()
    {
        MyArrayStack<int> myStack = new MyArrayStack<int>();

        myStack.Push(3);
        myStack.Push(5);
        myStack.Push(-2);
        myStack.Push(7);

        var arr = myStack.ToArray();

        Assert.AreEqual(7, arr[0]);
        Assert.AreEqual(-2, arr[1]);
        Assert.AreEqual(5, arr[2]);
        Assert.AreEqual(3, arr[3]);
    }
Ejemplo n.º 36
0
    public void PopOneThousandTimesFromMyStackWithOneThousendElements_CountShoulBeZero()
    {
        MyArrayStack<int> myStack = new MyArrayStack<int>();

        for (int i = 0; i < 1000; i++)
        {
            myStack.Push(i);
        }

        for (int i = 0; i < 1000; i++)
        {
            myStack.Pop();
        }

        Assert.AreEqual(0, myStack.Count);
    }
        public void InvalidCopyToArray()
        {
            int[]         array = new int[2];
            MyStack <int> Stack = new MyArrayStack <int>();

            Stack.Push(51);
            Stack.Push(94);
            try
            {
                Stack.CopyTo(array, 2);
            }
            catch (IndexOutOfRangeException e)
            {
                StringAssert.Contains(e.Message, "Индекс вне диапазона.");
            }
        }
Ejemplo n.º 38
0
        static void Main()
        {
            //MyEasyStack<string> myEasyStack = new MyEasyStack<string>();

            //myEasyStack.Push("Hi");
            //myEasyStack.Push("Hellow");
            //myEasyStack.Push("World");

            //Print(myEasyStack);

            //var newStack = myEasyStack.Clone();
            //myEasyStack.Push("People");
            //Print(myEasyStack);
            //Console.Write("Клонированный ");
            //Print(newStack);

            //MyStack<int> myStack = new MyStack<int>();

            //myStack.Push(1);
            //myStack.Push(3);
            //myStack.Push(5);
            //Print(myStack);
            //var newMyStack = myStack.Clone();
            //myStack.Push(7);
            //Print(myStack);
            //Console.Write("Клонированный ");
            //Print(newMyStack);


            MyArrayStack <string> myArrayStack = new MyArrayStack <string>(6);

            myArrayStack.Push("1");
            myArrayStack.Push("3");
            myArrayStack.Push("5");
            Print(myArrayStack);
            var newMyArrayStack = myArrayStack.Clone();


            myArrayStack.Push("7");
            Print(myArrayStack);



            Console.Write("Клонированный ");
            newMyArrayStack.Push("new");
            Print(newMyArrayStack);
        }
        public void Pop_OneItem_ShouldReturnLastAddedItem()
        {
            // Arrange
            var myArrayStack = new MyArrayStack <int>();

            myArrayStack.Push(1);
            myArrayStack.Push(2);
            myArrayStack.Push(3);
            myArrayStack.Push(4);
            myArrayStack.Push(5);

            // Act
            var item = myArrayStack.Pop();

            // Assert
            Assert.AreEqual(5, item);
        }
        public void Pop_TwoItem_ShouldDecrementStackCountbyTwo()
        {
            // Arrange
            var myArrayStack = new MyArrayStack <int>();

            myArrayStack.Push(1);
            myArrayStack.Push(2);
            myArrayStack.Push(3);
            myArrayStack.Push(4);
            myArrayStack.Push(5);

            // Act
            myArrayStack.Pop();
            myArrayStack.Pop();

            // Assert
            Assert.AreEqual(3, myArrayStack.Count);
        }
        public void Peek_ShouldReturnLastAddedItem()
        {
            // Arrange
            var myArrayStack = new MyArrayStack <int>();
            var expected     = 0;

            myArrayStack.Push(++expected);
            myArrayStack.Push(++expected);
            myArrayStack.Push(++expected);
            myArrayStack.Push(++expected);
            myArrayStack.Push(++expected);

            // Act
            var actual = myArrayStack.Peek();

            // Assert
            Assert.AreEqual(expected, actual);
        }
Ejemplo n.º 42
0
        public void Should_Pop_Multiple()
        {
            //arrange
            var array = new[] { 1, 2, 3 };
            var stack = new MyArrayStack <int>(array);

            //act
            var    first  = stack.Pop();
            var    second = stack.Pop();
            var    third  = stack.Pop();
            Action act    = () => stack.Pop();

            //assert
            first.ShouldBeEquivalentTo(array[2]);
            second.ShouldBeEquivalentTo(array[1]);
            third.ShouldBeEquivalentTo(array[0]);
            act.ShouldThrow <InvalidOperationException>();
        }
Ejemplo n.º 43
0
    public void PopAndPushTwoTimesInitCapcityOne_ResizeAndCountShouldBehaveCorectly()
    {
        MyArrayStack<string> myStack = new MyArrayStack<string>(1);

        Assert.AreEqual(0, myStack.Count);

        myStack.Push("One");
        Assert.AreEqual(1, myStack.Count);

        myStack.Push("Two");
        Assert.AreEqual(2, myStack.Count);

        var poppedElement = myStack.Pop();
        Assert.AreEqual("Two", poppedElement);
        Assert.AreEqual(1, myStack.Count);

        poppedElement = myStack.Pop();
        Assert.AreEqual("One", poppedElement);
        Assert.AreEqual(0, myStack.Count);
    }
 public void PushPopTest()
 {
     MyStack<int> Stack = new MyArrayStack<int>();
     Stack.Push(85);
     Stack.Push(48);
     Assert.AreEqual(Stack.Pop(), 48);
 }
Ejemplo n.º 45
0
    public void EmptyMyStack_ShouldReturnEmptyArray()
    {
        MyArrayStack<DateTime> myStack = new MyArrayStack<DateTime>();

        var arr = myStack.ToArray();

        Assert.AreEqual(0, arr.Length);       
    }
Ejemplo n.º 46
0
    public void PopElementFromEmptyMyStack_ShouldThrow()
    {
        MyArrayStack<int> myStack = new MyArrayStack<int>();

        myStack.Pop();
    }
 public void DefaultInitTest()
 {
     MyStack<int> Stack = new MyArrayStack<int>();
     Assert.AreEqual(Stack.Count, 0);
     Assert.AreEqual((Stack as MyArrayStack<int>).Capacity, 10);
 }
 public void PeekTest()
 {
     MyStack<int> Stack = new MyArrayStack<int>();
     Stack.Push(98);
     Stack.Push(20);
     Assert.AreEqual(Stack.Peek(), 20);
 }
        public void PeekFromEmptyTest()
        {
            MyStack<int> Stack = new MyArrayStack<int>();
            try
            {
                Stack.Peek();
            }
            catch (InvalidOperationException e)
            {
                StringAssert.Contains(e.Message, "Стек пуст.");
            }

        }
 public void InvalidCopyToArray()
 {
     int[] array = new int[2];
     MyStack<int> Stack = new MyArrayStack<int>();
     Stack.Push(51);
     Stack.Push(94);
     try
     {
         Stack.CopyTo(array, 2);
     }
     catch (IndexOutOfRangeException e)
     {
         StringAssert.Contains(e.Message, "Индекс вне диапазона.");
     }
 }
 public void PushMoreThanCapacityTest()
 {
     int actualCapacity = 1;
     MyStack<int> Stack = new MyArrayStack<int>(actualCapacity);
     Stack.Push(70);
     Stack.Push(52);
     Assert.AreEqual(Stack.Count, 2);
     Assert.AreEqual((Stack as MyArrayStack<int>).Capacity, actualCapacity + 10);
 }