public void CreateQueueWithNegativeCapacityThrowsException()
        {
            //Arrange
            var queue = new StaticQueue <string>(-2);

            //Act
            //Assert
        }
        public void DequeueOnEmptyQueueThrowsException()
        {
            //Arrange
            var queue = new StaticQueue <string>(4);

            //Act
            queue.Dequeue();

            //Assert
        }
        public void CreateQueueFromCollectionWorksCorrectly()
        {
            //Arrange
            var collection = new string[] { "one", "two", "three", "four" };
            var queue      = new StaticQueue <string>(collection);

            //Act
            var array = queue.ToArray();

            //Assert
            CollectionAssert.AreEqual(collection, array);
        }
        public void CreateEmptyQueueWorksCorrectly()
        {
            //Arrange
            var queue    = new StaticQueue <string>();
            int expected = 0;

            //Act
            int count = queue.Count;

            //Assert
            Assert.AreEqual(expected, count);
        }
        public void EnumarateEmptyQueueDoesntEnumerate()
        {
            //Arrange
            var  queue     = new StaticQueue <string>(4);
            bool enumerate = false;

            //Act
            foreach (var item in queue)
            {
                enumerate = true;
            }

            //Assert
            Assert.IsFalse(enumerate);
        }
Exemplo n.º 6
0
        public async Task Start(int showId)
        {
            StaticQueue.ClearQueue();
            StaticQueue.Enable();

            if (showId < 0)
            {
                showId = await this.showService.GetMaxShowId().ConfigureAwait(false);

                showId += 1;
            }

            StaticQueue.AddShowIds(showId);

            // assume the worker is continuously running and will pick this up shortly.
        }
        public void QueueEnqueueWorksCorrectly()
        {
            //Arrange
            var    queue         = new StaticQueue <string>(4);
            string expected      = "one";
            int    expectedCount = 2;

            //Act
            queue.Enqueue("one");
            queue.Enqueue("two");
            int count = queue.Count;

            //Assert
            Assert.AreEqual(expected, queue.Peek());
            Assert.AreEqual(expectedCount, count);
        }
        public void QueueToArrayWorksCorrectly()
        {
            //Arrange
            var collection = new string[] { "one", "two", "three", "four" };
            var queue      = new StaticQueue <string>(4);

            //Act
            queue.Enqueue("one");
            queue.Enqueue("two");
            queue.Enqueue("three");
            queue.Enqueue("four");

            var array = queue.ToArray();

            //Assert
            CollectionAssert.AreEqual(collection, array);
        }
        public void QueueClearWorksCorrectly()
        {
            //Arrange
            var queue    = new StaticQueue <string>(4);
            int expected = 0;

            //Act
            queue.Enqueue("one");
            queue.Enqueue("two");
            queue.Enqueue("three");
            queue.Enqueue("four");
            queue.Clear();
            int count = queue.Count;

            //Assert
            Assert.AreEqual(expected, count);
        }
        public void QueuePeekNullWorksCorrectly()
        {
            //Arrange
            var    queue      = new StaticQueue <string>(4);
            var    collection = new string[] { null, "one", "two", "three", "four" };
            string input      = null;

            //Act
            queue.Enqueue(input);
            queue.Enqueue("one");
            queue.Enqueue("two");
            queue.Enqueue("three");
            queue.Enqueue("four");

            var result = queue.Peek();

            //Assert
            Assert.AreEqual(input, result);
        }
        public void QueueContainsWorksCorrectly()
        {
            //Arrange
            var queue = new StaticQueue <string>(4);

            //Act
            queue.Enqueue("one");
            queue.Enqueue("two");
            queue.Enqueue("three");
            queue.Enqueue("four");
            var contains = queue.Contains("two");

            queue.Dequeue();
            var doesNotContain = queue.Contains("one");

            //Assert
            Assert.IsTrue(contains);
            Assert.IsFalse(doesNotContain);
        }
        public void QueueDequeueWorksCorrectly()
        {
            //Arrange
            var    queue         = new StaticQueue <string>(4);
            string expected      = "one";
            int    expectedCount = 3;

            //Act
            queue.Enqueue("one");
            queue.Enqueue("two");
            queue.Enqueue("three");
            queue.Enqueue("four");

            string result = queue.Dequeue();
            int    count  = queue.Count;

            //Assert
            Assert.AreEqual(expected, result);
            Assert.AreEqual(expectedCount, count);
        }
        public void QueueEnumarateWorksCorrectly()
        {
            //Arrange
            var expected = new List <string> {
                "one", "two", "three", "four"
            };
            var queue  = new StaticQueue <string>(4);
            var result = new List <string>();

            //Act
            queue.Enqueue("one");
            queue.Enqueue("two");
            queue.Enqueue("three");
            queue.Enqueue("four");

            foreach (var item in queue)
            {
                result.Add(item);
            }

            //Assert
            CollectionAssert.AreEqual(expected, result);
        }
Exemplo n.º 14
0
#pragma warning disable CA1822 // Mark members as static
        public void Stop()
#pragma warning restore CA1822 // Mark members as static
        {
            StaticQueue.ClearQueue();
        }