public void PushAndPop_StackWith1000Elemnts_ShouldTestTheAutoGrowFunctionality()
        {
            //Arrange
            var stack = new ArrayStack<string>();
            int i = 0;

            //Assert
            Assert.AreEqual(0, stack.Count);

            while(i != 1000)
            {
                //Act
                i++;
                stack.Push(i.ToString());

                //Assert
                Assert.AreEqual(i, stack.Count);
            }

            while (i != 0)
            {
                //Act
                i--;
                string lastElement = stack.Pop();

                //Assert
                Assert.AreEqual(i, stack.Count);
                Assert.AreEqual((i + 1).ToString(), lastElement);
            }
        }

        public void Test_Push_Pop()
        {
            ArrayStack<int> roo = new ArrayStack<int>();
            Assert.AreEqual(0,roo.Count);
            roo.Push(9);
            Assert.AreEqual(1,roo.Count);
            Assert.AreEqual(9,roo.Pop());
            Assert.AreEqual(0,roo.Count);

            ArrayStack<string> testPush = new ArrayStack<string>();
            Assert.AreEqual(0, testPush.Count);
            for (int i = 1; i <= 1000; i++)
            {
                testPush.Push("as"+i);
                Assert.AreEqual(i, testPush.Count);

            }

            for (int i = 1000; i >= 1; i--)
            {
                Assert.AreEqual("as"+i, testPush.Pop());
                Assert.AreEqual(i - 1, testPush.Count);

            }
        }

        public void Push_OneElement_ShouldBeReturnedWhenPop()
        {
            var arrayStack = new ArrayStack<bool>();
            arrayStack.Push(true);

            Assert.AreEqual(true, arrayStack.Pop());
        }

        public void ArrayStack_PushPopManyChunks_ShouldWorkCorrectly()
        {
            // Arrange
            var stack = new ArrayStack<int>();
            int chunks = 100;

            // Act & Assert in a loop
            int value = 1;
            for (int i = 0; i < chunks; i++)
            {
                Assert.AreEqual(0, stack.Count);
                var chunkSize = i + 1;
                for (int counter = 0; counter < chunkSize; counter++)
                {
                    Assert.AreEqual(value - 1, stack.Count);
                    stack.Push(value);
                    Assert.AreEqual(value, stack.Count);
                    value++;
                }
                for (int counter = 0; counter < chunkSize; counter++)
                {
                    value--;
                    Assert.AreEqual(value, stack.Count);
                    stack.Pop();
                    Assert.AreEqual(value - 1, stack.Count);
                }
                Assert.AreEqual(0, stack.Count);
            }
        }

        public void EmptyStackToArray()
        {
            var stack = new ArrayStack<DateTime>();
            var testArr = new DateTime[0];

            CollectionAssert.AreEqual(testArr, stack.ToArray());
        }

        public void TestEmptyStackToArray()
        {
            var stack = new ArrayStack<DateTime>();
            DateTime[] array = stack.ToArray();

            Assert.AreEqual(0, array.Length);
        }

 public void PushPopElement()
 {
     ArrayStack<int> testStack = new ArrayStack<int>();
     Assert.AreEqual(0,testStack.Count);
     testStack.Push(1);
     Assert.AreEqual(1,testStack.Count);
 }

        public void EmptyStackToArray_ShouldReturnEmptyArray()
        {
            var stack = new ArrayStack<DateTime>();

            var actual = stack.ToArray().Length;
            Assert.AreEqual(0, actual, "Array is not empty.");
        }

        public void PushAndPopRepeat1000Times()
        {
            // Arrange
            ArrayStack<string> stack = new ArrayStack<string>();
            var count = 0;

            // Assert
            Assert.AreEqual(count, stack.Count);

            // Act
            for (int i = 0; i < 1000; i++)
            {
                stack.Push("Plamen");
            }

            // Assert
            Assert.AreEqual(1000, stack.Count);

            // Act
            var poppedElement = string.Empty;
            for (int i = 0; i < 1000; i++)
            {
                poppedElement = stack.Pop();
            }

            Assert.AreEqual(poppedElement, "Plamen");
            Assert.AreEqual(count, stack.Count);
        }

        public void PushAndPopWithInitialCapacity1ShouldWorkCorrectly()
        {
            //Arrange
            var stack = new ArrayStack<int>(1);
            //Assert
            Assert.AreEqual(0, stack.Count);

            //Act
            stack.Push(1);
            //Assert
            Assert.AreEqual(1, stack.Count);
            //Act
            stack.Push(2);
            //Assert
            Assert.AreEqual(2, stack.Count);
            //Act
            var element = stack.Pop();
            //Assert
            Assert.AreEqual(2, element);
            Assert.AreEqual(1, stack.Count);
            //Act
            element = stack.Pop();
            //Assert
            Assert.AreEqual(1, element);
            Assert.AreEqual(0, stack.Count);
        }

        public void Push_OneElement_InCustomCapacityStack_ShouldAddProperly()
        {
            var newStack = new ArrayStack<string>(1);
            newStack.Push("ha");

            Assert.AreEqual(1, newStack.Count);
        }

        public void TestPushPopElement()
        {
            var arrayStack = new ArrayStack<int>();
            arrayStack.Push(6);

            // I'll know how to make unit testing in a week.
        }

        public void PushPop100Elements_CountShouldBeCorrect()
        {
            var stack = new ArrayStack<string>();
            var items = new List<string>();

            Assert.AreEqual(0, stack.Count, "Count is not 0.");

            for (int i = 0; i < 1000; i++)
            {
                string currentElement = i.ToString();
                items.Add((999 - i).ToString());
                stack.Push(currentElement);

                Assert.AreEqual(i + 1, stack.Count, $"Count is not {i + 1}.");
            }

            Assert.AreEqual(1000, stack.Count, "Count is not 1000.");

            for (int i = 0; i < 1000; i++)
            {
                string poppedElement = stack.Pop();
                string expectedElement = items[i];
                Assert.AreEqual(expectedElement, poppedElement, $"Popped element is not {expectedElement}");
                Assert.AreEqual(999 - i, stack.Count, $"Count is not {999 - i}.");

            }

            Assert.AreEqual(0, stack.Count, "Count is not 0");
        }

 public void ConvertEmptyStackToArray()
 {
     ArrayStack<int> arrayStack = new ArrayStack<int>();
     int [] expected= new int[0];
     int[] actual = arrayStack.ToArray();
     CollectionAssert.AreEqual(expected, actual);
 }

 public void TestEmptyStackToArray_ShouldReturnEmptyArray()
 {
     var stack = new ArrayStack<DateTime>();
     var array = stack.ToArray();
     var expected = new DateTime[0];
     CollectionAssert.AreEqual(expected, array);
 }

 public void CreateStack_PushSingleElement_ShouldWorkCorrectly()
 {
     var stack = new ArrayStack<int>();
     stack.Push(3);
     Assert.AreEqual(3, stack.Peak());
     Assert.AreEqual(1, stack.Count);
 }

        public void StackWithOneElementShouldHaveCountOne()
        {
            ArrayStack<int> arrayStack = new ArrayStack<int>();
            arrayStack.Push(15);

            Assert.AreEqual(1, arrayStack.Count);
        }

        public void Push_FewElements_InCustomCapacityStack_ShouldAddProperly()
        {
            var newStack = new ArrayStack<string>(1);
            newStack.Push("Az");
            newStack.Push("Ti");

            Assert.AreEqual(2, newStack.Count);
        }

 public void PopElementFromStackShouldReturnTheProperElementAndDecreaseCountWithOne()
 {
     ArrayStack<int> stackOfInts = new ArrayStack<int>();
     stackOfInts.Push(5);
     int poppedElement = stackOfInts.Pop();
     Assert.AreEqual(5, poppedElement);
     Assert.AreEqual(0, stackOfInts.Count);
 }

        public void TestEmptyStackToArray_ShouldReturnEmptyArray()
        {
            var stack = new ArrayStack<List<Dictionary<bool[], decimal>>>();

            var arr = stack.ToArray();

            Assert.AreEqual(0, arr.Length);
        }