Merge pull request #2133 from Clockwork-Muse/PLINQ_Other

System.Linq.Parallel - Other cleanup

Author: stephentoub

src/System.Linq.Parallel/tests/Combinatorial/SourcesAndOperators.cs

@@ -206,8 +206,8 @@ private static IEnumerable<LabeledOperation> BinaryOperations(LabeledOperation o
             yield return Label("Join-Right:" + label, (start, count, source) => source(0, count).Join(other(start, count), x => x, y => y - start, (x, y) => x + start, new ModularCongruenceComparer(count)));
             yield return Label("Join-Left:" + label, (start, count, source) => other(0, count).Join(source(start, count), x => x, y => y - start, (x, y) => x + start, new ModularCongruenceComparer(count)));
 
-            yield return Label("Union-Right:" + label, (start, count, source) => source(start, count * 3 / 4).Union(other(start + count / 2, count / 2 + count % 2)));
-            yield return Label("Union-Left:" + label, (start, count, source) => other(start, count * 3 / 4).Union(source(start + count / 2, count / 2 + count % 2)));
+            yield return Label("Union-Right:" + label, (start, count, source) => source(start, count * 3 / 4).Union(other(start + count / 2, count / 2 + count % 2), new ModularCongruenceComparer(count)));
+            yield return Label("Union-Left:" + label, (start, count, source) => other(start, count * 3 / 4).Union(source(start + count / 2, count / 2 + count % 2), new ModularCongruenceComparer(count)));
 
             // When both sources are unordered any element can be matched to any other, so a different check is required.
             yield return Label("Zip-Unordered-Right:" + label, (start, count, source) => source(0, count).Zip(other(start * 2, count), (x, y) => x + start));

src/System.Linq.Parallel/tests/ExceptionAndParallelEnumerableExceptionTests.cs

@@ -19,7 +19,7 @@ public int GetHashCode(T obj)
         }
     }
 
-    internal class ModularCongruenceComparer : IEqualityComparer<int>
+    internal class ModularCongruenceComparer : IEqualityComparer<int>, IComparer<int>
     {
         private int _mod;
 
@@ -47,6 +47,11 @@ public int GetHashCode(object obj)
         {
             return GetHashCode((int)obj);
         }
+
+        public int Compare(int x, int y)
+        {
+            return leastPositiveResidue(x).CompareTo(leastPositiveResidue(y));
+        }
     }
 
     internal class ReverseComparer : IComparer<int>

src/System.Linq.Parallel/tests/ExchangeTests.cs

@@ -0,0 +1,34 @@
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Test
+{
+    internal static class Enumerables<T>
+    {
+        /// <summary>
+        /// Get an enumerable that throws an error on the first enumeration.
+        /// </summary>
+        /// <returns>An enumerable that throws on the first enumeration.</returns>
+        public static IEnumerable<T> ThrowOnEnumeration()
+        {
+            return ThrowOnEnumeration(1);
+        }
+
+        /// <summary>
+        /// Get an enumerable that throws an error after the given number of enumerations.
+        /// </summary>
+        /// <param name="count">The number of enumerations until the error is thrown.</param>
+        /// <returns>An enumerable that throws on the given enumeration.</returns>
+        public static IEnumerable<T> ThrowOnEnumeration(int count)
+        {
+            return Enumerable.Range(0, count).Select(i =>
+            {
+                if (i == count - 1) throw new DeliberateTestException();
+                return default(T);
+            });
+        }
+    }
+}

src/System.Linq.Parallel/tests/Helpers/Comparers.cs

@@ -10,6 +10,8 @@ public static class UnorderedSources
     {
         public const int AdditionalTypeLimit = 1024;
 
+        // Get a set of ranges, of each count in `counts`.
+        // The start of each range is determined by passing the count into the `start` predicate.
         private static IEnumerable<object[]> Ranges(Func<int, int> start, IEnumerable<int> counts)
         {
             foreach (int count in counts)
@@ -22,33 +24,80 @@ private static IEnumerable<object[]> Ranges(Func<int, int> start, IEnumerable<in
             }
         }
 
+        /// <summary>
+        /// Get a set of ranges, starting at `start`, and running for each count in `counts`.
+        /// </summary>
+        /// <param name="start">The starting element of the range.</param>
+        /// <param name="counts">The sizes of ranges to return.</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 start.</returns>
         public static IEnumerable<object[]> Ranges(int start, IEnumerable<int> counts)
         {
             foreach (object[] parms in Ranges(x => start, counts)) yield return parms;
         }
 
-        // Wrapper for attribute calls
+        /// <summary>
+        /// Get a set of ranges, starting at 0, and running for each count in `counts`.
+        /// </summary>
+        /// <remarks>This version is a wrapper for use from the MemberData attribute.</remarks>
+        /// <param name="counts">The sizes of ranges to return.</param>
+        /// <returns>Entries for test data.
+        /// The first element is the Labeled{ParallelQuery{int}} range,
+        /// and the second element is the count</returns>
         public static IEnumerable<object[]> Ranges(object[] counts)
         {
             foreach (object[] parms in Ranges(counts.Cast<int>())) yield return parms;
         }
 
+        /// <summary>
+        /// Get a set of ranges, starting at `start`, and running for each count in `counts`.
+        /// </summary>
+        /// <remarks>This version is a wrapper for use from the MemberData attribute.</remarks>
+        /// <param name="start">The starting element of the range.</param>
+        /// <param name="counts">The sizes of ranges to return.</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 start.</returns>
         public static IEnumerable<object[]> Ranges(int start, object[] counts)
         {
             foreach (object[] parms in Ranges(start, counts.Cast<int>())) yield return parms;
         }
 
+        /// <summary>
+        /// Return pairs of ranges, both from 0 to each respective count in `counts`.
+        /// </summary>
+        /// <remarks>This version is a wrapper for use from the MemberData attribute.</remarks>
+        /// <param name="leftCounts">The sizes of left ranges to return.</param>
+        /// <param name="rightCounts">The sizes of right ranges to return.</param>
+        /// <returns>Entries for test data.
+        /// The first element is the left Labeled{ParallelQuery{int}} range, the second element is the left count,
+        /// the third element is the right Labeled{ParallelQuery{int}} range, and the fourth element is the right count, .</returns>
         public static IEnumerable<object[]> BinaryRanges(object[] leftCounts, object[] rightCounts)
         {
             foreach (object[] parms in BinaryRanges(leftCounts.Cast<int>(), rightCounts.Cast<int>())) yield return parms;
         }
 
-        // Simple labeled-range source - just return a set of ranges from 0 to each of the counts.
+        /// <summary>
+        /// Get a set of ranges, starting at 0, and running for each count in `counts`.
+        /// </summary>
+        /// <param name="counts">The sizes of ranges to return.</param>
+        /// <returns>Entries for test data.
+        /// The first element is the Labeled{ParallelQuery{int}} range,
+        /// and the second element is the count</returns>
         public static IEnumerable<object[]> Ranges(IEnumerable<int> counts)
         {
             foreach (object[] parms in Ranges(x => 0, counts)) yield return parms.Take(2).ToArray();
         }
 
+        /// <summary>
+        /// Return pairs of ranges, both from 0 to each respective count in `counts`.
+        /// </summary>
+        /// <param name="leftCounts">The sizes of left ranges to return.</param>
+        /// <param name="rightCounts">The sizes of right ranges to return.</param>
+        /// <returns>Entries for test data.
+        /// The first element is the left Labeled{ParallelQuery{int}} range, the second element is the left count,
+        /// the third element is the right Labeled{ParallelQuery{int}} range, and the fourth element is the right count.</returns>
         public static IEnumerable<object[]> BinaryRanges(IEnumerable<int> leftCounts, IEnumerable<int> rightCounts)
         {
             foreach (object[] left in Ranges(leftCounts))
@@ -60,6 +109,16 @@ public static IEnumerable<object[]> BinaryRanges(IEnumerable<int> leftCounts, IE
             }
         }
 
+        /// <summary>
+        /// Return pairs of ranges, for each respective count in `counts`.
+        /// </summary>
+        /// <param name="leftCounts">The sizes of left ranges to return.</param>
+        /// <param name="rightStart">A predicate to determine the start of the right range, by passing the left and right range size.</param>
+        /// <param name="rightCounts">The sizes of right ranges to return.</param>
+        /// <returns>Entries for test data.
+        /// The first element is the left Labeled{ParallelQuery{int}} range, the second element is the left count,
+        /// the third element is the right Labeled{ParallelQuery{int}} range, the fourth element is the right count,
+        /// and the fifth is the right start..</returns>
         public static IEnumerable<object[]> BinaryRanges(IEnumerable<int> leftCounts, Func<int, int, int> rightStart, IEnumerable<int> rightCounts)
         {
             foreach (object[] left in Ranges(leftCounts))
@@ -71,8 +130,17 @@ public static IEnumerable<object[]> BinaryRanges(IEnumerable<int> leftCounts, Fu
             }
         }
 
-        // Allows for a set of output modifiers to be passed.
-        // This is useful for things like showing an average (via the use of `x => (double)SumRange(0, x) / x`)
+        /// <summary>
+        /// Get a set of ranges, starting at 0, and running for each count in `counts`.
+        /// </summary>
+        /// <remarks>
+        /// This is useful for things like showing an average (via the use of `x => (double)SumRange(0, x) / x`)
+        /// </remarks>
+        /// <param name="counts">The sizes of ranges to return.</param>
+        /// <param name="modifiers">A set of modifiers to return as additional parameters.</param>
+        /// <returns>Entries for test data.
+        /// The first element is the Labeled{ParallelQuery{int}} range,
+        /// the second element is the count, and one additional element for each modifier.</returns>
         public static IEnumerable<object[]> Ranges<T>(IEnumerable<int> counts, params Func<int, T>[] modifiers)
         {
             if (modifiers == null || !modifiers.Any())
@@ -89,10 +157,19 @@ public static IEnumerable<object[]> Ranges<T>(IEnumerable<int> counts, params Fu
             }
         }
 
-        // For each count, each modifier has multiple outputs.
-        // This is useful for things like dealing with `Max(predicate)`,
-        // allowing multiple predicate values for the same source count to be tested.
-        // The number of variations is equal to the longest inner enumeration (all others will cycle).
+        /// <summary>
+        /// Get a set of ranges, starting at 0, and running for each count in `counts`.
+        /// </summary>
+        /// <remarks>
+        /// This is useful for things like dealing with `Max(predicate)`,
+        /// allowing multiple predicate values for the same source count to be tested.
+        /// The number of variations is equal to the longest modifier enumeration (all others will cycle).
+        /// </remarks>
+        /// <param name="counts">The sizes of ranges to return.</param>
+        /// <param name="modifiers">A set of modifiers to return as additional parameters.</param>
+        /// <returns>Entries for test data.
+        /// The first element is the Labeled{ParallelQuery{int}} range,
+        /// the second element is the count, and one additional element for each modifier.</returns>
         public static IEnumerable<object[]> Ranges<T>(IEnumerable<int> counts, params Func<int, IEnumerable<T>>[] modifiers)
         {
             if (modifiers == null || !modifiers.Any())
@@ -119,11 +196,11 @@ private static IEnumerable<Labeled<ParallelQuery<int>>> LabeledRanges(int start,
             yield return Labeled.Label("Enumerable.Range", Enumerable.Range(start, count).AsParallel());
             int[] rangeArray = GetRangeArray(start, count);
             yield return Labeled.Label("Array", rangeArray.AsParallel());
+            IList<int> rangeList = rangeArray.ToList();
+            yield return Labeled.Label("List", rangeList.AsParallel());
             if (count < AdditionalTypeLimit + 1)
             {
                 yield return Labeled.Label("Partitioner", Partitioner.Create(rangeArray).AsParallel());
-                IList<int> rangeList = rangeArray.ToList();
-                yield return Labeled.Label("List", rangeList.AsParallel());
                 yield return Labeled.Label("ReadOnlyCollection", new ReadOnlyCollection<int>(rangeList).AsParallel());
             }
         }