Esempio n. 1
0
        public void TestClear()
        {
            VisitableStack <int> stack = new VisitableStack <int>();

            stack.Push(2);
            stack.Push(4);
            stack.Push(6);

            stack.Clear();

            Assert.AreEqual(stack.IsEmpty, true);
            Assert.AreEqual(stack.IsFull, false);
            Assert.AreEqual(stack.Count, 0);
        }
Esempio n. 2
0
        public void TestPeek()
        {
            VisitableStack <int> stack = new VisitableStack <int>();

            stack.Push(2);
            stack.Push(4);
            stack.Push(6);

            Assert.AreEqual(stack.Peek(), 6);

            stack.Pop();

            Assert.AreEqual(stack.Peek(), 4);
        }
Esempio n. 3
0
        public void TestPushPop()
        {
            VisitableStack <int> stack = new VisitableStack <int>();

            stack.Push(2);
            stack.Push(4);
            stack.Push(6);

            Assert.AreEqual(stack.Count, 3);


            Assert.AreEqual(stack.Pop(), 6);
            Assert.AreEqual(stack.Pop(), 4);
            Assert.AreEqual(stack.Pop(), 2);
            Assert.AreEqual(stack.Count, 0);
        }
Esempio n. 4
0
        public void TestReadOnly()
        {
            VisitableStack <int> stack = new VisitableStack <int>();

            Assert.AreEqual(stack.IsReadOnly, false);

            stack.Push(5);
            Assert.AreEqual(stack.IsReadOnly, false);
        }
Esempio n. 5
0
        public void TestVisitor()
        {
            VisitableStack <int> stack = new VisitableStack <int>();

            stack.Push(2);
            stack.Push(4);
            stack.Push(9);
            stack.Push(3);

            ComparableFindingVisitor <int> visitor = new ComparableFindingVisitor <int>(9);

            stack.Accept(visitor);

            Assert.AreEqual(visitor.Found, true);

            visitor = new ComparableFindingVisitor <int>(5);
            stack.Accept(visitor);
            Assert.AreEqual(visitor.Found, false);
        }
Esempio n. 6
0
        public void Testcount()
        {
            VisitableStack <int> stack = new VisitableStack <int>();

            for (int i = 0; i < 5; i++)
            {
                stack.Push(i * 3);
                Assert.AreEqual(stack.Count, i + 1);
            }
        }
Esempio n. 7
0
        public void TestAdd()
        {
            VisitableStack <int> stack = new VisitableStack <int>();

            stack.Add(5);

            Assert.AreEqual(stack.Count, 1);
            Assert.AreEqual(stack.Peek(), 5);
            Assert.AreEqual(stack.Pop(), 5);

            stack.Push(2);
            stack.Push(4);

            Assert.AreEqual(stack.Count, 2);
            Assert.AreEqual(stack.Peek(), 4);
            Assert.AreEqual(stack.Pop(), 4);

            Assert.AreEqual(stack.Count, 1);
            Assert.AreEqual(stack.Peek(), 2);
            Assert.AreEqual(stack.Pop(), 2);;
        }
Esempio n. 8
0
        public void TestEnumeratorValues()
        {
            VisitableStack <int> stack = new VisitableStack <int>();

            stack.Push(2);
            stack.Push(4);
            stack.Push(6);

            IEnumerator <int> enumerator = stack.GetEnumerator();

            Assert.AreEqual(enumerator.MoveNext(), true);
            Assert.AreEqual(enumerator.Current, 6);

            Assert.AreEqual(enumerator.MoveNext(), true);
            Assert.AreEqual(enumerator.Current, 4);

            Assert.AreEqual(enumerator.MoveNext(), true);
            Assert.AreEqual(enumerator.Current, 2);

            Assert.AreEqual(enumerator.MoveNext(), false);
        }
Esempio n. 9
0
        public void TestSuccesfulInit()
        {
            Deque <int> d = new Deque <int>();

            Assert.AreEqual(d.Count, 0);
            Assert.AreEqual(d.IsEmpty, true);
            Assert.AreEqual(d.IsFull, false);

            VisitableStack <int> stack = new VisitableStack <int>();

            for (int i = 0; i < 3; i++)
            {
                stack.Push(i * 4);
            }

            d = new Deque <int>(stack);

            for (int i = 2; i >= 0; i--)
            {
                Assert.AreEqual(d.DequeueHead(), i * 4);
            }
        }