public static void Sum_Long_SomeNull(Labeled <ParallelQuery <int> > labeled, int count, long sum)
{
ParallelQuery <int> query = labeled.Item;
Assert.Equal(Functions.SumRange(0L, count / 2), query.Select(x => x < count / 2 ? (long?)x : null).Sum());
Assert.Equal(-Functions.SumRange(0L, count / 2), query.Sum(x => x < count / 2 ? -(long?)x : null));
}
public static void Sum_Float(int count)
{
Assert.Equal(Functions.SumRange(0, count), ParallelEnumerable.Range(0, count).Select(x => (float)x).Sum());
Assert.Equal(Functions.SumRange(0, count), ParallelEnumerable.Range(0, count).Select(x => (float?)x).Sum());
Assert.Equal(-Functions.SumRange(0, count), ParallelEnumerable.Range(0, count).Sum(x => - (float)x));
Assert.Equal(-Functions.SumRange(0, count), ParallelEnumerable.Range(0, count).Sum(x => - (float?)x));
}
public static void Sum_Decimal(int count)
{
Assert.Equal(Functions.SumRange(0, count), ParallelEnumerable.Range(0, count).Select(x => (decimal)x).Sum());
Assert.Equal(Functions.SumRange(0, count), ParallelEnumerable.Range(0, count).Select(x => (decimal?)x).Sum());
Assert.Equal(-Functions.SumRange(0, count), ParallelEnumerable.Range(0, count).Sum(x => - (decimal)x));
Assert.Equal(-Functions.SumRange(0, count), ParallelEnumerable.Range(0, count).Sum(x => - (decimal?)x));
}
public static void Sum_Decimal_SomeNull(Labeled <ParallelQuery <int> > labeled, int count, decimal sum)
{
ParallelQuery <int> query = labeled.Item;
Assert.Equal(Functions.SumRange(0, count / 2), query.Select(x => x < count / 2 ? (decimal?)x : null).Sum());
Assert.Equal(-Functions.SumRange(0, count / 2), query.Sum(x => x < count / 2 ? -(decimal?)x : null));
}
public static void Sum_Long(int count)
{
Assert.Equal(Functions.SumRange(0, count), ParallelEnumerable.Range(0, count).Select(x => (long)x).Sum());
Assert.Equal(Functions.SumRange(0, count), ParallelEnumerable.Range(0, count).Select(x => (long?)x).Sum());
Assert.Equal(-Functions.SumRange(0, count), ParallelEnumerable.Range(0, count).Sum(x => - (long)x));
Assert.Equal(-Functions.SumRange(0, count), ParallelEnumerable.Range(0, count).Sum(x => - (long?)x));
}
public static void DegreeOfParallelism_Barrier(Labeled <ParallelQuery <int> > labeled, int count, int degree)
{
using (ThreadPoolHelpers.EnsureMinThreadsAtLeast(degree))
{
var barrier = new Barrier(degree);
Assert.Equal(Functions.SumRange(0, count), labeled.Item.WithDegreeOfParallelism(degree).Sum(x => { barrier.SignalAndWait(); return(x); }));
}
}
public static void Aggregate_Sum_SeedFunction(int count)
{
ParallelQuery <int> query = UnorderedSources.Default(count);
int actual = query.Aggregate(
() => 0,
(accumulator, x) => accumulator + x,
(left, right) => left + right,
result => result + ResultFuncModifier);
Assert.Equal(Functions.SumRange(0, count) + ResultFuncModifier, actual);
}
public static void Aggregate_Sum_SeedFunction(Labeled <ParallelQuery <int> > labeled, int count)
{
ParallelQuery <int> query = labeled.Item;
int actual = query.Aggregate(
() => 0,
(accumulator, x) => accumulator + x,
(left, right) => left + right,
result => result + ResultFuncModifier);
Assert.Equal(Functions.SumRange(0, count) + ResultFuncModifier, actual);
}
public static void DegreeOfParallelism_Aggregate_Accumulator(Labeled <ParallelQuery <int> > labeled, int count, int degree)
{
ParallelQuery <int> query = labeled.Item;
int accumulatorCombineCount = 0;
int actual = query.WithDegreeOfParallelism(degree).Aggregate(
0,
(accumulator, x) => accumulator + x,
(left, right) => { Interlocked.Increment(ref accumulatorCombineCount); return(left + right); },
result => result);
Assert.Equal(Functions.SumRange(0, count), actual);
Assert.Equal(degree - 1, accumulatorCombineCount);
}
public static void Aggregate_Sum(Labeled <ParallelQuery <int> > labeled, int count)
{
ParallelQuery <int> query = labeled.Item;
if (count == 0)
{
Assert.Throws <InvalidOperationException>(() => query.Aggregate((x, y) => x + y));
}
else
{
// The operation will overflow for long-running sizes, but that's okay:
// The helper is overflowing too!
Assert.Equal(Functions.SumRange(0, count), query.Aggregate((x, y) => x + y));
}
}
public static void DegreeOfParallelism_Barrier(Labeled <ParallelQuery <int> > labeled, int count, int degree)
{
Barrier barrier = new Barrier(degree);
//If ThreadPool becomes available, uncomment the below.
//_poolManager.ReserveThreads(degree);
//try
//{
Assert.Equal(Functions.SumRange(0, count), labeled.Item.WithDegreeOfParallelism(degree).Sum(x => { barrier.SignalAndWait(); return(x); }));
//}
//finally
//{
// _poolManager.ReleaseThreads();
//}
}
public static void Aggregate_Sum(int count)
{
// The operation will overflow for long-running sizes, but that's okay:
// The helper is overflowing too!
Assert.Equal(Functions.SumRange(0, count), UnorderedSources.Default(count).Aggregate((x, y) => x + y));
}
public static void Aggregate_Sum_Seed(int count)
{
Assert.Equal(Functions.SumRange(0, count), UnorderedSources.Default(count).Aggregate(0, (x, y) => x + y));
}
public static void DegreeOfParallelism(Labeled <ParallelQuery <int> > labeled, int count, int degree)
{
Assert.Equal(Functions.SumRange(0, count), labeled.Item.WithDegreeOfParallelism(degree).Sum());
}
public static void Sum_Long_SomeNull(int count)
{
Assert.Equal(Functions.SumRange(0, count / 2), ParallelEnumerable.Range(0, count).Select(x => x < count / 2 ? (long?)x : null).Sum());
Assert.Equal(-Functions.SumRange(0, count / 2), ParallelEnumerable.Range(0, count).Sum(x => x < count / 2 ? -(long?)x : null));
}
public static void Aggregate_Sum_Result(int count)
{
Assert.Equal(Functions.SumRange(0, count) + ResultFuncModifier, UnorderedSources.Default(count).Aggregate(0, (x, y) => x + y, result => result + ResultFuncModifier));
}
public static IEnumerable <object[]> SumData(int[] counts)
{
foreach (object[] results in UnorderedSources.Ranges(counts.Cast <int>(), x => Functions.SumRange(0L, x)))
{
yield return(results);
}
}
public static void Aggregate_Sum_Result(Labeled <ParallelQuery <int> > labeled, int count)
{
ParallelQuery <int> query = labeled.Item;
Assert.Equal(Functions.SumRange(0, count) + ResultFuncModifier, query.Aggregate(0, (x, y) => x + y, result => result + ResultFuncModifier));
}
public static void Aggregate_Sum_Seed(Labeled <ParallelQuery <int> > labeled, int count)
{
ParallelQuery <int> query = labeled.Item;
Assert.Equal(Functions.SumRange(0, count), query.Aggregate(0, (x, y) => x + y));
}