Parcel out PlinqDelegateExceptions.cs contents, remove.

Update ExchangeTests

Update PlinqModesTests.

Remove file (contents covered more thoroughly by other tests).

Change Union tests to use custom Comparator similar to other set operations.

Add List to sources used for OuterLoop

Change how empty tests are handled.

Add tests for non-comparable types.

Add tests checking for duplicate compared items.

Describe behavior of common range sources

Describe Zip member data functions.

Describe Union member data functions.

Describe OrderBy member data functions

Describe Max/Min member data functions.

Author: Clockwork-Muse

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());
             }
         }