public void ConcatMultipleTest_IntZero()
{
var expected = new int[0];
var actual = EnumerableF.ConcatMultipleF(new IList <int> [0]);
Assert.Equal(expected, actual);
}
public void RangeTest_Int()
{
var expected = Enumerable.Range(5, 100).ToArray();
var actual = EnumerableF.RangeF(5, 100).ToArrayF();
Assert.Equal(expected, actual);
}
public void ConcatMultipleTest_StringPair()
{
var expected = "TeHe";
var actual = EnumerableF.ConcatMultipleF("Te", "He");
Assert.Equal(expected, actual);
}
public void ConcatMultipleTest_StringZero()
{
var expected = string.Empty;
var actual = EnumerableF.ConcatMultipleF();
Assert.Equal(expected, actual);
}
public void EmptyTest_Int()
{
var expected = Enumerable.Empty <int>().ToArray();
var actual = EnumerableF.EmptyF <int>().ToArrayF();
Assert.Equal(expected, actual);
}
public void RepeatTest_Int(IList <int> source)
{
var expected = Enumerable.Repeat(source.FirstOrDefault(), source.Count).ToArray();
var actual = EnumerableF.RepeatF(source.FirstOrDefault(), source.Count).ToArrayF();
Assert.Equal(expected, actual);
}
public void ConcatMultipleTest_IntSingle()
{
var expected = new[] { 1, 2, 3 };
var actual = EnumerableF.ConcatMultipleF(expected);
Assert.Equal(expected, actual);
}
public void ConcatMultipleTest_StringSingle()
{
var expected = "TeHe";
var actual = EnumerableF.ConcatMultipleF(expected);
Assert.Equal(expected, actual);
}
public void ConcatMultipleTest_Int(int[] expected, int[] left, int[] middle, int[] right)
{
var actual = EnumerableF.ConcatMultipleF(left, middle, right);
var actual2 = new[] { left, middle, right }.ConcatF();
Assert.Equal(expected, actual);
Assert.Equal(expected, actual2);
}
public void ConcatMultipleTest_String(string expected, string left, string middle, string right)
{
var actual = EnumerableF.ConcatMultipleF(left, middle, right);
var actual2 = new[] { left, middle, right }.ConcatF();
Assert.Equal(expected, actual);
Assert.Equal(expected, actual2);
}
public void RepeatSequenceTest_Int(int[] expected, int[] source, int count)
{
var actual = EnumerableF.RepeatSequenceF(source, count).ToArrayF();
var actual2 = source.RepeatF(count).ToArrayF();
Assert.Equal(expected, actual);
Assert.Equal(expected, actual2);
}
public FatValueType LinqFasterer()
{
var items = EnumerableF.DistinctF(source);
var sum = default(FatValueType);
foreach (var item in items)
{
sum += item;
}
return(sum);
}
public int LinqFasterer()
{
var items = EnumerableF.SelectF(EnumerableF.TakeF(EnumerableF.SkipF(source, Skip), Count), item => item * 3);
var sum = 0;
foreach (var item in items)
{
sum += item;
}
return(sum);
}
public FatValueType LinqFasterer()
{
var items = EnumerableF.SelectF(EnumerableF.WhereF(source, item => item.IsEven()), item => item * 3);
var sum = default(FatValueType);
foreach (var item in items)
{
sum += item;
}
return(sum);
}
public int LinqFasterer()
{
var items = EnumerableF.WhereF(source, item => item.IsEven());
var sum = 0;
foreach (var item in items)
{
sum += item;
}
return(sum);
}
public int LinqFasterer()
{
var items = EnumerableF.DistinctF(source);
var sum = 0;
foreach (var item in items)
{
sum += item;
}
return(sum);
}
public FatValueType LinqFasterer()
{
var items = EnumerableF.SelectF(EnumerableF.TakeF(EnumerableF.SkipF(source, Skip), Count), item => item * 3);
var sum = default(FatValueType);
foreach (var item in items)
{
sum += item;
}
return(sum);
}
public int[] RepeatSequenceFaster()
{
return(EnumerableF.RepeatSequenceF(new[] { 1, 2, 3, 4, 5 }, N).ToArrayF());
}
public int[] RepeatFaster()
{
return(EnumerableF.RepeatF(5, N).ToArrayF());
}
public void RangeTest_IntChange(int[] expected, int start, int count, int change)
{
Assert.Equal(expected, EnumerableF.RangeF(start, count, change));
}
public void RangeTest_LongChange(long[] expected, long start, int count, long change)
{
Assert.Equal(expected, EnumerableF.RangeF(start, count, change));
}
public void RangeTest_DecimalChange(double[] expected, decimal start, int count, decimal change)
{
Assert.Equal(expected, EnumerableF.RangeF(start, count, change).SelectF(v => (double)v));
}
public FatValueType[] LinqFasterer()
=> EnumerableF.ToArrayF(
EnumerableF.SelectF(
EnumerableF.WhereF(source, item => item.IsEven()),
item => item * 3)
);
public void RangeTest_FloatChange(float[] expected, float start, int count, float change)
{
Assert.Equal(expected, EnumerableF.RangeF(start, count, change));
}
public string ConcatMultipleStrFaster()
{
return(EnumerableF.ConcatMultipleF(Data.SelectF(i => i.ToString()).ToArrayF()));
}
public int[] ConcatMultipleFaster()
{
return(EnumerableF.ConcatMultipleF(Data, DataSecondary, Data, DataSecondary).ToArrayF());
}
public void RangeTest_DoubleChange(double[] expected, double start, int count, double change)
{
Assert.Equal(expected, EnumerableF.RangeF(start, count, change));
}
public int[] RangeFaster()
{
return(EnumerableF.RangeF(0, 100).ToArrayF());
}
public int LinqFasterer() => EnumerableF.SumF(source);
public bool LinqFasterer() => EnumerableF.ContainsF(source, value);
