public void RemoveAtTest()
{
try
{
int[] removeAt = Enumerable.Range(0, 5).RemoveAt(-1).ToArray();
Assert.Fail(string.Join(", ", removeAt.Select(int32 => int32.ToString())));
}
catch (ArgumentOutOfRangeException exception)
{
Assert.AreEqual("index", exception.ParamName);
}
EnumerableAssert.AreSequentialEqual(new int[] { 1, 2, 3, 4 }, Enumerable.Range(0, 5).RemoveAt(0));
EnumerableAssert.AreSequentialEqual(new int[] { 0, 2, 3, 4 }, Enumerable.Range(0, 5).RemoveAt(1));
EnumerableAssert.AreSequentialEqual(new int[] { 0, 1, 3, 4 }, Enumerable.Range(0, 5).RemoveAt(2));
EnumerableAssert.AreSequentialEqual(new int[] { 0, 1, 2, 4 }, Enumerable.Range(0, 5).RemoveAt(3));
EnumerableAssert.AreSequentialEqual(new int[] { 0, 1, 2, 3 }, Enumerable.Range(0, 5).RemoveAt(4));
try
{
int[] removeAt = Enumerable.Range(0, 5).RemoveAt(5).ToArray();
Assert.Fail(string.Join(", ", removeAt.Select(int32 => int32.ToString())));
}
catch (ArgumentOutOfRangeException exception)
{
Assert.AreEqual("index", exception.ParamName);
}
try
{
int[] removeAt = Enumerable.Range(0, 5).RemoveAt(6).ToArray();
Assert.Fail(string.Join(", ", removeAt.Select(int32 => int32.ToString())));
}
catch (ArgumentOutOfRangeException exception)
{
Assert.AreEqual("index", exception.ParamName);
}
}
public void MaxRangeIsMaximumIntValue()
{
var range = Linq.Range(int.MaxValue, 1);
range.Should().OnlyContain(x => x == int.MaxValue);
range.Should().HaveCount(1);
}
public void InsertTest()
{
try
{
int[] insert = Enumerable.Range(0, 5).Insert(-1, 5).ToArray();
Assert.Fail(string.Join(", ", insert.Select(int32 => int32.ToString())));
}
catch (ArgumentOutOfRangeException exception)
{
Assert.AreEqual("index", exception.ParamName);
}
EnumerableAssert.AreSequentialEqual(new int[] { 5, 0, 1, 2, 3, 4 }, Enumerable.Range(0, 5).Insert(0, 5));
EnumerableAssert.AreSequentialEqual(new int[] { 0, 5, 1, 2, 3, 4 }, Enumerable.Range(0, 5).Insert(1, 5));
EnumerableAssert.AreSequentialEqual(new int[] { 0, 1, 5, 2, 3, 4 }, Enumerable.Range(0, 5).Insert(2, 5));
EnumerableAssert.AreSequentialEqual(new int[] { 0, 1, 2, 5, 3, 4 }, Enumerable.Range(0, 5).Insert(3, 5));
EnumerableAssert.AreSequentialEqual(new int[] { 0, 1, 2, 3, 5, 4 }, Enumerable.Range(0, 5).Insert(4, 5));
EnumerableAssert.AreSequentialEqual(new int[] { 0, 1, 2, 3, 4, 5 }, Enumerable.Range(0, 5).Insert(5, 5));
try
{
int[] insert = Enumerable.Range(0, 5).Insert(6, 5).ToArray();
Assert.Fail(string.Join(", ", insert.Select(int32 => int32.ToString())));
}
catch (ArgumentOutOfRangeException exception)
{
Assert.AreEqual("index", exception.ParamName);
}
}
public void ConsumeReallyConsumes()
{
var counter = 0;
var sequence = LinqEnumerable.Range(0, 10).Pipe(x => counter++);
sequence.Consume();
Assert.AreEqual(10, counter);
}
public void IndexOfTest()
{
Assert.AreEqual(-1, Enumerable.Range(0, 5).IndexOf(-1));
Assert.AreEqual(-1, Enumerable.Range(0, 5).IndexOf(6));
Assert.AreEqual(0, Enumerable.Range(0, 5).IndexOf(0));
Assert.AreEqual(1, Enumerable.Range(0, 5).IndexOf(1));
Assert.AreEqual(-1, Enumerable.Repeat("a", 5).IndexOf("A"));
Assert.AreEqual(0, Enumerable.Repeat("a", 5).IndexOf("A", comparer: StringComparer.OrdinalIgnoreCase));
}
static void Main(string[] args)
{
var values = new List <int>(Linq.Range(0, 10));
var useLinqFirst = Linq.First(values);
Console.WriteLine("LINQ First(): {0}", useLinqFirst);
var useMyFirst = values.First();
Console.WriteLine("My First(): {0}", useMyFirst);
Console.ReadLine();
}
public void RemoveTest()
{
EnumerableAssert.AreSequentialEqual(new int[] { 0, 1, 2, 3, 4 }, Enumerable.Range(0, 5).Remove(-1));
EnumerableAssert.AreSequentialEqual(new int[] { 1, 2, 3, 4 }, Enumerable.Range(0, 5).Remove(0));
EnumerableAssert.AreSequentialEqual(new int[] { 0, 2, 3, 4 }, Enumerable.Range(0, 5).Remove(1));
EnumerableAssert.AreSequentialEqual(new int[] { 0, 1, 3, 4 }, Enumerable.Range(0, 5).Remove(2));
EnumerableAssert.AreSequentialEqual(new int[] { 0, 1, 2, 4 }, Enumerable.Range(0, 5).Remove(3));
EnumerableAssert.AreSequentialEqual(new int[] { 0, 1, 2, 3 }, Enumerable.Range(0, 5).Remove(4));
EnumerableAssert.AreSequentialEqual(new int[] { 0, 1, 2, 3, 4 }, Enumerable.Range(0, 5).Remove(5));
EnumerableAssert.AreSequentialEqual(new int[] { 0, 1, 2, 3, 4 }, Enumerable.Range(0, 5).Remove(6));
}
public void LastIndexOfTest()
{
Assert.AreEqual(-1, Enumerable.Range(0, 5).LastIndexOf(-1));
Assert.AreEqual(-1, Enumerable.Range(0, 5).LastIndexOf(6));
Assert.AreEqual(0, Enumerable.Range(0, 5).LastIndexOf(0));
Assert.AreEqual(1, Enumerable.Range(0, 5).LastIndexOf(1));
Assert.AreEqual(4, Enumerable.Repeat(0, 5).LastIndexOf(0));
Assert.AreEqual(6, Enumerable.Repeat(0, 5).Concat(Enumerable.Range(0, 5)).LastIndexOf(1));
Assert.AreEqual(-1, Enumerable.Repeat("a", 5).LastIndexOf("A"));
Assert.AreEqual(4, Enumerable.Repeat("a", 5).LastIndexOf("A", StringComparer.OrdinalIgnoreCase));
}
public void RemoveTest()
{
try
{
int[] remove = Enumerable.Range(0, 5).Remove(-1).ToArray();
Assert.Fail(string.Join(", ", remove.Select(int32 => int32.ToString())));
}
catch (ArgumentOutOfRangeException exception)
{
Assert.AreEqual("remove", exception.ParamName);
}
EnumerableAssert.AreSequentialEqual(new int[] { 1, 2, 3, 4 }, Enumerable.Range(0, 5).Remove(0));
EnumerableAssert.AreSequentialEqual(new int[] { 0, 2, 3, 4 }, Enumerable.Range(0, 5).Remove(1));
EnumerableAssert.AreSequentialEqual(new int[] { 0, 1, 3, 4 }, Enumerable.Range(0, 5).Remove(2));
EnumerableAssert.AreSequentialEqual(new int[] { 0, 1, 2, 4 }, Enumerable.Range(0, 5).Remove(3));
EnumerableAssert.AreSequentialEqual(new int[] { 0, 1, 2, 3 }, Enumerable.Range(0, 5).Remove(4));
try
{
int[] remove = Enumerable.Range(0, 5).Remove(5).ToArray();
Assert.Fail(string.Join(", ", remove.Select(int32 => int32.ToString())));
}
catch (ArgumentOutOfRangeException exception)
{
Assert.AreEqual("remove", exception.ParamName);
}
try
{
int[] remove = Enumerable.Range(0, 5).Remove(6).ToArray();
Assert.Fail(string.Join(", ", remove.Select(int32 => int32.ToString())));
}
catch (ArgumentOutOfRangeException exception)
{
Assert.AreEqual("remove", exception.ParamName);
}
EnumerableAssert.AreSequentialEqual(new int[] { 0, 1, 2, 3, 4 }, Enumerable.Range(0, 5).Remove(-1, null, ListQueryMode.Normalize));
EnumerableAssert.AreSequentialEqual(new int[] { 1, 2, 3, 4 }, Enumerable.Range(0, 5).Remove(0, null, ListQueryMode.Normalize));
EnumerableAssert.AreSequentialEqual(new int[] { 0, 2, 3, 4 }, Enumerable.Range(0, 5).Remove(1, null, ListQueryMode.Normalize));
EnumerableAssert.AreSequentialEqual(new int[] { 0, 1, 3, 4 }, Enumerable.Range(0, 5).Remove(2, null, ListQueryMode.Normalize));
EnumerableAssert.AreSequentialEqual(new int[] { 0, 1, 2, 4 }, Enumerable.Range(0, 5).Remove(3, null, ListQueryMode.Normalize));
EnumerableAssert.AreSequentialEqual(new int[] { 0, 1, 2, 3 }, Enumerable.Range(0, 5).Remove(4, null, ListQueryMode.Normalize));
EnumerableAssert.AreSequentialEqual(new int[] { 0, 1, 2, 3, 4 }, Enumerable.Range(0, 5).Remove(5, null, ListQueryMode.Normalize));
EnumerableAssert.AreSequentialEqual(new int[] { 0, 1, 2, 3, 4 }, Enumerable.Range(0, 5).Remove(6, null, ListQueryMode.Normalize));
EnumerableAssert.AreSequentialEqual(new int[] { 0, 1, 2, 3, 4 }, Enumerable.Range(0, 5).Remove(-1, null, ListQueryMode.Ignore));
EnumerableAssert.AreSequentialEqual(new int[] { 1, 2, 3, 4 }, Enumerable.Range(0, 5).Remove(0, null, ListQueryMode.Ignore));
EnumerableAssert.AreSequentialEqual(new int[] { 0, 2, 3, 4 }, Enumerable.Range(0, 5).Remove(1, null, ListQueryMode.Ignore));
EnumerableAssert.AreSequentialEqual(new int[] { 0, 1, 3, 4 }, Enumerable.Range(0, 5).Remove(2, null, ListQueryMode.Ignore));
EnumerableAssert.AreSequentialEqual(new int[] { 0, 1, 2, 4 }, Enumerable.Range(0, 5).Remove(3, null, ListQueryMode.Ignore));
EnumerableAssert.AreSequentialEqual(new int[] { 0, 1, 2, 3 }, Enumerable.Range(0, 5).Remove(4, null, ListQueryMode.Ignore));
EnumerableAssert.AreSequentialEqual(new int[] { 0, 1, 2, 3, 4 }, Enumerable.Range(0, 5).Remove(5, null, ListQueryMode.Ignore));
EnumerableAssert.AreSequentialEqual(new int[] { 0, 1, 2, 3, 4 }, Enumerable.Range(0, 5).Remove(6, null, ListQueryMode.Ignore));
}
public void PercentileTest()
{
IEnumerable <int> source = Enumerable.Range(0, 5).ToArray();
Assert.AreEqual(0, source.Percentile(int32 => int32, 0));
Assert.AreEqual(0.8, source.Percentile(int32 => int32, 0.2));
Assert.AreEqual(2, source.Percentile(int32 => int32, 0.5));
Assert.AreEqual(2.4, source.Percentile(int32 => int32, 0.6));
Assert.AreEqual(3.32, source.Percentile(int32 => int32, 0.83));
Assert.AreEqual(3.36, source.Percentile(int32 => int32, 0.84));
Assert.AreEqual(3.8, source.Percentile(int32 => int32, 0.95));
}
public void RemoveAllTest()
{
EnumerableAssert.AreSequentialEqual(new int[] { 0, 1, 2, 3, 4 }, Enumerable.Range(0, 5).RemoveAll(-1));
EnumerableAssert.AreSequentialEqual(new int[] { 1, 2, 3, 4 }, Enumerable.Range(0, 5).RemoveAll(0));
EnumerableAssert.AreSequentialEqual(new int[] { 0, 2, 3, 4 }, Enumerable.Range(0, 5).RemoveAll(1));
EnumerableAssert.AreSequentialEqual(new int[] { 0, 1, 3, 4 }, Enumerable.Range(0, 5).RemoveAll(2));
EnumerableAssert.AreSequentialEqual(new int[] { 0, 1, 2, 4 }, Enumerable.Range(0, 5).RemoveAll(3));
EnumerableAssert.AreSequentialEqual(new int[] { 0, 1, 2, 3 }, Enumerable.Range(0, 5).RemoveAll(4));
EnumerableAssert.AreSequentialEqual(new int[] { 0, 1, 2, 3, 4 }, Enumerable.Range(0, 5).RemoveAll(5));
EnumerableAssert.AreSequentialEqual(new int[] { 0, 1, 2, 3, 4 }, Enumerable.Range(0, 5).RemoveAll(6));
EnumerableAssert.AreSequentialEqual(new int[] { }, Enumerable.Repeat(0, 5).RemoveAll(0));
EnumerableAssert.AreSequentialEqual(new int[] { 0, 0, 0, 0, 0 }, Enumerable.Repeat(0, 5).RemoveAll(1));
EnumerableAssert.AreSequentialEqual(new int[] { 0, 1, 2, 3, 0, 1, 2, 3 }, Enumerable.Range(0, 5).Concat(Enumerable.Range(0, 5)).RemoveAll(4));
EnumerableAssert.AreSequentialEqual(new int[] { 1, 2, 3, 4, 1, 2, 3, 4 }, Enumerable.Range(0, 5).Concat(Enumerable.Range(0, 5)).RemoveAll(0));
}
static void Main(string[] args)
{
Console.WriteLine("Benchmarking...");
var size = 10_000_000;
var random = new Random();
var threshold = Int32.MaxValue / 2;
threshold = Int32.MaxValue / 2 - 1000;
// Do all actions twice to make sure the JIT is fully optimized
var largeStructArray = Enumerable.Range(0, size)
.Select(_ => new LargeStruct(random.Next()));
var(largeStructTime, filteredLargeStructArray) = MeasureTime(() => largeStructArray.Where(s => s.i < threshold));
(largeStructTime, filteredLargeStructArray) = MeasureTime(() => largeStructArray.Where(s => s.i < threshold));
Console.WriteLine("68 Byte Struct: Elapsed={0}, Count={1}", largeStructTime, filteredLargeStructArray.Count());
filteredLargeStructArray = null;
largeStructArray = null;
var smallStructArray = Enumerable.Range(0, size)
.Select(_ => new SmallStruct(random.Next()));
var(smallStructTime, filteredSmallStructArray) = MeasureTime(() => smallStructArray.Where(s => s.e < threshold));
(smallStructTime, filteredSmallStructArray) = MeasureTime(() => smallStructArray.Where(s => s.e < threshold));
Console.WriteLine("4 Byte Struct: Elapsed={0}, Count={1}", smallStructTime, filteredSmallStructArray.Count());
filteredSmallStructArray = null;
smallStructArray = null;
var smallClassArray = Enumerable.Range(0, size)
.Select(_ => new SmallClass(random.Next()));
var(smallClassTime, filteredSmallClassArray) = MeasureTime(() => smallClassArray.Where(s => s.e < threshold));
(smallClassTime, filteredSmallClassArray) = MeasureTime(() => smallClassArray.Where(s => s.e < threshold));
Console.WriteLine("4-byte Class: Elapsed={0}, Count={1}", smallClassTime, filteredSmallClassArray.Count());
filteredSmallClassArray = null;
smallClassArray = null;
var classArray = Enumerable.Range(0, size)
.Select(_ => new LargeClass(random.Next()));
var(classTime, filteredClassArray) = MeasureTime(() => classArray.Where(s => s.i < threshold));
(classTime, filteredClassArray) = MeasureTime(() => classArray.Where(s => s.i < threshold));
Console.WriteLine("68-byte Class: Elapsed={0}, Count={1}", classTime, filteredClassArray.Count());
}
public void PercentileExclusiveTest()
{
IEnumerable <int> source = Enumerable.Range(0, 5).ToArray();
try
{
double percentile = source.PercentileExclusive(int32 => int32, 0);
Assert.Fail($"{percentile}");
}
catch (ArgumentOutOfRangeException exception)
{
Assert.AreEqual("percentile", exception.ParamName);
}
Assert.AreEqual(0.2, source.PercentileExclusive(int32 => int32, 0.2), 0.000000001);
Assert.AreEqual(2, source.PercentileExclusive(int32 => int32, 0.5), 0.000000001);
Assert.AreEqual(2.6, source.PercentileExclusive(int32 => int32, 0.6), 0.000000001);
Assert.AreEqual(3.98, source.PercentileExclusive(int32 => int32, 0.83), 0.000000001);
try
{
double percentile = source.PercentileExclusive(int32 => int32, 0.84);
Assert.Fail($"{percentile}");
}
catch (ArgumentOutOfRangeException exception)
{
Assert.AreEqual("percentile", exception.ParamName);
}
try
{
double percentile = source.PercentileExclusive(int32 => int32, 0.95);
Assert.Fail($"{percentile}");
}
catch (ArgumentOutOfRangeException exception)
{
Assert.AreEqual("percentile", exception.ParamName);
}
}
public void IfCountCrossesMaximumInt_ExceptionIsThrown(int start, int count)
{
Assert.Throws <ArgumentOutOfRangeException>(() => Linq.Range(start, count));
}
public void CountCantBeNegative()
{
Assert.Throws <ArgumentOutOfRangeException>(() => Linq.Range(1, -4));
}
public void EmptyRangeReturnsEmptyCollection()
{
var range = Linq.Range(7, 0);
range.Should().BeEmpty();
}
public void StartValueCantBeNegative()
{
var range = Linq.Range(-3, 2);
range.Should().BeEquivalentTo(new[] { -3, -2 });
}
public void ReturnsValidRange()
{
var range = Linq.Range(5, 3);
range.Should().BeEquivalentTo(new[] { 5, 6, 7 });
}
public void VarianceTest()
{
Assert.AreEqual(9.166666667, Enumerable.Range(0, 10).Variance(int32 => int32), 0.000000001);
}
public void VariancePopulationTest()
{
Assert.AreEqual(8.25, Enumerable.Range(0, 10).VariancePopulation(int32 => int32));
}