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

        static void Main()
        {
            var collection = new LinkedStack<int>();
            collection.Push(1);
            collection.Push(2);
            collection.Push(3);
            collection.Push(4);
            collection.Push(5);
            collection.Push(6);
            collection.Push(7);
            collection.Push(8);
            collection.Push(9);

            Console.WriteLine(collection.Pop());
            Console.WriteLine(collection.Pop());
            Console.WriteLine(collection.Pop());
            Console.WriteLine(collection.Pop());
            Console.WriteLine(collection.Pop());
            Console.WriteLine("Count: " + collection.Count);

            var array = collection.ToArray();
            Console.WriteLine(string.Join(", ", array));

            Console.WriteLine(collection.Pop());
            Console.WriteLine("Count: " + collection.Count);
        }

        public void Push_Pop_Two()
        {
            var ints = new LinkedStack<int> ();
            Assert.AreEqual (0, ints.Count);

            int element1 = 1;
            ints.Push (element1);
            Assert.AreEqual (1, ints.Count);

            int element2 = 2;
            ints.Push (element2);
            Assert.AreEqual (2, ints.Count);

            {
                int poppedEl = ints.Pop ();
                Assert.AreEqual (poppedEl, element2);
                Assert.AreEqual (1, ints.Count);
            }

            {
                int poppedEl = ints.Pop ();
                Assert.AreEqual (poppedEl, element1);
                Assert.AreEqual (0, ints.Count);
            }
        }

        public void ToArrayOnEmptyStackShouldReturnEmptyArray()
        {
            LinkedStack<int> stack = new LinkedStack<int>();
            var resultArray = stack.ToArray();

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

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

            LinkedStack<string> testPush = new LinkedStack<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 EmptyLinkedStackToArray()
        {
            var linkedStack = new LinkedStack<DateTime>();
            var testArr = new DateTime[0];

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

        public void EmptyArraysShouldBeEqual()
        {
            var stack = new LinkedStack<DateTime>();
            var array = new DateTime[] { };

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

 [TestMethod] //IDisposable
 public void DisposeTest()
 {
     LinkedStack<object> data = new LinkedStack<object>();
     data.Push(8);
     data.Push(14);
     data.Dispose();
 }

 [TestMethod] // ICloneable
 public void CloneTest()
 {
     LinkedStack<object> data = new LinkedStack<object>();
     data.Push(8);
     data.Push(10);
     data.Clone();
 }

 [TestMethod] // IEnumerable
 public void EnumerableTest()
 {
     LinkedStack<object> data = new LinkedStack<object>();
     data.Push(8);
     data.Push(10);
     data.GetEnumerator();
 }

        public void To_Array_Empty()
        {
            var dates = new LinkedStack<DateTime>();
            var arrTest = new DateTime[0];

            CollectionAssert.AreEqual(arrTest, dates.ToArray());
        }

 [TestMethod] // получение последнего элемента
 public void PopTest()
 {
     LinkedStack<object> data = new LinkedStack<object>();
     data.Push(8);
     data.Push(6);
     data.Pop();
 }

        public void CheckCountAfterOnePush_ShouldBeOne()
        {
            var linkedStack = new LinkedStack<int>();
            linkedStack.Push(1);

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

        public void PushAndPopWithInitialCapacity1ShouldWorkCorrectly()
        {
            //Arrange
            var stack = new LinkedStack<int>();
            //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 PushPopElement()
 {
     LinkedStack<int> testStack = new LinkedStack<int>();
     Assert.AreEqual(0,testStack.Count);
     testStack.Push(1);
     Assert.AreEqual(1,testStack.Count);
 }

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

        public void LinkedStack_PushPopManyChunks_ShouldWorkCorrectly()
        {
            // Arrange
            var stack = new LinkedStack<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 TestEmptyStackToArray()
        {
            var stack = new LinkedStack<DateTime>();
            DateTime[] array = stack.ToArray();

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

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

        public void Create_EmptyLinkedStack_ShouldGetCountZero()
        {
            // Arrange
            var emptyStack = new LinkedStack<int>();

            // Assert
            Assert.AreEqual(0, emptyStack.Count);
        }