public void Reverse_RepeatedValues(int listLength, int index, int count)
{
PooledList <T> list = GenericListFactory(1);
for (int i = 1; i < listLength; i++)
{
list.Add(list[0]);
}
PooledList <T> listBefore = list.ToPooledList();
list.Reverse(index, count);
for (int i = 0; i < index; i++)
{
Assert.Equal(list[i], listBefore[i]); //"Expect them to be the same."
}
int j = 0;
for (int i = index; i < index + count; i++)
{
Assert.Equal(list[i], listBefore[index + count - (j + 1)]); //"Expect them to be the same."
j++;
}
for (int i = index + count; i < listBefore.Count; i++)
{
Assert.Equal(list[i], listBefore[i]); //"Expect them to be the same."
}
list.Dispose();
listBefore.Dispose();
}
public void AddRange_NullEnumerable_ThrowsArgumentNullException(int count)
{
PooledList <T> list = GenericListFactory(count);
var listBeforeAdd = list.ToPooledList();
Assert.Throws <ArgumentNullException>(() => list.AddRange((IEnumerable <T>)null));
Assert.Equal(listBeforeAdd, list);
list.Dispose();
listBeforeAdd.Dispose();
}
public void RemoveAll_AllElements(int count)
{
PooledList <T> list = GenericListFactory(count);
PooledList <T> beforeList = list.ToPooledList();
int removedCount = list.RemoveAll((value) => { return(true); });
Assert.Equal(count, removedCount);
Assert.Equal(0, list.Count);
list.Dispose();
beforeList.Dispose();
}
public void IndexOf_NoDuplicates(IndexOfMethod indexOfMethod, int count, bool frontToBackOrder)
{
PooledList <T> list = GenericListFactory(count);
PooledList <T> expectedList = list.ToPooledList();
IndexOfDelegate IndexOf = IndexOfDelegateFromType(indexOfMethod);
Assert.All(Enumerable.Range(0, count), i =>
{
Assert.Equal(i, IndexOf(list, expectedList[i]));
});
list.Dispose();
expectedList.Dispose();
}
public void Reverse(int listLength)
{
PooledList <T> list = GenericListFactory(listLength);
PooledList <T> listBefore = list.ToPooledList();
list.Reverse();
for (int i = 0; i < listBefore.Count; i++)
{
Assert.Equal(list[i], listBefore[listBefore.Count - (i + 1)]); //"Expect them to be the same."
}
list.Dispose();
listBefore.Dispose();
}
public void RemoveAll_DefaultElements(int count)
{
PooledList <T> list = GenericListFactory(count);
PooledList <T> beforeList = list.ToPooledList();
bool EqualsDefaultElement(T value)
{
return(default(T) == null ? value == null : default(T).Equals(value));
}
int expectedCount = beforeList.Count((value) => EqualsDefaultElement(value));
int removedCount = list.RemoveAll(EqualsDefaultElement);
Assert.Equal(expectedCount, removedCount);
list.Dispose();
beforeList.Dispose();
}
public void BinarySearch_ForEveryItemWithDuplicates(int count)
{
if (count > 0)
{
PooledList <T> list = GenericListFactory(count);
list.Add(list[0]);
list.Sort();
PooledList <T> beforeList = list.ToPooledList();
Assert.All(Enumerable.Range(0, list.Count), index =>
{
Assert.True(list.BinarySearch(beforeList[index]) >= 0);
Assert.True(list.BinarySearch(beforeList[index], GetIComparer()) >= 0);
Assert.Equal(beforeList[index], list[index]);
});
list.Dispose();
}
}
public void ConvertAll()
{
var list = new PooledList <int>(new int[] { 1, 2, 3 });
var before = list.ToPooledList();
var after = list.ConvertAll((i) => { return(10 * i); });
Assert.Equal(before.Count, list.Count);
Assert.Equal(before.Count, after.Count);
for (int i = 0; i < list.Count; i++)
{
Assert.Equal(before[i], list[i]);
Assert.Equal(before[i] * 10, after[i]);
}
list.Dispose();
before.Dispose();
after.Dispose();
}
public void Remove_Range(int listLength, int index, int count)
{
PooledList <T> list = GenericListFactory(listLength);
PooledList <T> beforeList = list.ToPooledList();
list.RemoveRange(index, count);
Assert.Equal(list.Count, listLength - count); //"Expected them to be the same."
for (int i = 0; i < index; i++)
{
Assert.Equal(list[i], beforeList[i]); //"Expected them to be the same."
}
for (int i = index; i < count - (index + count); i++)
{
Assert.Equal(list[i], beforeList[i + count]); //"Expected them to be the same."
}
list.Dispose();
beforeList.Dispose();
}
public void LastIndexOf_int_OrderIsCorrectWithManyDuplicates(int count)
{
PooledList <T> list = GenericListFactory(count);
PooledList <T> withoutDuplicates = list.ToPooledList();
list.AddRange(list);
list.AddRange(list);
list.AddRange(list);
Assert.All(Enumerable.Range(0, count), i =>
{
Assert.All(Enumerable.Range(0, 4), j =>
{
int expectedIndex = (j * count) + i;
Assert.Equal(expectedIndex, list.LastIndexOf(withoutDuplicates[i], (count * (j + 1)) - 1));
Assert.Equal(expectedIndex, list.LastIndexOf(withoutDuplicates[i], (count * (j + 1)) - 1, count));
});
});
list.Dispose();
withoutDuplicates.Dispose();
}
public void AddRange(EnumerableType enumerableType, int listLength, int enumerableLength, int numberOfMatchingElements, int numberOfDuplicateElements)
{
PooledList <T> list = GenericListFactory(listLength);
var listBeforeAdd = list.ToPooledList();
IEnumerable <T> enumerable = CreateEnumerable(enumerableType, list, enumerableLength, numberOfMatchingElements, numberOfDuplicateElements);
list.AddRange(enumerable);
// Check that the first section of the List is unchanged
Assert.All(Enumerable.Range(0, listLength), index =>
{
Assert.Equal(listBeforeAdd[index], list[index]);
});
// Check that the added elements are correct
Assert.All(Enumerable.Range(0, enumerableLength), index =>
{
Assert.Equal(enumerable.ElementAt(index), list[index + listLength]);
});
list.Dispose();
}
public void BinarySearch_ForEveryItemWithoutDuplicates(int count)
{
PooledList <T> list = GenericListFactory(count);
foreach (T item in list)
{
while (list.Count((value) => value.Equals(item)) > 1)
{
list.Remove(item);
}
}
list.Sort();
PooledList <T> beforeList = list.ToPooledList();
Assert.All(Enumerable.Range(0, list.Count), index =>
{
Assert.Equal(index, list.BinarySearch(beforeList[index]));
Assert.Equal(index, list.BinarySearch(beforeList[index], GetIComparer()));
Assert.Equal(beforeList[index], list[index]);
});
list.Dispose();
}
public void IndexOf_OrderIsCorrect(IndexOfMethod indexOfMethod, int count, bool frontToBackOrder)
{
PooledList <T> list = GenericListFactory(count);
PooledList <T> withoutDuplicates = list.ToPooledList();
list.AddRange(list);
IndexOfDelegate IndexOf = IndexOfDelegateFromType(indexOfMethod);
Assert.All(Enumerable.Range(0, count), i =>
{
if (frontToBackOrder)
{
Assert.Equal(i, IndexOf(list, withoutDuplicates[i]));
}
else
{
Assert.Equal(count + i, IndexOf(list, withoutDuplicates[i]));
}
});
list.Dispose();
withoutDuplicates.Dispose();
}
