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);
}
