public void Test_add_and_clear() { MyDynamicArray <int> arr = new MyDynamicArray <int>(); for (int i = 0; i < 100; i++) { arr.Add(i); } arr.Clear(); Assert.True(arr.IsEmpty()); for (int i = 0; i < 1000; i++) { arr.Add(i); } arr.Clear(); Assert.True(arr.IsEmpty()); for (int i = 0; i < 10000; i++) { arr.Add(i); } arr.Clear(); Assert.True(arr.IsEmpty()); }
// Private helper methods for testing private void FillDynamicArray <T>(MyDynamicArray <T> arr, int length, T val) { for (int i = 0; i < length; i++) { arr.Add(val); } }
public void MyDynamicArray_Equals_OriginalArray() { List <int> originalArray = _arrayService.CreateArray(new List <int>()) as List <int>; MyDynamicArray <int> myDynamicArray = _arrayService.CreateArray(new MyDynamicArray <int>()) as MyDynamicArray <int>; Assert.Equal(myDynamicArray, originalArray); }
public void Test_removing_at_empty() { MyDynamicArray <int> arr = new MyDynamicArray <int>(); // assert Assert.Throws <ArgumentOutOfRangeException>(() => arr.RemoveAt(0)); }
public static T[] MergeSortBy<T, TKey>(this T[] array, Func<T, TKey> keySelector) { TKey[] keys = new TKey[array.Length]; MyDynamicArray<object> map = SortHelper.CreateMap(array, keys, keySelector); return SortHelper.OrderByMapToArray(array, map, keys.MergeSort()); }
public void Test_indexer_get_out_of_range(int index) { MyDynamicArray <int> arr = new MyDynamicArray <int>(); FillDynamicArray(arr, 100, 1); Assert.Throws <IndexOutOfRangeException>(() => arr[index]); }
public void Test_using_enumerator() { int[] elements = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; MyDynamicArray <int> arr = new MyDynamicArray <int>(100); using (var e = arr.GetEnumerator()) Assert.NotNull(e); }
public void ConstructorWithParametersTest() { MyDynamicArray<int> a = new MyDynamicArray<int>(15); MyDynamicArray<string> b = new MyDynamicArray<string>(30); Assert.AreEqual(15, a.Capacity); Assert.AreEqual(0, a.Length); Assert.AreEqual(30, b.Capacity); Assert.AreEqual(0, b.Length); }
public void Test_remove_at4() { MyDynamicArray <int> arr = new MyDynamicArray <int>(); FillDynamicArray(arr, 1000, 1); // assert Assert.Throws <ArgumentOutOfRangeException>(() => arr.RemoveAt(-500)); }
internal static IEnumerable <T> OrderByMap <T, TKey>(T[] array, MyDynamicArray <object> map, TKey[] keys) { for (int i = 0; i < map.Length; i++) { int index = map.IndexOf(keys.GetValue(i)); map[index] = $"CLEARED_{Guid.NewGuid()}"; yield return(array[index]); } }
public void Test_clear() { MyDynamicArray <int> arr = new MyDynamicArray <int>(); FillDynamicArray(arr, 1000, 100); arr.Clear(); // assert Assert.True(arr.IsEmpty()); }
internal static MyDynamicArray <object> CreateMap <T, TKey>(T[] array, TKey[] keys, Func <T, TKey> keySelector) { MyDynamicArray <object> map = new MyDynamicArray <object>(array.Length); for (int i = 0; i < array.Length; i++) { keys[i] = keySelector(array[i]); map[i] = keys.GetValue(i); } return(map); }
public void ConstructorWithCollectionTest() { List<int> col = new List<int>(); col.Add(2); col.Add(4); col.Add(6); col.Add(8); MyDynamicArray<int> arr = new MyDynamicArray<int>(col); Assert.AreEqual(4, arr.Capacity); Assert.AreEqual(4, arr.Length); Assert.AreEqual(arr.Length, arr.Capacity); Assert.AreEqual(2, arr[0]); Assert.AreEqual(4, arr[1]); Assert.AreEqual(6, arr[2]); Assert.AreEqual(8, arr[3]); }
public void Test_parameterless_constructor() { int expectedCapacity = 20; int expectedSize = 0; MyDynamicArray <int> arr = new MyDynamicArray <int>(); int actualCapacity = arr.Capacity; int actualSize = arr.Size; // assert Assert.Equal(expectedCapacity, actualCapacity); Assert.Equal(expectedSize, actualSize); Assert.True(arr.IsEmpty()); }
public void Test_resize_add(int originalCapacity, int elementsLength) { MyDynamicArray <int> arr = new MyDynamicArray <int>(originalCapacity); FillDynamicArray(arr, elementsLength, 1); // assert Assert.Equal(2 * originalCapacity, arr.Capacity); Assert.Equal(elementsLength, arr.Size); for (int i = 0; i < elementsLength; i++) { Assert.Equal(1, arr[i]); } }
public void Test_resize_remove() { int initialCapacity = 50; MyDynamicArray <int> arr = new MyDynamicArray <int>(initialCapacity); FillDynamicArray(arr, initialCapacity * 5, 1); for (int i = 0; i < initialCapacity * 5; i++) { arr.Remove(1); } // assert Assert.Equal(0, arr.Size); Assert.Equal(initialCapacity, arr.Capacity); }
public void Test_indexer_set_get() { MyDynamicArray <int> arr = new MyDynamicArray <int>(); int length = 1000000; FillDynamicArray(arr, length, 1); for (int i = 0; i < length; i++) { arr[i] = i; } for (int i = 0; i < length; i++) { Assert.Equal(i, arr[i]); } }
public void Test_add() { int[] elements = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; MyDynamicArray <int> arr = new MyDynamicArray <int>(); foreach (var e in elements) { arr.Add(e); } // assert for (int i = 0; i < arr.Size; i++) { Assert.Equal(elements[i], arr[i]); } }
public void Test_get_enumerator() { int[] elements = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; MyDynamicArray <int> arr = new MyDynamicArray <int>(100); foreach (var e in elements) { arr.Add(e); } int size = 0; foreach (var a in arr) { size++; Assert.True(Array.IndexOf(elements, a) != -1); } Assert.Equal(elements.Length, size); }
public void Test_add_and_remove() { MyDynamicArray <int> arr = new MyDynamicArray <int>(); for (int i = 0; i < 100; i++) { arr.Add(i); } for (int i = 0; i < 100; i++) { arr.Remove(i); } Assert.True(arr.IsEmpty()); for (int i = 0; i < 1000; i++) { arr.Add(i); } for (int i = 0; i < 1000; i++) { arr.Remove(i); } Assert.True(arr.IsEmpty()); for (int i = 0; i < 10000; i++) { arr.Add(i); } for (int i = 0; i < 10000; i++) { arr.Remove(i); } Assert.True(arr.IsEmpty()); }
internal static T[] OrderByMapToArray <T, TKey>(T[] array, MyDynamicArray <object> map, TKey[] keys) { return(OrderByMap(array, map, keys).ToArray()); }
public void DefaultConstructorTest() { MyDynamicArray<int> a = new MyDynamicArray<int>(); Assert.AreEqual(8, a.Capacity); Assert.AreEqual(0, a.Length); }