public static IEnumerable <object[]> Ranges(int start, IEnumerable <int> counts)
{
foreach (object[] parms in UnorderedSources.Ranges(start, counts))
{
yield return(new object[] { ((Labeled <ParallelQuery <int> >)parms[0]).Order(), parms[1] });
}
}
/// <summary>
/// Get a a combination of ranges and "easy" queries to run on them, starting at 0, running for each count in `counts`,
/// .with each ExecutionMode specified.
/// </summary>
/// <remarks>
/// "Easy" queries are ones PLINQ can trivially parallelize (the overhead would not be a significant factor).
/// </remarks>
/// <param name="counts">The sizes of ranges to return.</param>
/// <param name="modes">The ExecutionMode to use.</param>
/// <returns>Entries for test data.
/// The first element is the Labeled{ParallelQuery{int}} range,
/// the second element is the count, and the third is the execution mode.</returns>
public static IEnumerable <object[]> EasyQueryData(object[] counts, object[] modes)
{
// Test doesn't apply to DOP == 1. It verifies that work is actually
// happening in parallel, which won't be the case with DOP == 1.
if (Environment.ProcessorCount == 1)
{
yield break;
}
foreach (object[] results in UnorderedSources.Ranges(counts))
{
foreach (var query in EasyUnorderedQueries())
{
foreach (ParallelExecutionMode mode in modes)
{
yield return(new object[] { results[0], results[1], query, mode });
}
}
}
foreach (object[] results in Sources.Ranges(counts))
{
foreach (var query in EasyOrderedQueries())
{
foreach (ParallelExecutionMode mode in modes)
{
yield return(new object[] { results[0], results[1], query, mode });
}
}
}
}
public static IEnumerable <object[]> DistinctUnorderedData(object[] counts)
{
foreach (object[] results in UnorderedSources.Ranges(counts.Cast <int>().Select(x => x * DuplicateFactor)))
{
yield return(new object[] { results[0], ((int)results[1]) / DuplicateFactor });
}
}
public static IEnumerable <object[]> SumData(int[] counts)
{
foreach (object[] results in UnorderedSources.Ranges(counts.Cast <int>(), x => Functions.SumRange(0L, x)))
{
yield return(results);
}
}
// If ThreadPool becomes available, uncomment the below
//private static ThreadPoolManager _poolManager = new ThreadPoolManager();
public static IEnumerable <object[]> DegreeData(object[] counts, object[] degrees)
{
foreach (object[] results in UnorderedSources.Ranges(counts.Cast <int>(), x => degrees.Cast <int>().DefaultIfEmpty(x)))
{
yield return(results);
}
}
public static IEnumerable <object[]> Ranges <T>(IEnumerable <int> counts, params Func <int, IEnumerable <T> >[] modifiers)
{
foreach (object[] parms in UnorderedSources.Ranges(counts, modifiers))
{
parms[0] = ((Labeled <ParallelQuery <int> >)parms[0]).Order();
yield return(parms);
}
}
public static IEnumerable <object[]> OnlyOneData(object[] counts)
{
Func <int, IEnumerable <int> > positions = x => new[] { 0, x / 2, Math.Max(0, x - 1) }.Distinct();
foreach (object[] results in UnorderedSources.Ranges(counts.Cast <int>(), positions))
{
yield return(results);
}
}
public static IEnumerable <object[]> MinData(object[] counts)
{
Func <int, int> min = x => 1 - x;
foreach (object[] results in UnorderedSources.Ranges(counts.Cast <int>(), min))
{
yield return(results);
}
}
//
// Skip
//
public static IEnumerable <object[]> SkipUnorderedData(int[] counts)
{
Func <int, IEnumerable <int> > skip = x => new[] { -x, -1, 0, 1, x / 2, x, x * 2 }.Distinct();
foreach (object[] results in UnorderedSources.Ranges(counts.Cast <int>(), skip))
{
yield return(results);
}
}
public static IEnumerable <object[]> ElementAtOutOfRangeData(int[] counts)
{
Func <int, IEnumerable <int> > positions = x => new[] { -1, x, x * 2 }.Distinct();
foreach (object[] results in UnorderedSources.Ranges(counts.Cast <int>(), positions))
{
yield return(results);
}
}
//
// Average
//
public static IEnumerable <object[]> AverageData(object[] counts)
{
Func <int, double> average = x => (x - 1) / 2.0;
foreach (object[] results in UnorderedSources.Ranges(counts.Cast <int>(), average))
{
yield return(results);
}
}
// Get a set of ranges from 0 to each count, having an extra parameter describing the maximum (count - 1)
public static IEnumerable <object[]> MaxData(int[] counts)
{
Func <int, int> max = x => x - 1;
foreach (object[] results in UnorderedSources.Ranges(counts.Cast <int>(), max))
{
yield return(results);
}
}
public static IEnumerable <object[]> EmptyData()
{
foreach (object[] query in UnorderedSources.Ranges(new[] { 0 }))
{
yield return(new object[] { query[0], 1 });
}
yield return(new object[] { Labeled.Label("Empty-Int", ParallelEnumerable.Empty <int>()), 1 });
yield return(new object[] { Labeled.Label("Empty-Decimal", ParallelEnumerable.Empty <decimal>()), 1.5M });
yield return(new object[] { Labeled.Label("Empty-String", ParallelEnumerable.Empty <string>()), "default" });
}
//
// SelectMany
//
public static IEnumerable <object[]> SelectManyUnorderedData(int[] counts)
{
foreach (object[] results in UnorderedSources.Ranges(counts.Cast <int>()))
{
foreach (Labeled <Func <int, int, IEnumerable <int> > > expander in Expanders())
{
foreach (int count in new[] { 0, 1, 2, 8 })
{
yield return(new object[] { results[0], results[1], expander, count });
}
}
}
}
public static IEnumerable <object[]> SingleData(object[] elements, object[] counts)
{
foreach (int element in elements)
{
foreach (object[] results in UnorderedSources.Ranges(element, counts.Cast <int>()))
{
yield return(new object[] { results[0], results[1], element });
}
foreach (object[] results in Sources.Ranges(element, counts.Cast <int>()))
{
yield return(new object[] { results[0], results[1], element });
}
}
}
public static IEnumerable <object[]> AggregateExceptionData(int[] counts)
{
foreach (object[] results in UnorderedSources.Ranges(counts.Cast <int>()))
{
Labeled <ParallelQuery <int> > query = (Labeled <ParallelQuery <int> >)results[0];
if (query.ToString().StartsWith("Partitioner"))
{
yield return(new object[] { Labeled.Label(query.ToString(), Partitioner.Create(UnorderedSources.GetRangeArray(0, (int)results[1]), false).AsParallel()), results[1] });
}
else if (query.ToString().StartsWith("Enumerable.Range"))
{
yield return(new object[] { Labeled.Label(query.ToString(), new StrictPartitioner <int>(Partitioner.Create(Enumerable.Range(0, (int)results[1]), EnumerablePartitionerOptions.None), (int)results[1]).AsParallel()), results[1] });
}
else
{
yield return(results);
}
}
}
