public void QuickSortDecreaseTest(int[] array, int[] expectedArray)
 {
     DataStructure.ArrayList actual   = new DataStructure.ArrayList(array);
     DataStructure.ArrayList expected = new DataStructure.ArrayList(expectedArray);
     actual.SortDecrease();
     Assert.AreEqual(expected, actual);
 }
 public void DeleteElementsWithValueTest(int[] array, int value, int[] expectedArray)
 {
     DataStructure.ArrayList actual   = new DataStructure.ArrayList(array);
     DataStructure.ArrayList expected = new DataStructure.ArrayList(expectedArray);
     actual.DeleteElementsWithValue(value);
     Assert.AreEqual(expected, actual);
 }
 public void DeleteFromBiginningTest(int[] array, int[] expectedArray)
 {
     DataStructure.ArrayList actual = new DataStructure.ArrayList(array);
     actual.DeleteFromBiginning();
     DataStructure.ArrayList expected = new DataStructure.ArrayList(expectedArray);
     Assert.AreEqual(expected, actual);
 }
 public void AddToTest(int[] array, int idx, int value, int[] expectedArray)
 {
     DataStructure.ArrayList actual = new DataStructure.ArrayList(array);
     actual.AddTo(idx, value);
     DataStructure.ArrayList expected = new DataStructure.ArrayList(expectedArray);
     Assert.AreEqual(expected, actual);
 }
 public void DeleteNElementsFromBiginning(int[] array, int number, int[] expectedArray)
 {
     DataStructure.ArrayList actual = new DataStructure.ArrayList(array);
     actual.DeleteFromBiginning(number);
     DataStructure.ArrayList expected = new DataStructure.ArrayList(expectedArray);
     Assert.AreEqual(expected, actual);
 }
        public void GetByIndexTest(int[] array, int idx, int expected)
        {
            DataStructure.ArrayList list = new DataStructure.ArrayList(array);
            int actual = list.GetByIndex(idx);

            Assert.AreEqual(expected, actual);
        }
        public void GetIndexOfMinElementTest(int[] array, int expected)
        {
            DataStructure.ArrayList list = new DataStructure.ArrayList(array);
            int actual = list.GetIndexOfMinElement();

            Assert.AreEqual(expected, actual);
        }
 public void CopyListTest(int[] array, int[] expectedArray)
 {
     DataStructure.ArrayList list     = new DataStructure.ArrayList(array);
     DataStructure.ArrayList actual   = list.CopyList();
     DataStructure.ArrayList expected = new DataStructure.ArrayList(expectedArray);
     Assert.AreEqual(expected, actual);
 }
 public void ReversListTest(int[] array, int[] expectedArray)
 {
     DataStructure.ArrayList actual = new DataStructure.ArrayList(array);
     actual.ReversList();
     DataStructure.ArrayList expected = new DataStructure.ArrayList(expectedArray);
     Assert.AreEqual(expected, actual);
 }
        public void GetIndexByValueTest(int[] array, int value, int expected)
        {
            DataStructure.ArrayList list = new DataStructure.ArrayList(array);
            int actual = list.GetIndexByValue(value);

            Assert.AreEqual(expected, actual);
        }
        public void DeleteNElmentsFromTest(int[] array, int idx, int number, int[] expectedArray)
        {
            DataStructure.ArrayList actual   = new DataStructure.ArrayList(array);
            DataStructure.ArrayList expected = new DataStructure.ArrayList(expectedArray);

            actual.DeleteFrom(idx, number);
            Assert.AreEqual(expected, actual);
        }
        public void AddArrayToBiginningTest(int[] array, int[] addedArray, int[] expectedArray)
        {
            DataStructure.ArrayList actual = new DataStructure.ArrayList(array);
            actual.AddToBiginning(addedArray);
            DataStructure.ArrayList expected = new DataStructure.ArrayList(expectedArray);

            Assert.AreEqual(expected, actual);
        }
        public void DeleteNElementsFromNegativTest(int[] array, int idx, int number, string excepyion)
        {
            DataStructure.ArrayList actual = new DataStructure.ArrayList(array);
            switch (excepyion)
            {
            case "Index":
                Assert.Throws <IndexOutOfRangeException>(() => actual.DeleteFrom(idx, number));
                break;

            case "Argument":
                Assert.Throws <ArgumentOutOfRangeException>(() => actual.DeleteFrom(idx, number));
                break;
            }
        }
 public void AddToNegativeTest(int[] array, int idx, int value)
 {
     DataStructure.ArrayList actual = new DataStructure.ArrayList(array);
     Assert.Throws <IndexOutOfRangeException>(() => actual.AddTo(idx, value));
 }
 public void DeleteNElementsFromEndNegativTest(int[] array, int number)
 {
     DataStructure.ArrayList actual = new DataStructure.ArrayList(array);
     Assert.Throws <ArgumentOutOfRangeException>(() => actual.DeleteFromBiginning(number));
 }
 public void GetIndexOfMinElementNegativeTest(int[] array)
 {
     DataStructure.ArrayList actual = new DataStructure.ArrayList(array);
     Assert.Throws <InvalidOperationException>(() => actual.GetIndexOfMinElement());
 }
 public void GetIndexByValueNegativeTest(int[] array, int value)
 {
     DataStructure.ArrayList actual = new DataStructure.ArrayList(array);
     Assert.Throws <ArgumentException>(() => actual.GetIndexByValue(value));
 }
 public void GetByIndexNegativeTest(int[] array, int idx)
 {
     DataStructure.ArrayList actual = new DataStructure.ArrayList(array);
     Assert.Throws <IndexOutOfRangeException>(() => actual.GetByIndex(idx));
 }
 public void DeleteFromBiginningNegativeTest(int[] array)
 {
     DataStructure.ArrayList actual = new DataStructure.ArrayList(array);
     Assert.Throws <InvalidOperationException>(() => actual.DeleteFromBiginning());
 }
 public void SetByIndexNegativeTest(int[] array, int idx, int newValue)
 {
     DataStructure.ArrayList actual = new DataStructure.ArrayList(array);
     Assert.Throws <IndexOutOfRangeException>(() => actual[idx] = newValue);
 }