public void DequeueMax_OneItem_ExpectReturnItem()
        {
            var queue = new MaxPriorityQueue<int>();
            queue.Add(ITEM);

            var dequeuedItem = queue.DequeueMax();

            Assert.AreEqual(ITEM, dequeuedItem);
        }
        public void DequeueMax_OneItem_ExpectCountDecrement()
        {
            var queue = new MaxPriorityQueue<int>();
            queue.Add(ITEM);

            queue.DequeueMax();

            Assert.AreEqual(0, queue.Count);
        }
示例#3
0
        public void MaxPriorityQueue_SingleEnqueueDequeueTest()
        {
            string test  = "test";
            var    queue = new MaxPriorityQueue <string>();

            queue.Enqueue(test);

            Assert.IsFalse(queue.IsEmpty);
            Assert.AreEqual(1, queue.Size);

            var dequeued = queue.DequeueMax();

            Assert.IsTrue(queue.IsEmpty);
            Assert.AreEqual(0, queue.Size);
            Assert.AreEqual(test, dequeued);
        }
示例#4
0
        public void MaxPriorityQueue_MultipleEnqueueDequeueTest()
        {
            var testData = new int[] { 12, 0, 3, 9, 1, 3, 4, 4, 5, 2, 13, 7, 8, 3, 11, 14, 15 };
            var queue    = new MaxPriorityQueue <int>();

            foreach (var item in testData)
            {
                queue.Enqueue(item);
            }

            Assert.IsFalse(queue.IsEmpty);
            Assert.AreEqual(testData.Length, queue.Size);

            var dequeued = queue.DequeueMax();

            Assert.IsFalse(queue.IsEmpty);
            Assert.AreEqual(testData.Length - 1, queue.Size);
            Assert.AreEqual(15, dequeued);

            dequeued = queue.DequeueMax();

            Assert.IsFalse(queue.IsEmpty);
            Assert.AreEqual(testData.Length - 2, queue.Size);
            Assert.AreEqual(14, dequeued);

            dequeued = queue.Max;

            Assert.IsFalse(queue.IsEmpty);
            Assert.AreEqual(testData.Length - 2, queue.Size);
            Assert.AreEqual(13, dequeued);

            dequeued = queue.DequeueMax();

            Assert.IsFalse(queue.IsEmpty);
            Assert.AreEqual(testData.Length - 3, queue.Size);
            Assert.AreEqual(13, dequeued);

            dequeued = queue.DequeueMax();

            Assert.IsFalse(queue.IsEmpty);
            Assert.AreEqual(testData.Length - 4, queue.Size);
            Assert.AreEqual(12, dequeued);

            dequeued = queue.DequeueMax();

            Assert.IsFalse(queue.IsEmpty);
            Assert.AreEqual(testData.Length - 5, queue.Size);
            Assert.AreEqual(11, dequeued);

            dequeued = queue.DequeueMax();

            Assert.IsFalse(queue.IsEmpty);
            Assert.AreEqual(testData.Length - 6, queue.Size);
            Assert.AreEqual(9, dequeued);

            dequeued = queue.DequeueMax();

            Assert.IsFalse(queue.IsEmpty);
            Assert.AreEqual(testData.Length - 7, queue.Size);
            Assert.AreEqual(8, dequeued);

            dequeued = queue.DequeueMax();

            Assert.IsFalse(queue.IsEmpty);
            Assert.AreEqual(testData.Length - 8, queue.Size);
            Assert.AreEqual(7, dequeued);

            dequeued = queue.DequeueMax();

            Assert.IsFalse(queue.IsEmpty);
            Assert.AreEqual(testData.Length - 9, queue.Size);
            Assert.AreEqual(5, dequeued);

            dequeued = queue.DequeueMax();

            Assert.IsFalse(queue.IsEmpty);
            Assert.AreEqual(testData.Length - 10, queue.Size);
            Assert.AreEqual(4, dequeued);

            dequeued = queue.DequeueMax();

            Assert.IsFalse(queue.IsEmpty);
            Assert.AreEqual(testData.Length - 11, queue.Size);
            Assert.AreEqual(4, dequeued);

            dequeued = queue.DequeueMax();

            Assert.IsFalse(queue.IsEmpty);
            Assert.AreEqual(testData.Length - 12, queue.Size);
            Assert.AreEqual(3, dequeued);

            dequeued = queue.DequeueMax();

            Assert.IsFalse(queue.IsEmpty);
            Assert.AreEqual(testData.Length - 13, queue.Size);
            Assert.AreEqual(3, dequeued);

            dequeued = queue.DequeueMax();

            Assert.IsFalse(queue.IsEmpty);
            Assert.AreEqual(testData.Length - 14, queue.Size);
            Assert.AreEqual(3, dequeued);

            dequeued = queue.DequeueMax();

            Assert.IsFalse(queue.IsEmpty);
            Assert.AreEqual(testData.Length - 15, queue.Size);
            Assert.AreEqual(2, dequeued);

            dequeued = queue.DequeueMax();

            Assert.IsFalse(queue.IsEmpty);
            Assert.AreEqual(testData.Length - 16, queue.Size);
            Assert.AreEqual(1, dequeued);

            dequeued = queue.DequeueMax();

            Assert.IsTrue(queue.IsEmpty);
            Assert.AreEqual(0, queue.Size);
            Assert.AreEqual(0, dequeued);
        }
示例#5
0
        public void MaxPriorityQueue_DequeueMaxFromEmptyQueueTest()
        {
            var queue = new MaxPriorityQueue <string>();

            queue.DequeueMax();
        }
        public void DequeueMax_TwoNotEqualItems_ExpectReturnMax()
        {
            var queue = CreateQueueAddTwoNotEqualItems();
            queue.Add(MIN_ITEM);
            queue.Add(MAX_ITEM);

            var dequeuedItem = queue.DequeueMax();
            Assert.AreEqual(MAX_ITEM, dequeuedItem);

            //check order of insertion does not matter
            queue = new MaxPriorityQueue<int>();
            queue.Add(MAX_ITEM);
            queue.Add(MIN_ITEM);

            dequeuedItem = queue.DequeueMax();
            Assert.AreEqual(MAX_ITEM, dequeuedItem);
        }
        public void DequeueMax_EmptyQueue_ExpectThrowInvalidOperationException()
        {
            var queue = new MaxPriorityQueue<int>();

            queue.DequeueMax();
        }
        public void UltimateTest()
        {
            const int COUNT = 100000;

            var random = new Random();

            var array = new int[COUNT];
            var queue = new MaxPriorityQueue<int>();

            for (var i = 0; i < COUNT; i++)
            {
                array[i] = random.Next(COUNT);
                queue.Add(array[i]);
            }

            Array.Sort(array);
            Array.Reverse(array);

            var numbersFromQueue = new int[COUNT];
            for (var i = 0; i < COUNT; i++)
            {
                numbersFromQueue[i] = queue.DequeueMax();
            }

            Assert.AreEqual(0, queue.Count);
            CollectionAssert.AreEqual(array, numbersFromQueue);
        }