Clean up tests for Average.

Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/Average.Generated.cs

@@ -13,6 +13,12 @@ namespace Tests
 {
     public class AverageAsync : AsyncEnumerableTests
     {
+        [Fact]
+        public async Task AverageAsync_Int32_Null()
+        {
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<int>)).AsTask());
+        }
+
         [Fact]
         public async Task AverageAsync_Int32_Empty()
         {
@@ -28,6 +34,13 @@ namespace Tests
             Assert.Equal(xs.Average(), await ys.AverageAsync());
         }
 
+        [Fact]
+        public async Task AverageAsync_Selector_Int32_Null()
+        {
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<int>), x => x).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(AsyncEnumerable.Empty<object>(), default(Func<object, int>)).AsTask());
+        }
+
         [Fact]
         public async Task AverageAsync_Selector_Int32_Empty()
         {
@@ -43,6 +56,13 @@ namespace Tests
             Assert.Equal(xs.Average(), await ys.AverageAsync(x => x));
         }
 
+        [Fact]
+        public async Task AverageAwaitAsync_Selector_Int32_Null()
+        {
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(default(IAsyncEnumerable<int>), x => new ValueTask<int>(x)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(AsyncEnumerable.Empty<object>(), default(Func<object, ValueTask<int>>)).AsTask());
+        }
+
         [Fact]
         public async Task AverageAwaitAsync_Selector_Int32_Empty()
         {
@@ -59,6 +79,13 @@ namespace Tests
         }
 
 #if !NO_DEEP_CANCELLATION
+        [Fact]
+        public async Task AverageAwaitWithCancellationAsync_Selector_Int32_Null()
+        {
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitWithCancellationAsync(default(IAsyncEnumerable<int>), (x, ct) => new ValueTask<int>(x)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitWithCancellationAsync(AsyncEnumerable.Empty<object>(), default(Func<object, CancellationToken, ValueTask<int>>)).AsTask());
+        }
+
         [Fact]
         public async Task AverageAwaitWithCancellationAsync_Selector_Int32_Empty()
         {
@@ -75,6 +102,12 @@ namespace Tests
         }
 #endif
 
+        [Fact]
+        public async Task AverageAsync_Int32_Nullable_Null()
+        {
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<int?>)).AsTask());
+        }
+
         [Fact]
         public async Task AverageAsync_Int32_Nullable_Empty()
         {
@@ -105,6 +138,14 @@ namespace Tests
             Assert.Equal(xs.Average(), await ys.AverageAsync(x => x));
         }
 
+        [Fact]
+        public async Task AverageAwaitAsync_Selector_Int32_Nullable_Null()
+        {
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(default(IAsyncEnumerable<int?>), x => new ValueTask<int?>(x)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(AsyncEnumerable.Empty<object>(), default(Func<object, ValueTask<int?>>)).AsTask());
+        }
+
+
         [Fact]
         public async Task AverageAwaitAsync_Selector_Int32_Nullable_Empty()
         {
@@ -121,6 +162,13 @@ namespace Tests
         }
 
 #if !NO_DEEP_CANCELLATION
+        [Fact]
+        public async Task AverageAwaitWithCancellationAsync_Selector_Int32_Nullable_Null()
+        {
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitWithCancellationAsync(default(IAsyncEnumerable<int?>), (x, ct) => new ValueTask<int?>(x)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitWithCancellationAsync(AsyncEnumerable.Empty<object>(), default(Func<object, CancellationToken, ValueTask<int?>>)).AsTask());
+        }
+
         [Fact]
         public async Task AverageAwaitWithCancellationAsync_Selector_Int32_Nullable_Empty()
         {
@@ -137,6 +185,12 @@ namespace Tests
         }
 #endif
 
+        [Fact]
+        public async Task AverageAsync_Int64_Null()
+        {
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<long>)).AsTask());
+        }
+
         [Fact]
         public async Task AverageAsync_Int64_Empty()
         {
@@ -152,6 +206,13 @@ namespace Tests
             Assert.Equal(xs.Average(), await ys.AverageAsync());
         }
 
+        [Fact]
+        public async Task AverageAsync_Selector_Int64_Null()
+        {
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<long>), x => x).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(AsyncEnumerable.Empty<object>(), default(Func<object, long>)).AsTask());
+        }
+
         [Fact]
         public async Task AverageAsync_Selector_Int64_Empty()
         {
@@ -167,6 +228,13 @@ namespace Tests
             Assert.Equal(xs.Average(), await ys.AverageAsync(x => x));
         }
 
+        [Fact]
+        public async Task AverageAwaitAsync_Selector_Int64_Null()
+        {
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(default(IAsyncEnumerable<long>), x => new ValueTask<long>(x)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(AsyncEnumerable.Empty<object>(), default(Func<object, ValueTask<long>>)).AsTask());
+        }
+
         [Fact]
         public async Task AverageAwaitAsync_Selector_Int64_Empty()
         {
@@ -183,6 +251,13 @@ namespace Tests
         }
 
 #if !NO_DEEP_CANCELLATION
+        [Fact]
+        public async Task AverageAwaitWithCancellationAsync_Selector_Int64_Null()
+        {
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitWithCancellationAsync(default(IAsyncEnumerable<long>), (x, ct) => new ValueTask<long>(x)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitWithCancellationAsync(AsyncEnumerable.Empty<object>(), default(Func<object, CancellationToken, ValueTask<long>>)).AsTask());
+        }
+
         [Fact]
         public async Task AverageAwaitWithCancellationAsync_Selector_Int64_Empty()
         {
@@ -199,6 +274,12 @@ namespace Tests
         }
 #endif
 
+        [Fact]
+        public async Task AverageAsync_Int64_Nullable_Null()
+        {
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<long?>)).AsTask());
+        }
+
         [Fact]
         public async Task AverageAsync_Int64_Nullable_Empty()
         {
@@ -229,6 +310,14 @@ namespace Tests
             Assert.Equal(xs.Average(), await ys.AverageAsync(x => x));
         }
 
+        [Fact]
+        public async Task AverageAwaitAsync_Selector_Int64_Nullable_Null()
+        {
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(default(IAsyncEnumerable<long?>), x => new ValueTask<long?>(x)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(AsyncEnumerable.Empty<object>(), default(Func<object, ValueTask<long?>>)).AsTask());
+        }
+
+
         [Fact]
         public async Task AverageAwaitAsync_Selector_Int64_Nullable_Empty()
         {
@@ -245,6 +334,13 @@ namespace Tests
         }
 
 #if !NO_DEEP_CANCELLATION
+        [Fact]
+        public async Task AverageAwaitWithCancellationAsync_Selector_Int64_Nullable_Null()
+        {
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitWithCancellationAsync(default(IAsyncEnumerable<long?>), (x, ct) => new ValueTask<long?>(x)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitWithCancellationAsync(AsyncEnumerable.Empty<object>(), default(Func<object, CancellationToken, ValueTask<long?>>)).AsTask());
+        }
+
         [Fact]
         public async Task AverageAwaitWithCancellationAsync_Selector_Int64_Nullable_Empty()
         {
@@ -261,6 +357,12 @@ namespace Tests
         }
 #endif
 
+        [Fact]
+        public async Task AverageAsync_Single_Null()
+        {
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<float>)).AsTask());
+        }
+
         [Fact]
         public async Task AverageAsync_Single_Empty()
         {
@@ -276,6 +378,13 @@ namespace Tests
             Assert.Equal(xs.Average(), await ys.AverageAsync());
         }
 
+        [Fact]
+        public async Task AverageAsync_Selector_Single_Null()
+        {
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<float>), x => x).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(AsyncEnumerable.Empty<object>(), default(Func<object, float>)).AsTask());
+        }
+
         [Fact]
         public async Task AverageAsync_Selector_Single_Empty()
         {
@@ -291,6 +400,13 @@ namespace Tests
             Assert.Equal(xs.Average(), await ys.AverageAsync(x => x));
         }
 
+        [Fact]
+        public async Task AverageAwaitAsync_Selector_Single_Null()
+        {
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(default(IAsyncEnumerable<float>), x => new ValueTask<float>(x)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(AsyncEnumerable.Empty<object>(), default(Func<object, ValueTask<float>>)).AsTask());
+        }
+
         [Fact]
         public async Task AverageAwaitAsync_Selector_Single_Empty()
         {
@@ -307,6 +423,13 @@ namespace Tests
         }
 
 #if !NO_DEEP_CANCELLATION
+        [Fact]
+        public async Task AverageAwaitWithCancellationAsync_Selector_Single_Null()
+        {
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitWithCancellationAsync(default(IAsyncEnumerable<float>), (x, ct) => new ValueTask<float>(x)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitWithCancellationAsync(AsyncEnumerable.Empty<object>(), default(Func<object, CancellationToken, ValueTask<float>>)).AsTask());
+        }
+
         [Fact]
         public async Task AverageAwaitWithCancellationAsync_Selector_Single_Empty()
         {
@@ -323,6 +446,12 @@ namespace Tests
         }
 #endif
 
+        [Fact]
+        public async Task AverageAsync_Single_Nullable_Null()
+        {
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<float?>)).AsTask());
+        }
+
         [Fact]
         public async Task AverageAsync_Single_Nullable_Empty()
         {
@@ -353,6 +482,14 @@ namespace Tests
             Assert.Equal(xs.Average(), await ys.AverageAsync(x => x));
         }
 
+        [Fact]
+        public async Task AverageAwaitAsync_Selector_Single_Nullable_Null()
+        {
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(default(IAsyncEnumerable<float?>), x => new ValueTask<float?>(x)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(AsyncEnumerable.Empty<object>(), default(Func<object, ValueTask<float?>>)).AsTask());
+        }
+
+
         [Fact]
         public async Task AverageAwaitAsync_Selector_Single_Nullable_Empty()
         {
@@ -369,6 +506,13 @@ namespace Tests
         }
 
 #if !NO_DEEP_CANCELLATION
+        [Fact]
+        public async Task AverageAwaitWithCancellationAsync_Selector_Single_Nullable_Null()
+        {
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitWithCancellationAsync(default(IAsyncEnumerable<float?>), (x, ct) => new ValueTask<float?>(x)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitWithCancellationAsync(AsyncEnumerable.Empty<object>(), default(Func<object, CancellationToken, ValueTask<float?>>)).AsTask());
+        }
+
         [Fact]
         public async Task AverageAwaitWithCancellationAsync_Selector_Single_Nullable_Empty()
         {
@@ -385,6 +529,12 @@ namespace Tests
         }
 #endif
 
+        [Fact]
+        public async Task AverageAsync_Double_Null()
+        {
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<double>)).AsTask());
+        }
+
         [Fact]
         public async Task AverageAsync_Double_Empty()
         {
@@ -400,6 +550,13 @@ namespace Tests
             Assert.Equal(xs.Average(), await ys.AverageAsync());
         }
 
+        [Fact]
+        public async Task AverageAsync_Selector_Double_Null()
+        {
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<double>), x => x).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(AsyncEnumerable.Empty<object>(), default(Func<object, double>)).AsTask());
+        }
+
         [Fact]
         public async Task AverageAsync_Selector_Double_Empty()
         {
@@ -415,6 +572,13 @@ namespace Tests
             Assert.Equal(xs.Average(), await ys.AverageAsync(x => x));
         }
 
+        [Fact]
+        public async Task AverageAwaitAsync_Selector_Double_Null()
+        {
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(default(IAsyncEnumerable<double>), x => new ValueTask<double>(x)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(AsyncEnumerable.Empty<object>(), default(Func<object, ValueTask<double>>)).AsTask());
+        }
+
         [Fact]
         public async Task AverageAwaitAsync_Selector_Double_Empty()
         {
@@ -431,6 +595,13 @@ namespace Tests
         }
 
 #if !NO_DEEP_CANCELLATION
+        [Fact]
+        public async Task AverageAwaitWithCancellationAsync_Selector_Double_Null()
+        {
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitWithCancellationAsync(default(IAsyncEnumerable<double>), (x, ct) => new ValueTask<double>(x)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitWithCancellationAsync(AsyncEnumerable.Empty<object>(), default(Func<object, CancellationToken, ValueTask<double>>)).AsTask());
+        }
+
         [Fact]
         public async Task AverageAwaitWithCancellationAsync_Selector_Double_Empty()
         {
@@ -447,6 +618,12 @@ namespace Tests
         }
 #endif
 
+        [Fact]
+        public async Task AverageAsync_Double_Nullable_Null()
+        {
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<double?>)).AsTask());
+        }
+
         [Fact]
         public async Task AverageAsync_Double_Nullable_Empty()
         {
@@ -477,6 +654,14 @@ namespace Tests
             Assert.Equal(xs.Average(), await ys.AverageAsync(x => x));
         }
 
+        [Fact]
+        public async Task AverageAwaitAsync_Selector_Double_Nullable_Null()
+        {
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(default(IAsyncEnumerable<double?>), x => new ValueTask<double?>(x)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(AsyncEnumerable.Empty<object>(), default(Func<object, ValueTask<double?>>)).AsTask());
+        }
+
+
         [Fact]
         public async Task AverageAwaitAsync_Selector_Double_Nullable_Empty()
         {
@@ -493,6 +678,13 @@ namespace Tests
         }
 
 #if !NO_DEEP_CANCELLATION
+        [Fact]
+        public async Task AverageAwaitWithCancellationAsync_Selector_Double_Nullable_Null()
+        {
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitWithCancellationAsync(default(IAsyncEnumerable<double?>), (x, ct) => new ValueTask<double?>(x)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitWithCancellationAsync(AsyncEnumerable.Empty<object>(), default(Func<object, CancellationToken, ValueTask<double?>>)).AsTask());
+        }
+
         [Fact]
         public async Task AverageAwaitWithCancellationAsync_Selector_Double_Nullable_Empty()
         {
@@ -509,6 +701,12 @@ namespace Tests
         }
 #endif
 
+        [Fact]
+        public async Task AverageAsync_Decimal_Null()
+        {
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<decimal>)).AsTask());
+        }
+
         [Fact]
         public async Task AverageAsync_Decimal_Empty()
         {
@@ -524,6 +722,13 @@ namespace Tests
             Assert.Equal(xs.Average(), await ys.AverageAsync());
         }
 
+        [Fact]
+        public async Task AverageAsync_Selector_Decimal_Null()
+        {
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<decimal>), x => x).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(AsyncEnumerable.Empty<object>(), default(Func<object, decimal>)).AsTask());
+        }
+
         [Fact]
         public async Task AverageAsync_Selector_Decimal_Empty()
         {
@@ -539,6 +744,13 @@ namespace Tests
             Assert.Equal(xs.Average(), await ys.AverageAsync(x => x));
         }
 
+        [Fact]
+        public async Task AverageAwaitAsync_Selector_Decimal_Null()
+        {
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(default(IAsyncEnumerable<decimal>), x => new ValueTask<decimal>(x)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(AsyncEnumerable.Empty<object>(), default(Func<object, ValueTask<decimal>>)).AsTask());
+        }
+
         [Fact]
         public async Task AverageAwaitAsync_Selector_Decimal_Empty()
         {
@@ -555,6 +767,13 @@ namespace Tests
         }
 
 #if !NO_DEEP_CANCELLATION
+        [Fact]
+        public async Task AverageAwaitWithCancellationAsync_Selector_Decimal_Null()
+        {
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitWithCancellationAsync(default(IAsyncEnumerable<decimal>), (x, ct) => new ValueTask<decimal>(x)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitWithCancellationAsync(AsyncEnumerable.Empty<object>(), default(Func<object, CancellationToken, ValueTask<decimal>>)).AsTask());
+        }
+
         [Fact]
         public async Task AverageAwaitWithCancellationAsync_Selector_Decimal_Empty()
         {
@@ -571,6 +790,12 @@ namespace Tests
         }
 #endif
 
+        [Fact]
+        public async Task AverageAsync_Decimal_Nullable_Null()
+        {
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<decimal?>)).AsTask());
+        }
+
         [Fact]
         public async Task AverageAsync_Decimal_Nullable_Empty()
         {
@@ -601,6 +826,14 @@ namespace Tests
             Assert.Equal(xs.Average(), await ys.AverageAsync(x => x));
         }
 
+        [Fact]
+        public async Task AverageAwaitAsync_Selector_Decimal_Nullable_Null()
+        {
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(default(IAsyncEnumerable<decimal?>), x => new ValueTask<decimal?>(x)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(AsyncEnumerable.Empty<object>(), default(Func<object, ValueTask<decimal?>>)).AsTask());
+        }
+
+
         [Fact]
         public async Task AverageAwaitAsync_Selector_Decimal_Nullable_Empty()
         {
@@ -617,6 +850,13 @@ namespace Tests
         }
 
 #if !NO_DEEP_CANCELLATION
+        [Fact]
+        public async Task AverageAwaitWithCancellationAsync_Selector_Decimal_Nullable_Null()
+        {
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitWithCancellationAsync(default(IAsyncEnumerable<decimal?>), (x, ct) => new ValueTask<decimal?>(x)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitWithCancellationAsync(AsyncEnumerable.Empty<object>(), default(Func<object, CancellationToken, ValueTask<decimal?>>)).AsTask());
+        }
+
         [Fact]
         public async Task AverageAwaitWithCancellationAsync_Selector_Decimal_Nullable_Empty()
         {

Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/Average.Generated.tt

@@ -43,6 +43,12 @@ foreach (var t in types)
 {
     var cs = toCSharp(t);
 #>
+        [Fact]
+        public async Task AverageAsync_<#=t.Name#>_Null()
+        {
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<<#=cs#>>)).AsTask());
+        }
+
         [Fact]
         public async Task AverageAsync_<#=t.Name#>_Empty()
         {
@@ -58,6 +64,13 @@ foreach (var t in types)
             Assert.Equal(xs.Average(), await ys.AverageAsync());
         }
 
+        [Fact]
+        public async Task AverageAsync_Selector_<#=t.Name#>_Null()
+        {
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<<#=cs#>>), x => x).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(AsyncEnumerable.Empty<object>(), default(Func<object, <#=cs#>>)).AsTask());
+        }
+
         [Fact]
         public async Task AverageAsync_Selector_<#=t.Name#>_Empty()
         {
@@ -73,6 +86,13 @@ foreach (var t in types)
             Assert.Equal(xs.Average(), await ys.AverageAsync(x => x));
         }
 
+        [Fact]
+        public async Task AverageAwaitAsync_Selector_<#=t.Name#>_Null()
+        {
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(default(IAsyncEnumerable<<#=cs#>>), x => new ValueTask<<#=cs#>>(x)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(AsyncEnumerable.Empty<object>(), default(Func<object, ValueTask<<#=cs#>>>)).AsTask());
+        }
+
         [Fact]
         public async Task AverageAwaitAsync_Selector_<#=t.Name#>_Empty()
         {
@@ -89,6 +109,13 @@ foreach (var t in types)
         }
 
 #if !NO_DEEP_CANCELLATION
+        [Fact]
+        public async Task AverageAwaitWithCancellationAsync_Selector_<#=t.Name#>_Null()
+        {
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitWithCancellationAsync(default(IAsyncEnumerable<<#=cs#>>), (x, ct) => new ValueTask<<#=cs#>>(x)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitWithCancellationAsync(AsyncEnumerable.Empty<object>(), default(Func<object, CancellationToken, ValueTask<<#=cs#>>>)).AsTask());
+        }
+
         [Fact]
         public async Task AverageAwaitWithCancellationAsync_Selector_<#=t.Name#>_Empty()
         {
@@ -105,6 +132,12 @@ foreach (var t in types)
         }
 #endif
 
+        [Fact]
+        public async Task AverageAsync_<#=t.Name#>_Nullable_Null()
+        {
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<<#=cs#>?>)).AsTask());
+        }
+
         [Fact]
         public async Task AverageAsync_<#=t.Name#>_Nullable_Empty()
         {
@@ -135,6 +168,14 @@ foreach (var t in types)
             Assert.Equal(xs.Average(), await ys.AverageAsync(x => x));
         }
 
+        [Fact]
+        public async Task AverageAwaitAsync_Selector_<#=t.Name#>_Nullable_Null()
+        {
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(default(IAsyncEnumerable<<#=cs#>?>), x => new ValueTask<<#=cs#>?>(x)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(AsyncEnumerable.Empty<object>(), default(Func<object, ValueTask<<#=cs#>?>>)).AsTask());
+        }
+
+
         [Fact]
         public async Task AverageAwaitAsync_Selector_<#=t.Name#>_Nullable_Empty()
         {
@@ -151,6 +192,13 @@ foreach (var t in types)
         }
 
 #if !NO_DEEP_CANCELLATION
+        [Fact]
+        public async Task AverageAwaitWithCancellationAsync_Selector_<#=t.Name#>_Nullable_Null()
+        {
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitWithCancellationAsync(default(IAsyncEnumerable<<#=cs#>?>), (x, ct) => new ValueTask<<#=cs#>?>(x)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitWithCancellationAsync(AsyncEnumerable.Empty<object>(), default(Func<object, CancellationToken, ValueTask<<#=cs#>?>>)).AsTask());
+        }
+
         [Fact]
         public async Task AverageAwaitWithCancellationAsync_Selector_<#=t.Name#>_Nullable_Empty()
         {

Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/Average.cs

@@ -1,348 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the Apache 2.0 License.
-// See the LICENSE file in the project root for more information. 
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using Xunit;
-
-namespace Tests
-{
-    public class Average : AsyncEnumerableTests
-    {
-        [Fact]
-        public async Task Average_Null()
-        {
-            // Average(IAE<P>)
-
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<int>)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<int?>)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<long>)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<long?>)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<double>)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<double?>)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<float>)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<float?>)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<decimal>)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<decimal?>)).AsTask());
-
-            // Average(IAE<P>, CT)
-
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<int>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<int?>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<long>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<long?>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<double>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<double?>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<float>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<float?>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<decimal>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<decimal?>), CancellationToken.None).AsTask());
-
-            // Average<T>(IAE<T>, Func<T, P>)
-
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<int>), x => x).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<int?>), x => x).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<long>), x => x).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<long?>), x => x).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<double>), x => x).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<double?>), x => x).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<float>), x => x).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<float?>), x => x).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<decimal>), x => x).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<decimal?>), x => x).AsTask());
-
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(AsyncEnumerable.Empty<int>(), default(Func<int, int>)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(AsyncEnumerable.Empty<int>(), default(Func<int, int?>)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(AsyncEnumerable.Empty<int>(), default(Func<int, long>)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(AsyncEnumerable.Empty<int>(), default(Func<int, long?>)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(AsyncEnumerable.Empty<int>(), default(Func<int, double>)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(AsyncEnumerable.Empty<int>(), default(Func<int, double?>)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(AsyncEnumerable.Empty<int>(), default(Func<int, float>)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(AsyncEnumerable.Empty<int>(), default(Func<int, float?>)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(AsyncEnumerable.Empty<int>(), default(Func<int, decimal>)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(AsyncEnumerable.Empty<int>(), default(Func<int, decimal?>)).AsTask());
-
-            // Average<T>(IAE<T>, Func<T, P>, CT)
-
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<int>), x => x, CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<int?>), x => x, CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<long>), x => x, CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<long?>), x => x, CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<double>), x => x, CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<double?>), x => x, CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<float>), x => x, CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<float?>), x => x, CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<decimal>), x => x, CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<decimal?>), x => x, CancellationToken.None).AsTask());
-
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(AsyncEnumerable.Empty<int>(), default, CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(AsyncEnumerable.Empty<int>(), default(Func<int, int?>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(AsyncEnumerable.Empty<int>(), default(Func<int, long>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(AsyncEnumerable.Empty<int>(), default(Func<int, long?>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(AsyncEnumerable.Empty<int>(), default(Func<int, double>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(AsyncEnumerable.Empty<int>(), default(Func<int, double?>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(AsyncEnumerable.Empty<int>(), default(Func<int, float>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(AsyncEnumerable.Empty<int>(), default(Func<int, float?>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(AsyncEnumerable.Empty<int>(), default(Func<int, decimal>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(AsyncEnumerable.Empty<int>(), default(Func<int, decimal?>), CancellationToken.None).AsTask());
-
-            // Average<T>(IAE<T>, Func<T, VT<P>>)
-
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(default(IAsyncEnumerable<int>), x => new ValueTask<int>(x)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(default(IAsyncEnumerable<int?>), x => new ValueTask<int?>(x)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(default(IAsyncEnumerable<long>), x => new ValueTask<long>(x)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(default(IAsyncEnumerable<long?>), x => new ValueTask<long?>(x)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(default(IAsyncEnumerable<double>), x => new ValueTask<double>(x)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(default(IAsyncEnumerable<double?>), x => new ValueTask<double?>(x)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(default(IAsyncEnumerable<float>), x => new ValueTask<float>(x)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(default(IAsyncEnumerable<float?>), x => new ValueTask<float?>(x)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(default(IAsyncEnumerable<decimal>), x => new ValueTask<decimal>(x)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(default(IAsyncEnumerable<decimal?>), x => new ValueTask<decimal?>(x)).AsTask());
-
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(AsyncEnumerable.Empty<int>(), default).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<int?>>)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<long>>)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<long?>>)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<double>>)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<double?>>)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<float>>)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<float?>>)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<decimal>>)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<decimal?>>)).AsTask());
-
-            // Average<T>(IAE<T>, Func<T, VT<P>>, CT)
-
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(default(IAsyncEnumerable<int>), x => new ValueTask<int>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(default(IAsyncEnumerable<int?>), x => new ValueTask<int?>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(default(IAsyncEnumerable<long>), x => new ValueTask<long>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(default(IAsyncEnumerable<long?>), x => new ValueTask<long?>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(default(IAsyncEnumerable<double>), x => new ValueTask<double>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(default(IAsyncEnumerable<double?>), x => new ValueTask<double?>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(default(IAsyncEnumerable<float>), x => new ValueTask<float>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(default(IAsyncEnumerable<float?>), x => new ValueTask<float?>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(default(IAsyncEnumerable<decimal>), x => new ValueTask<decimal>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(default(IAsyncEnumerable<decimal?>), x => new ValueTask<decimal?>(x), CancellationToken.None).AsTask());
-
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(AsyncEnumerable.Empty<int>(), default, CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<int?>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<long>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<long?>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<double>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<double?>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<float>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<float?>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<decimal>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<decimal?>>), CancellationToken.None).AsTask());
-
-#if !NO_DEEP_CANCELLATION
-            // Average<T>(IAE<T>, Func<T, CT, VT<P>>, CT)
-
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitWithCancellationAsync(default(IAsyncEnumerable<int>), (x, ct) => new ValueTask<int>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitWithCancellationAsync(default(IAsyncEnumerable<int?>), (x, ct) => new ValueTask<int?>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitWithCancellationAsync(default(IAsyncEnumerable<long>), (x, ct) => new ValueTask<long>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitWithCancellationAsync(default(IAsyncEnumerable<long?>), (x, ct) => new ValueTask<long?>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitWithCancellationAsync(default(IAsyncEnumerable<double>), (x, ct) => new ValueTask<double>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitWithCancellationAsync(default(IAsyncEnumerable<double?>), (x, ct) => new ValueTask<double?>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitWithCancellationAsync(default(IAsyncEnumerable<float>), (x, ct) => new ValueTask<float>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitWithCancellationAsync(default(IAsyncEnumerable<float?>), (x, ct) => new ValueTask<float?>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitWithCancellationAsync(default(IAsyncEnumerable<decimal>), (x, ct) => new ValueTask<decimal>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitWithCancellationAsync(default(IAsyncEnumerable<decimal?>), (x, ct) => new ValueTask<decimal?>(x), CancellationToken.None).AsTask());
-
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitWithCancellationAsync(AsyncEnumerable.Empty<int>(), default, CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitWithCancellationAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<int?>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitWithCancellationAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<long>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitWithCancellationAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<long?>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitWithCancellationAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<double>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitWithCancellationAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<double?>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitWithCancellationAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<float>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitWithCancellationAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<float?>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitWithCancellationAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<decimal>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitWithCancellationAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<decimal?>>), CancellationToken.None).AsTask());
-#endif
-        }
-
-        [Fact]
-        public async Task Average1()
-        {
-            var xs = new[] { 1, 2, 3 };
-            var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Average(), await ys.AverageAsync());
-            Assert.Equal(xs.Average(), await ys.AverageAsync(x => x));
-            Assert.Equal(xs.Average(), await ys.AverageAwaitAsync(x => new ValueTask<int>(x)));
-        }
-
-        [Fact]
-        public async Task Average2()
-        {
-            var xs = new[] { 1, default(int?), 3 };
-            var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Average(), await ys.AverageAsync());
-            Assert.Equal(xs.Average(), await ys.AverageAsync(x => x));
-            Assert.Equal(xs.Average(), await ys.AverageAwaitAsync(x => new ValueTask<int?>(x)));
-        }
-
-        [Fact]
-        public async Task Average3()
-        {
-            var xs = new[] { 1L, 2L, 3L };
-            var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Average(), await ys.AverageAsync());
-            Assert.Equal(xs.Average(), await ys.AverageAsync(x => x));
-            Assert.Equal(xs.Average(), await ys.AverageAwaitAsync(x => new ValueTask<long>(x)));
-        }
-
-        [Fact]
-        public async Task Average4()
-        {
-            var xs = new[] { 1L, default(long?), 3L };
-            var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Average(), await ys.AverageAsync());
-            Assert.Equal(xs.Average(), await ys.AverageAsync(x => x));
-            Assert.Equal(xs.Average(), await ys.AverageAwaitAsync(x => new ValueTask<long?>(x)));
-        }
-
-        [Fact]
-        public async Task Average5()
-        {
-            var xs = new[] { 1.0, 2.0, 3.0 };
-            var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Average(), await ys.AverageAsync());
-            Assert.Equal(xs.Average(), await ys.AverageAsync(x => x));
-            Assert.Equal(xs.Average(), await ys.AverageAwaitAsync(x => new ValueTask<double>(x)));
-        }
-
-        [Fact]
-        public async Task Average6()
-        {
-            var xs = new[] { 1.0, default(double?), 3.0 };
-            var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Average(), await ys.AverageAsync());
-            Assert.Equal(xs.Average(), await ys.AverageAsync(x => x));
-            Assert.Equal(xs.Average(), await ys.AverageAwaitAsync(x => new ValueTask<double?>(x)));
-        }
-
-        [Fact]
-        public async Task Average7()
-        {
-            var xs = new[] { 1.0f, 2.0f, 3.0f };
-            var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Average(), await ys.AverageAsync());
-            Assert.Equal(xs.Average(), await ys.AverageAsync(x => x));
-            Assert.Equal(xs.Average(), await ys.AverageAwaitAsync(x => new ValueTask<float>(x)));
-        }
-
-        [Fact]
-        public async Task Average8()
-        {
-            var xs = new[] { 1.0f, default(float?), 3.0f };
-            var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Average(), await ys.AverageAsync());
-            Assert.Equal(xs.Average(), await ys.AverageAsync(x => x));
-            Assert.Equal(xs.Average(), await ys.AverageAwaitAsync(x => new ValueTask<float?>(x)));
-        }
-
-        [Fact]
-        public async Task Average9()
-        {
-            var xs = new[] { 1.0m, 2.0m, 3.0m };
-            var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Average(), await ys.AverageAsync());
-            Assert.Equal(xs.Average(), await ys.AverageAsync(x => x));
-            Assert.Equal(xs.Average(), await ys.AverageAwaitAsync(x => new ValueTask<decimal>(x)));
-        }
-
-        [Fact]
-        public async Task Average10()
-        {
-            var xs = new[] { 1.0m, default(decimal?), 3.0m };
-            var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Average(), await ys.AverageAsync());
-            Assert.Equal(xs.Average(), await ys.AverageAsync(x => x));
-            Assert.Equal(xs.Average(), await ys.AverageAwaitAsync(x => new ValueTask<decimal?>(x)));
-        }
-
-        [Fact]
-        public async Task Average11()
-        {
-            var xs = new int[0];
-            var ys = xs.ToAsyncEnumerable();
-            await Assert.ThrowsAsync<InvalidOperationException>(() => ys.AverageAsync().AsTask());
-        }
-
-        [Fact]
-        public async Task Average12()
-        {
-            var xs = new int?[0];
-            var ys = xs.ToAsyncEnumerable();
-            Assert.Null(await ys.AverageAsync());
-        }
-
-        [Fact]
-        public async Task Average13()
-        {
-            var xs = new long[0];
-            var ys = xs.ToAsyncEnumerable();
-            await Assert.ThrowsAsync<InvalidOperationException>(() => ys.AverageAsync().AsTask());
-        }
-
-        [Fact]
-        public async Task Average14()
-        {
-            var xs = new long?[0];
-            var ys = xs.ToAsyncEnumerable();
-            Assert.Null(await ys.AverageAsync());
-        }
-
-        [Fact]
-        public async Task Average15()
-        {
-            var xs = new double[0];
-            var ys = xs.ToAsyncEnumerable();
-            await Assert.ThrowsAsync<InvalidOperationException>(() => ys.AverageAsync().AsTask());
-        }
-
-        [Fact]
-        public async Task Average16()
-        {
-            var xs = new double?[0];
-            var ys = xs.ToAsyncEnumerable();
-            Assert.Null(await ys.AverageAsync());
-        }
-
-        [Fact]
-        public async Task Average17()
-        {
-            var xs = new float[0];
-            var ys = xs.ToAsyncEnumerable();
-            await Assert.ThrowsAsync<InvalidOperationException>(() => ys.AverageAsync().AsTask());
-        }
-
-        [Fact]
-        public async Task Average18()
-        {
-            var xs = new float?[0];
-            var ys = xs.ToAsyncEnumerable();
-            Assert.Null(await ys.AverageAsync());
-        }
-
-        [Fact]
-        public async Task Average19()
-        {
-            var xs = new decimal[0];
-            var ys = xs.ToAsyncEnumerable();
-            await Assert.ThrowsAsync<InvalidOperationException>(() => ys.AverageAsync().AsTask());
-        }
-
-        [Fact]
-        public async Task Average20()
-        {
-            var xs = new decimal?[0];
-            var ys = xs.ToAsyncEnumerable();
-            Assert.Null(await ys.AverageAsync());
-        }
-    }
-}