Esempio n. 1
0
        public void CreateQueue_EnqueueSomeElements_ShouldWorkCorrectly()
        {
            var linkedQueue = new LinkedQueue<int>();
            linkedQueue.Enqueue(2);
            linkedQueue.Enqueue(6);

            Assert.AreEqual(2, linkedQueue.Count);
            Assert.AreEqual(2, linkedQueue.Dequeue());
            Assert.AreEqual(6, linkedQueue.Dequeue());
        }
        public void Dequeue_EmptyQueue_ThrowsException()
        {
            var queue = new LinkedQueue<int>();

            queue.Dequeue();

            // Assert: expect an exception
        }
Esempio n. 3
0
        public void CreateQueue_DequeueSingleElement_ShouldWorkCorrectly()
        {
            var linkedQueue = new LinkedQueue<int>();
            linkedQueue.Enqueue(4);
            linkedQueue.Enqueue(6);
            linkedQueue.Enqueue(1);

            Assert.AreEqual(4, linkedQueue.Dequeue());
            Assert.AreEqual(2, linkedQueue.Count);
        }
        public void EnqueueDequeue_1000Elements_ShouldWorkCorrectly()
        {
            const int NumberOfElements = 1000;
            var queue = new LinkedQueue<int>();

            for (int i = 0; i < NumberOfElements; i++)
            {
                queue.Enqueue(i);
            }

            for (int i = 0; i < NumberOfElements; i++)
            {
                Assert.AreEqual(NumberOfElements - i, queue.Count);
                var element = queue.Dequeue();
                Assert.AreEqual(i, element);
                Assert.AreEqual(NumberOfElements - i - 1, queue.Count);
            }
        }
        public void EnqueueDequeue_ManyChunks_ShouldWorkCorrectly()
        {
            var queue = new LinkedQueue<int>();
            const int Chunks = 1000;

            int value = 1;
            for (int i = 0; i < Chunks; i++)
            {
                Assert.AreEqual(0, queue.Count);
                var chunkSize = i + 1;
                for (int counter = 0; counter < chunkSize; counter++)
                {
                    Assert.AreEqual(value - 1, queue.Count);
                    queue.Enqueue(value);
                    Assert.AreEqual(value, queue.Count);
                    value++;
                }

                for (int counter = 0; counter < chunkSize; counter++)
                {
                    value--;
                    Assert.AreEqual(value, queue.Count);
                    queue.Dequeue();
                    Assert.AreEqual(value - 1, queue.Count);
                }

                Assert.AreEqual(0, queue.Count);
            }
        }
        public void EnqueueDequeue_TypeString_ShouldWorkCorrectly()
        {
            var queue = new LinkedQueue<string>();
            var element = "some value";

            queue.Enqueue(element);
            var elementFromQueue = queue.Dequeue();

            Assert.AreEqual(0, queue.Count);
            Assert.AreEqual(element, elementFromQueue);
        }
Esempio n. 7
0
 public void CreateQueue_DequeueEmptyQueue_ShouldThrowException()
 {
     var linkedQueue = new LinkedQueue<int>();
     linkedQueue.Dequeue();
 }