static void Main(string[] args)
        {
            Node            nodeFirst  = new Node("first");
            Node            nodeSecond = new Node("second");
            Node            nodeThird  = new Node("third");
            QueueWithStacks queue      = new QueueWithStacks(nodeFirst);

            queue.Enqueue(nodeSecond);
            queue.Enqueue(nodeThird);
            Console.WriteLine("Initial queue:");
            Console.WriteLine(queue.ToString());
            Console.WriteLine();
            Console.WriteLine($"First element: {queue.Dequeue().Value}");
            Console.WriteLine("The queue after dequeue:");
            Console.WriteLine(queue.ToString());
            Console.WriteLine();
            Console.WriteLine($"Second element: {queue.Dequeue().Value}");
            Console.WriteLine("The queue after dequeue:");
            Console.WriteLine(queue.ToString());
            Console.WriteLine();
            Console.WriteLine($"Second element: {queue.Dequeue().Value}");
            Console.WriteLine("The queue after dequeue:");
            Console.WriteLine(queue.ToString());
            Console.ReadLine();
        }
        public void GetExceptionNullPointerRetrievingEmptyQueue()
        {
            Node            nodeFirst = new Node("first");
            QueueWithStacks queue     = new QueueWithStacks(nodeFirst);

            queue.Dequeue();
            Assert.Throws <NullReferenceException>(() => queue.Dequeue());
        }
        public void CanDequeueTwoElm()
        {
            Node            nodeFirst  = new Node("first");
            Node            nodeSecond = new Node("second");
            QueueWithStacks queue      = new QueueWithStacks(nodeFirst);

            queue.Enqueue(nodeSecond);
            Node firstResult  = queue.Dequeue();
            Node secondResult = queue.Dequeue();

            Assert.Equal(nodeFirst, firstResult);
            Assert.Equal(nodeSecond, secondResult);
        }
        public void CanDequeueOneElm()
        {
            Node            nodeFirst   = new Node("first");
            QueueWithStacks queue       = new QueueWithStacks(nodeFirst);
            Node            firstResult = queue.Dequeue();

            Assert.Equal(nodeFirst, firstResult);
        }
Beispiel #5
0
        public void Dequeue_from_empty_stack()
        {
            QueueWithStacks <int> queue = new QueueWithStacks <int>();

            Assert.Throws <InvalidOperationException>(() =>
            {
                //Act
                return(queue.Dequeue());
            });
        }
Beispiel #6
0
        public void Dequeue_from_stack()
        {
            QueueWithStacks <int> queue = new QueueWithStacks <int>();

            queue.Enqueue(1);

            int result = queue.Dequeue();

            Assert.Equal(1, result);
        }
        public void NodesRemoved(object input)
        {
            Node node1 = new Node(10);
            Node node2 = new Node(input);

            QueueWithStacks queue = new QueueWithStacks(node2);

            queue.Enqueue(node1);

            Assert.Equal(input, queue.Dequeue().Value);
        }
Beispiel #8
0
        public void Can_Enequeue_Multiple_Nodes_And_Dequeue_What_Would_Be_The_Front_Nodes_Value()
        {
            QueueWithStacks <int> testQueueStack = new QueueWithStacks <int>();

            testQueueStack.Enqueue(1);
            testQueueStack.Enqueue(2);
            testQueueStack.Enqueue(3);
            testQueueStack.Enqueue(4);
            testQueueStack.Enqueue(5);
            int result = testQueueStack.Dequeue();

            Assert.Equal(1, result);
        }
Beispiel #9
0
        static void Main(string[] args)
        {
            QueueWithStacks stack = new QueueWithStacks();
            int             data;

            stack.Enqueue(1);
            stack.Enqueue(2);
            stack.Enqueue(3);
            data = stack.Dequeue();
            stack.Enqueue(4);
            stack.Enqueue(5);
            data = stack.Dequeue();
            stack.Enqueue(6);
            data = stack.Dequeue();
            data = stack.Dequeue();
            stack.Enqueue(7);
            stack.Enqueue(8);
            stack.Enqueue(9);
            data = stack.Dequeue();

            Console.Read();
        }
        public static void QueueWithStacks()
        {
            Node node1 = new Node(10);
            Node node2 = new Node(20);
            Node node3 = new Node(30);

            QueueWithStacks queue = new QueueWithStacks(node1);

            queue.Enqueue(node2);
            queue.Enqueue(node3);

            Console.WriteLine($"The front node value: {queue.Front.Value}");

            queue.Dequeue();
            Console.WriteLine($"The value of the removed node : {queue.Front.Value}");
        }
Beispiel #11
0
        public void Throw_An_Exception_When_Dequeue_Is_Called_On_Empty_QueueWithStack_Object()
        {
            QueueWithStacks <int> testQueueStack = new QueueWithStacks <int>();

            Assert.Throws <NullReferenceException>(() => testQueueStack.Dequeue());
        }