Exemple #1
0
        public void StackOfPlates_Pop_WhenNotEmpty_ShouldReturnTopOfCurrentPlate()
        {
            // Arrange
            var stackOfPlates = new StackOfPlates <int>(3);

            stackOfPlates.push(1);
            stackOfPlates.push(2);
            stackOfPlates.push(3);
            stackOfPlates.push(4);

            // Act && Assert
            stackOfPlates.Pop().Should().Be(4);
            stackOfPlates.Pop().Should().Be(3);
            stackOfPlates.Pop().Should().Be(2);
            stackOfPlates.Pop().Should().Be(1);
        }
Exemple #2
0
        public void TestPopException()
        {
            // Arrange
            StackOfPlates stack = new StackOfPlates(2);

            // Act
            stack.Pop();
        }
Exemple #3
0
        public void StackOfPlates_Pop_WhenEmpty_ThrowsEmptyStackException()
        {
            // Arrange
            var    stackOfPlates = new StackOfPlates <int>(3);
            Action action        = () => { stackOfPlates.Pop(); };

            // Act && Assert
            action.Should().Throw <EmptyStackException>().WithMessage("Stack is Empty");
        }
        public void PopWithIndex_Test_Positive()
        {
            StackOfPlates stackOfPlates = new StackOfPlates(10);

            stackOfPlates.Push(1);
            stackOfPlates.Push(2);
            stackOfPlates.Push(3);
            stackOfPlates.Push(4);
            stackOfPlates.Push(5);
            stackOfPlates.Push(6);
            stackOfPlates.Push(7);
            stackOfPlates.Push(8);
            stackOfPlates.Push(9);
            stackOfPlates.Push(10);
            stackOfPlates.Push(11);

            int latestremoved  = stackOfPlates.Pop(1);
            int latestremoved2 = stackOfPlates.Pop(0);

            Assert.AreEqual(11, latestremoved);
            Assert.AreEqual(10, latestremoved2);
        }
        public void Pop_Test()
        {
            StackOfPlates stackOfPlates = new StackOfPlates(10);

            stackOfPlates.Push(1);
            stackOfPlates.Push(2);
            stackOfPlates.Push(3);
            stackOfPlates.Push(4);
            stackOfPlates.Push(5);
            stackOfPlates.Push(6);
            stackOfPlates.Push(7);
            stackOfPlates.Push(8);
            stackOfPlates.Push(9);
            stackOfPlates.Push(10);

            stackOfPlates.Push(11);

            for (int i = 11; i > 0; i--)
            {
                Assert.AreEqual(i, stackOfPlates.Pop());
            }
        }
Exemple #6
0
        public void TestPushAndPop()
        {
            // Arrange
            StackOfPlates stack = new StackOfPlates(4);

            // Act
            stack.Push(1);
            stack.Push(2);
            stack.Push(3);
            stack.Push(4);
            stack.Push(5);
            stack.Push(6);
            stack.Push(7);
            stack.Push(8);
            stack.Push(9);
            stack.Push(10);
            stack.Push(11);
            stack.Push(12);
            stack.Push(13);
            stack.Push(14);
            stack.Push(15);
            stack.Push(16);

            // Assert
            Assert.AreEqual(stack.Pop(), 16);
            Assert.AreEqual(stack.Pop(), 15);
            Assert.AreEqual(stack.Pop(), 14);
            Assert.AreEqual(stack.Pop(), 13);
            Assert.AreEqual(stack.Pop(), 12);
            Assert.AreEqual(stack.Pop(), 11);
            Assert.AreEqual(stack.Pop(), 10);
            Assert.AreEqual(stack.Pop(), 9);
            Assert.AreEqual(stack.Pop(), 8);
            Assert.AreEqual(stack.Pop(), 7);
            Assert.AreEqual(stack.Pop(), 6);
            Assert.AreEqual(stack.Pop(), 5);
            Assert.AreEqual(stack.Pop(), 4);
            Assert.AreEqual(stack.Pop(), 3);
            Assert.AreEqual(stack.Pop(), 2);
            Assert.AreEqual(stack.Pop(), 1);
        }