public void EnqueueMultipleDequeue()
        {
            var queue = new FirstInFirstOut <Guid>();
            var a     = Guid.NewGuid();
            var b     = Guid.NewGuid();
            var c     = Guid.NewGuid();

            queue.Enqueue(a);
            queue.Enqueue(b);
            queue.Enqueue(c);

            Assert.AreEqual <Guid>(a, queue.Dequeue());
            Assert.AreEqual <Guid>(b, queue.Dequeue());
            Assert.AreEqual <Guid>(c, queue.Dequeue());
        }
Пример #2
0
        public void TestDequeue1()
        {
            ReadOnlyCollection <int> expected = new ReadOnlyCollection <int>(new int[] { 1, 3, 5, 7, 9, 11 });
            FirstInFirstOut <int>    fifo     = new FirstInFirstOut <int>(expected);

            Assert.AreEqual(expected[0], fifo.Dequeue());
            Assert.AreEqual(expected.Count - 1, fifo.Queue.Count);

            Assert.AreEqual(expected[1], fifo.Dequeue());
            Assert.AreEqual(expected[2], fifo.Dequeue());

            Assert.AreEqual(expected[3], fifo.Peek());
            Assert.AreEqual(expected[3], fifo.Dequeue());
            Assert.AreEqual(expected[4], fifo.Peek());
        }
Пример #3
0
        static Queuing()
        {
            _Queue.Added += (s, args) =>
            {
                if (!BackgroundWorker.IsBusy)
                {
                    BackgroundWorker.RunWorkerAsync();
                }
            };

            BackgroundWorker.DoWork += (s, args) =>
            {
                // Get the next item from the queue
                string key  = _Queue.Dequeue();
                Item   item = CacheManager.Items[key];

                // Perform whatever work there is to do on it
                Treatment.GenerateThumbnail(Color.Transparent, key);

                // Saves the modified item
                CacheManager.Items[key] = item;
                BackgroundWorker.ReportProgress(100 * _Queue.Count / _Queue.PeakCount);
            };

            BackgroundWorker.RunWorkerCompleted += (s, args) =>
            {
                if (_Queue.Count > 0)
                {
                    BackgroundWorker.RunWorkerAsync();
                }
            };
        }
        public void EnqueueDequeue()
        {
            var queue = new FirstInFirstOut <Guid>();
            var g     = Guid.NewGuid();

            queue.Enqueue(g);
            var returned = queue.Dequeue();

            Assert.AreEqual <Guid>(g, returned);
        }
        public void Count()
        {
            var queue = new FirstInFirstOut <bool>();

            Assert.AreEqual <int>(0, queue.Count);
            queue.Enqueue(true);
            Assert.AreEqual <int>(1, queue.Count);
            queue.Dequeue();
            Assert.AreEqual <int>(0, queue.Count);
        }
Пример #6
0
        public void TestDequeue2()
        {
            ReadOnlyCollection <int> expected = new ReadOnlyCollection <int>(new int[] { 1, 3, 5, 7, 9, 11 });
            FirstInFirstOut <int>    fifo     = new FirstInFirstOut <int>(expected);

            Assert.AreEqual(expected[0], fifo.Dequeue());
            Assert.AreEqual(expected[1], fifo.Dequeue());
            fifo.Enqueue(10);
            Assert.AreEqual(expected[2], fifo.Dequeue());
            fifo.Enqueue(6);
            Assert.AreEqual(expected[3], fifo.Dequeue());

            expected = new ReadOnlyCollection <int>(new int[] { 9, 11, 10, 6 });
            ReadOnlyCollection <int> actual = fifo.Queue;

            Assert.AreEqual(expected.Count, actual.Count);
            Assert.AreEqual(expected[0], actual[0]);
            Assert.AreEqual(expected[1], actual[1]);
            Assert.AreEqual(expected[2], actual[2]);
            Assert.AreEqual(expected[3], actual[3]);
        }
Пример #7
0
        public void TestDequeue2()
        {
            ReadOnlyCollection<int> expected = new ReadOnlyCollection<int>(new int[] { 1, 3, 5, 7, 9, 11 });
            FirstInFirstOut<int> fifo = new FirstInFirstOut<int>(expected);

            Assert.AreEqual(expected[0], fifo.Dequeue());
            Assert.AreEqual(expected[1], fifo.Dequeue());
            fifo.Enqueue(10);
            Assert.AreEqual(expected[2], fifo.Dequeue());
            fifo.Enqueue(6);
            Assert.AreEqual(expected[3], fifo.Dequeue());

            expected = new ReadOnlyCollection<int>(new int[] { 9, 11, 10, 6 });
            ReadOnlyCollection<int> actual = fifo.Queue;
            Assert.AreEqual(expected.Count, actual.Count);
            Assert.AreEqual(expected[0], actual[0]);
            Assert.AreEqual(expected[1], actual[1]);
            Assert.AreEqual(expected[2], actual[2]);
            Assert.AreEqual(expected[3], actual[3]);
        }
Пример #8
0
        public void TestDequeue1()
        {
            ReadOnlyCollection<int> expected = new ReadOnlyCollection<int>(new int[] { 1, 3, 5, 7, 9, 11 });
            FirstInFirstOut<int> fifo = new FirstInFirstOut<int>(expected);

            Assert.AreEqual(expected[0], fifo.Dequeue());
            Assert.AreEqual(expected.Count - 1, fifo.Queue.Count);

            Assert.AreEqual(expected[1], fifo.Dequeue());
            Assert.AreEqual(expected[2], fifo.Dequeue());

            Assert.AreEqual(expected[3], fifo.Peek());
            Assert.AreEqual(expected[3], fifo.Dequeue());
            Assert.AreEqual(expected[4], fifo.Peek());
        }