Add overflow checking to Average nullable internal aggregation.

Author: Clockwork-Muse

src/System.Linq.Parallel/src/System/Linq/Parallel/QueryOperators/Inlined/NullableDecimalAverageAggregationOperator.cs

@@ -118,8 +118,11 @@ protected override bool MoveNextCore(ref Pair<decimal, long> currentElement)
 
                     if (current.HasValue)
                     {
-                        sum += current.GetValueOrDefault();
-                        count++;
+                        checked
+                        {
+                            sum += current.GetValueOrDefault();
+                            count++;
+                        }
                     }
                 }
 

src/System.Linq.Parallel/src/System/Linq/Parallel/QueryOperators/Inlined/NullableDoubleAverageAggregationOperator.cs

@@ -118,8 +118,11 @@ protected override bool MoveNextCore(ref Pair<double, long> currentElement)
                         if ((i++ & CancellationState.POLL_INTERVAL) == 0)
                             CancellationState.ThrowIfCanceled(_cancellationToken);
 
-                        sum += current.GetValueOrDefault();
-                        count++;
+                        checked
+                        {
+                            sum += current.GetValueOrDefault();
+                            count++;
+                        }
                     }
                 }
 

src/System.Linq.Parallel/src/System/Linq/Parallel/QueryOperators/Inlined/NullableFloatAverageAggregationOperator.cs

@@ -119,8 +119,11 @@ protected override bool MoveNextCore(ref Pair<double, long> currentElement)
 
                     if (current.HasValue)
                     {
-                        sum += current.GetValueOrDefault();
-                        count++;
+                        checked
+                        {
+                            sum += current.GetValueOrDefault();
+                            count++;
+                        }
                     }
                 }
 

src/System.Linq.Parallel/src/System/Linq/Parallel/QueryOperators/Inlined/NullableIntAverageAggregationOperator.cs

@@ -119,8 +119,11 @@ protected override bool MoveNextCore(ref Pair<long, long> currentElement)
 
                     if (current.HasValue)
                     {
-                        sum += current.GetValueOrDefault();
-                        count++;
+                        checked
+                        {
+                            sum += current.GetValueOrDefault();
+                            count++;
+                        }
                     }
                 }
 

src/System.Linq.Parallel/src/System/Linq/Parallel/QueryOperators/Inlined/NullableLongAverageAggregationOperator.cs

@@ -119,8 +119,11 @@ protected override bool MoveNextCore(ref Pair<long, long> currentElement)
                         CancellationState.ThrowIfCanceled(_cancellationToken);
                     if (current.HasValue)
                     {
-                        sum += current.GetValueOrDefault();
-                        count++;
+                        checked
+                        {
+                            sum += current.GetValueOrDefault();
+                            count++;
+                        }
                     }
                 }
 

src/System.Linq.Parallel/tests/QueryOperators/AverageTests.cs

@@ -14,6 +14,8 @@ public class AverageTests
         //
         // Average
         //
+
+        // Get a set of ranges from 0 to each count, with an extra parameter containing the expected average.
         public static IEnumerable<object[]> AverageData(object[] counts)
         {
             Func<int, double> average = x => (x - 1) / 2.0;
@@ -76,6 +78,16 @@ public static void Average_Long_Longrunning(Labeled<ParallelQuery<int>> labeled,
             Average_Long(labeled, count, average);
         }
 
+        [Theory]
+        [MemberData("Ranges", (object)(new int[] { 2 }), MemberType = typeof(UnorderedSources))]
+        public static void Average_Long_Overflow(Labeled<ParallelQuery<int>> labeled, int count)
+        {
+            Functions.AssertThrowsWrapped<OverflowException>(() => labeled.Item.Select(x => x == 0 ? 1 : long.MaxValue).Average());
+            Functions.AssertThrowsWrapped<OverflowException>(() => labeled.Item.Select(x => x == 0 ? (long?)1 : long.MaxValue).Average());
+            Functions.AssertThrowsWrapped<OverflowException>(() => labeled.Item.Average(x => x == 0 ? -1 : long.MinValue));
+            Functions.AssertThrowsWrapped<OverflowException>(() => labeled.Item.Average(x => x == 0 ? (long?)-1 : long.MinValue));
+        }
+
         [Theory]
         [MemberData("AverageData", (object)(new int[] { 1, 2, 16 }))]
         public static void Average_Long_SomeNull(Labeled<ParallelQuery<int>> labeled, int count, double average)