public void Constructor_IncorrectParams_ThrowsExeption()
        {
            string[]          arr   = new string[10];
            CustomQueue <int> queue = new CustomQueue <int>();

            Assert.Throws <ArgumentException>(() => queue.CopyTo(arr, 0));
        }
        public void CustomQueue_CopyTo_NullArray_Test()
        {
            var customQueue = new CustomQueue <int>();

            customQueue.Enqueue(1);
            customQueue.Enqueue(2);
            customQueue.Enqueue(3);
            customQueue.Enqueue(4);

            Assert.Throws <ArgumentNullException>(() => customQueue.CopyTo(null, 2));
        }
        public void CopyToShouldThrowArgumentExceptionIfGivenArrayIsNull()
        {
            //Arange
            var queue = new CustomQueue <int>();

            //Act
            queue.Enqueue(1);
            var ex = Assert.ThrowsException <ArgumentException>(() => queue.CopyTo(null, 0));

            //Assert
            Assert.AreEqual(givenArrayWasNull, ex.Message);
        }
        public void CustomQueue_CopyTo_NegativeIndex_Test()
        {
            var array       = new[] { 7, 7, 7, 7, 7, 7, 7, 7 };
            var customQueue = new CustomQueue <int>();

            customQueue.Enqueue(1);
            customQueue.Enqueue(2);
            customQueue.Enqueue(3);
            customQueue.Enqueue(4);

            Assert.Throws <ArgumentOutOfRangeException>(() => customQueue.CopyTo(array, -2));
        }
        public void CustomQueue_CopyTo_InvalidBigIndex_Test()
        {
            var array       = new[] { 7, 7, 7, 7, 7, 7, 7, 7 };
            var customQueue = new CustomQueue <int>();

            customQueue.Enqueue(1);
            customQueue.Enqueue(2);
            customQueue.Enqueue(3);
            customQueue.Enqueue(4);

            Assert.Throws <InvalidOperationException>(() => customQueue.CopyTo(array, 20));
        }
        public void CustomQueue_CopyTo_InvalidIndex_NotEnoughPlaceForInsert_Test()
        {
            var array       = new[] { 7, 7, 7, 7, 7, 7, 7, 7 };
            var customQueue = new CustomQueue <int>();

            customQueue.Enqueue(1);
            customQueue.Enqueue(2);
            customQueue.Enqueue(3);
            customQueue.Enqueue(4);

            Assert.Throws <ArgumentException>(() => customQueue.CopyTo(array, 6));
        }
        public void CopyToShouldThrowArgumentExceptionIfGivenIndexIsTooBig()
        {
            //Arange
            var queue = new CustomQueue <int>();
            var array = new CustomArray <int>(queue.Count);

            //Act
            queue.Enqueue(1);
            var ex = Assert.ThrowsException <ArgumentException>(() => queue.CopyTo(array, 2));

            //Assert
            Assert.AreEqual(theGivenParametarWasTooBig, ex.Message);
        }
        public void CopyToShouldThrowIndexOutOfRangeExceptionIfGivenIndexIsLessThanZero()
        {
            //Arange
            var queue = new CustomQueue <int>();
            var array = new CustomArray <int>(queue.Count);

            //Act
            queue.Enqueue(1);
            var ex = Assert.ThrowsException <IndexOutOfRangeException>(() => queue.CopyTo(array, -1));

            //Assert
            Assert.AreEqual(givenParametarWasOutOfRange, ex.Message);
        }
        public void CustomQueue_CopyTo_Int_Test()
        {
            var array       = new[] { 7, 7, 7, 7, 7, 7, 7, 7 };
            var resultArray = new[] { 7, 7, 1, 2, 3, 4, 7, 7 };
            var customQueue = new CustomQueue <int>();

            customQueue.Enqueue(1);
            customQueue.Enqueue(2);
            customQueue.Enqueue(3);
            customQueue.Enqueue(4);

            customQueue.CopyTo(array, 2);

            CollectionAssert.AreEqual(array, resultArray);
        }
        public void CopyTo_CorrectParamsInt_FillsArrayWithQueueElements()
        {
            List <int> list = new List <int> {
                1, 2, 3, 4
            };
            CustomQueue <int> queue = new CustomQueue <int>(list);

            int expected = 1;

            int[] arr = { 88, 88, 88, 88, 88, 88 };
            queue.CopyTo(arr, 0);
            int actual = arr[0];

            Assert.AreEqual(expected, actual);
        }
 public void Queue_CopyTo_ArgumentException_Test()
 {
     string[] strArray = new string[2];
     Assert.That(() => queue.CopyTo(strArray, 1), Throws.TypeOf <ArgumentException>());
 }