More tests for Average.

Ix.NET/Source/System.Linq.Async.Tests/System.Linq.Async.Tests.csproj

@@ -15,6 +15,11 @@
 
 
   <ItemGroup>
+    <None Include="System\Linq\Operators\Average.Generated.cs">
+      <DesignTime>True</DesignTime>
+      <AutoGen>True</AutoGen>
+      <DependentUpon>Average.Generated.tt</DependentUpon>
+    </None>
     <None Include="System\Linq\Operators\MinMax.Generated.cs">
       <DesignTime>True</DesignTime>
       <AutoGen>True</AutoGen>
@@ -35,6 +40,10 @@
   </ItemGroup>
 
   <ItemGroup>
+    <None Update="System\Linq\Operators\Average.Generated.tt">
+      <Generator>TextTemplatingFileGenerator</Generator>
+      <LastGenOutput>Average.Generated.cs</LastGenOutput>
+    </None>
     <None Update="System\Linq\Operators\MinMax.Generated.tt">
       <Generator>TextTemplatingFileGenerator</Generator>
       <LastGenOutput>MinMax.Generated.cs</LastGenOutput>
@@ -46,6 +55,11 @@
   </ItemGroup>
 
   <ItemGroup>
+    <Compile Update="System\Linq\Operators\Average.Generated.cs">
+      <DesignTime>True</DesignTime>
+      <AutoGen>True</AutoGen>
+      <DependentUpon>Average.Generated.tt</DependentUpon>
+    </Compile>
     <Compile Update="System\Linq\Operators\MinMax.Generated.cs">
       <DesignTime>True</DesignTime>
       <AutoGen>True</AutoGen>

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

@@ -0,0 +1,637 @@
+// 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 AverageAsync : AsyncEnumerableTests
+    {
+        [Fact]
+        public async Task AverageAsync_Int32_Empty()
+        {
+            var ys = new int[0].ToAsyncEnumerable();
+            await Assert.ThrowsAsync<InvalidOperationException>(() => ys.AverageAsync());
+        }
+
+        [Fact]
+        public async Task AverageAsync_Int32_Many()
+        {
+            var xs = new int[] { 2, 3, 5, 7, 11, 13, 17, 19 };
+            var ys = xs.ToAsyncEnumerable();
+            Assert.Equal(xs.Average(), await ys.AverageAsync());
+        }
+
+        [Fact]
+        public async Task AverageAsync_Selector_Int32_Empty()
+        {
+            var ys = new int[0].ToAsyncEnumerable();
+            await Assert.ThrowsAsync<InvalidOperationException>(() => ys.AverageAsync(x => x));
+        }
+
+        [Fact]
+        public async Task AverageAsync_Selector_Int32_Many()
+        {
+            var xs = new int[] { 2, 3, 5, 7, 11, 13, 17, 19 };
+            var ys = xs.ToAsyncEnumerable();
+            Assert.Equal(xs.Average(), await ys.AverageAsync(x => x));
+        }
+
+        [Fact]
+        public async Task AverageAsync_AsyncSelector_Int32_Empty()
+        {
+            var ys = new int[0].ToAsyncEnumerable();
+            await Assert.ThrowsAsync<InvalidOperationException>(() => ys.AverageAsync(x => new ValueTask<int>(x)));
+        }
+
+        [Fact]
+        public async Task AverageAsync_AsyncSelector_Int32_Many()
+        {
+            var xs = new int[] { 2, 3, 5, 7, 11, 13, 17, 19 };
+            var ys = xs.ToAsyncEnumerable();
+            Assert.Equal(xs.Average(), await ys.AverageAsync(x => new ValueTask<int>(x)));
+        }
+
+#if !NO_DEEP_CANCELLATION
+        [Fact]
+        public async Task AverageAsync_AsyncSelectorWithCancellation_Int32_Empty()
+        {
+            var ys = new int[0].ToAsyncEnumerable();
+            await Assert.ThrowsAsync<InvalidOperationException>(() => ys.AverageAsync((x, ct) => new ValueTask<int>(x), CancellationToken.None));
+        }
+
+        [Fact]
+        public async Task AverageAsync_AsyncSelectorWithCancellation_Int32_Many()
+        {
+            var xs = new int[] { 2, 3, 5, 7, 11, 13, 17, 19 };
+            var ys = xs.ToAsyncEnumerable();
+            Assert.Equal(xs.Average(), await ys.AverageAsync((x, ct) => new ValueTask<int>(x), CancellationToken.None));
+        }
+#endif
+
+        [Fact]
+        public async Task AverageAsync_Int32_Nullable_Empty()
+        {
+            var ys = new int?[0].ToAsyncEnumerable();
+            Assert.Null(await ys.AverageAsync());
+        }
+
+        [Fact]
+        public async Task AverageAsync_Int32_Nullable_Many()
+        {
+            var xs = new int?[] { 2, 3, 5, 7, 11, 13, 17, 19 };
+            var ys = xs.ToAsyncEnumerable();
+            Assert.Equal(xs.Average(), await ys.AverageAsync());
+        }
+
+        [Fact]
+        public async Task AverageAsync_Selector_Int32_Nullable_Empty()
+        {
+            var ys = new int?[0].ToAsyncEnumerable();
+            Assert.Null(await ys.AverageAsync(x => x));
+        }
+
+        [Fact]
+        public async Task AverageAsync_Selector_Int32_Nullable_Many()
+        {
+            var xs = new int?[] { 2, 3, 5, 7, 11, 13, 17, 19 };
+            var ys = xs.ToAsyncEnumerable();
+            Assert.Equal(xs.Average(), await ys.AverageAsync(x => x));
+        }
+
+        [Fact]
+        public async Task AverageAsync_AsyncSelector_Int32_Nullable_Empty()
+        {
+            var ys = new int?[0].ToAsyncEnumerable();
+            Assert.Null(await ys.AverageAsync(x => new ValueTask<int?>(x)));
+        }
+
+        [Fact]
+        public async Task AverageAsync_AsyncSelector_Int32_Nullable_Many()
+        {
+            var xs = new int?[] { 2, 3, 5, 7, 11, 13, 17, 19 };
+            var ys = xs.ToAsyncEnumerable();
+            Assert.Equal(xs.Average(), await ys.AverageAsync(x => new ValueTask<int?>(x)));
+        }
+
+#if !NO_DEEP_CANCELLATION
+        [Fact]
+        public async Task AverageAsync_AsyncSelectorWithCancellation_Int32_Nullable_Empty()
+        {
+            var ys = new int?[0].ToAsyncEnumerable();
+            Assert.Null(await ys.AverageAsync((x, ct) => new ValueTask<int?>(x), CancellationToken.None));
+        }
+
+        [Fact]
+        public async Task AverageAsync_AsyncSelectorWithCancellation_Int32_Nullable_Many()
+        {
+            var xs = new int?[] { 2, 3, 5, 7, 11, 13, 17, 19 };
+            var ys = xs.ToAsyncEnumerable();
+            Assert.Equal(xs.Average(), await ys.AverageAsync((x, ct) => new ValueTask<int?>(x), CancellationToken.None));
+        }
+#endif
+
+        [Fact]
+        public async Task AverageAsync_Int64_Empty()
+        {
+            var ys = new long[0].ToAsyncEnumerable();
+            await Assert.ThrowsAsync<InvalidOperationException>(() => ys.AverageAsync());
+        }
+
+        [Fact]
+        public async Task AverageAsync_Int64_Many()
+        {
+            var xs = new long[] { 2, 3, 5, 7, 11, 13, 17, 19 };
+            var ys = xs.ToAsyncEnumerable();
+            Assert.Equal(xs.Average(), await ys.AverageAsync());
+        }
+
+        [Fact]
+        public async Task AverageAsync_Selector_Int64_Empty()
+        {
+            var ys = new long[0].ToAsyncEnumerable();
+            await Assert.ThrowsAsync<InvalidOperationException>(() => ys.AverageAsync(x => x));
+        }
+
+        [Fact]
+        public async Task AverageAsync_Selector_Int64_Many()
+        {
+            var xs = new long[] { 2, 3, 5, 7, 11, 13, 17, 19 };
+            var ys = xs.ToAsyncEnumerable();
+            Assert.Equal(xs.Average(), await ys.AverageAsync(x => x));
+        }
+
+        [Fact]
+        public async Task AverageAsync_AsyncSelector_Int64_Empty()
+        {
+            var ys = new long[0].ToAsyncEnumerable();
+            await Assert.ThrowsAsync<InvalidOperationException>(() => ys.AverageAsync(x => new ValueTask<long>(x)));
+        }
+
+        [Fact]
+        public async Task AverageAsync_AsyncSelector_Int64_Many()
+        {
+            var xs = new long[] { 2, 3, 5, 7, 11, 13, 17, 19 };
+            var ys = xs.ToAsyncEnumerable();
+            Assert.Equal(xs.Average(), await ys.AverageAsync(x => new ValueTask<long>(x)));
+        }
+
+#if !NO_DEEP_CANCELLATION
+        [Fact]
+        public async Task AverageAsync_AsyncSelectorWithCancellation_Int64_Empty()
+        {
+            var ys = new long[0].ToAsyncEnumerable();
+            await Assert.ThrowsAsync<InvalidOperationException>(() => ys.AverageAsync((x, ct) => new ValueTask<long>(x), CancellationToken.None));
+        }
+
+        [Fact]
+        public async Task AverageAsync_AsyncSelectorWithCancellation_Int64_Many()
+        {
+            var xs = new long[] { 2, 3, 5, 7, 11, 13, 17, 19 };
+            var ys = xs.ToAsyncEnumerable();
+            Assert.Equal(xs.Average(), await ys.AverageAsync((x, ct) => new ValueTask<long>(x), CancellationToken.None));
+        }
+#endif
+
+        [Fact]
+        public async Task AverageAsync_Int64_Nullable_Empty()
+        {
+            var ys = new long?[0].ToAsyncEnumerable();
+            Assert.Null(await ys.AverageAsync());
+        }
+
+        [Fact]
+        public async Task AverageAsync_Int64_Nullable_Many()
+        {
+            var xs = new long?[] { 2, 3, 5, 7, 11, 13, 17, 19 };
+            var ys = xs.ToAsyncEnumerable();
+            Assert.Equal(xs.Average(), await ys.AverageAsync());
+        }
+
+        [Fact]
+        public async Task AverageAsync_Selector_Int64_Nullable_Empty()
+        {
+            var ys = new long?[0].ToAsyncEnumerable();
+            Assert.Null(await ys.AverageAsync(x => x));
+        }
+
+        [Fact]
+        public async Task AverageAsync_Selector_Int64_Nullable_Many()
+        {
+            var xs = new long?[] { 2, 3, 5, 7, 11, 13, 17, 19 };
+            var ys = xs.ToAsyncEnumerable();
+            Assert.Equal(xs.Average(), await ys.AverageAsync(x => x));
+        }
+
+        [Fact]
+        public async Task AverageAsync_AsyncSelector_Int64_Nullable_Empty()
+        {
+            var ys = new long?[0].ToAsyncEnumerable();
+            Assert.Null(await ys.AverageAsync(x => new ValueTask<long?>(x)));
+        }
+
+        [Fact]
+        public async Task AverageAsync_AsyncSelector_Int64_Nullable_Many()
+        {
+            var xs = new long?[] { 2, 3, 5, 7, 11, 13, 17, 19 };
+            var ys = xs.ToAsyncEnumerable();
+            Assert.Equal(xs.Average(), await ys.AverageAsync(x => new ValueTask<long?>(x)));
+        }
+
+#if !NO_DEEP_CANCELLATION
+        [Fact]
+        public async Task AverageAsync_AsyncSelectorWithCancellation_Int64_Nullable_Empty()
+        {
+            var ys = new long?[0].ToAsyncEnumerable();
+            Assert.Null(await ys.AverageAsync((x, ct) => new ValueTask<long?>(x), CancellationToken.None));
+        }
+
+        [Fact]
+        public async Task AverageAsync_AsyncSelectorWithCancellation_Int64_Nullable_Many()
+        {
+            var xs = new long?[] { 2, 3, 5, 7, 11, 13, 17, 19 };
+            var ys = xs.ToAsyncEnumerable();
+            Assert.Equal(xs.Average(), await ys.AverageAsync((x, ct) => new ValueTask<long?>(x), CancellationToken.None));
+        }
+#endif
+
+        [Fact]
+        public async Task AverageAsync_Single_Empty()
+        {
+            var ys = new float[0].ToAsyncEnumerable();
+            await Assert.ThrowsAsync<InvalidOperationException>(() => ys.AverageAsync());
+        }
+
+        [Fact]
+        public async Task AverageAsync_Single_Many()
+        {
+            var xs = new float[] { 2, 3, 5, 7, 11, 13, 17, 19 };
+            var ys = xs.ToAsyncEnumerable();
+            Assert.Equal(xs.Average(), await ys.AverageAsync());
+        }
+
+        [Fact]
+        public async Task AverageAsync_Selector_Single_Empty()
+        {
+            var ys = new float[0].ToAsyncEnumerable();
+            await Assert.ThrowsAsync<InvalidOperationException>(() => ys.AverageAsync(x => x));
+        }
+
+        [Fact]
+        public async Task AverageAsync_Selector_Single_Many()
+        {
+            var xs = new float[] { 2, 3, 5, 7, 11, 13, 17, 19 };
+            var ys = xs.ToAsyncEnumerable();
+            Assert.Equal(xs.Average(), await ys.AverageAsync(x => x));
+        }
+
+        [Fact]
+        public async Task AverageAsync_AsyncSelector_Single_Empty()
+        {
+            var ys = new float[0].ToAsyncEnumerable();
+            await Assert.ThrowsAsync<InvalidOperationException>(() => ys.AverageAsync(x => new ValueTask<float>(x)));
+        }
+
+        [Fact]
+        public async Task AverageAsync_AsyncSelector_Single_Many()
+        {
+            var xs = new float[] { 2, 3, 5, 7, 11, 13, 17, 19 };
+            var ys = xs.ToAsyncEnumerable();
+            Assert.Equal(xs.Average(), await ys.AverageAsync(x => new ValueTask<float>(x)));
+        }
+
+#if !NO_DEEP_CANCELLATION
+        [Fact]
+        public async Task AverageAsync_AsyncSelectorWithCancellation_Single_Empty()
+        {
+            var ys = new float[0].ToAsyncEnumerable();
+            await Assert.ThrowsAsync<InvalidOperationException>(() => ys.AverageAsync((x, ct) => new ValueTask<float>(x), CancellationToken.None));
+        }
+
+        [Fact]
+        public async Task AverageAsync_AsyncSelectorWithCancellation_Single_Many()
+        {
+            var xs = new float[] { 2, 3, 5, 7, 11, 13, 17, 19 };
+            var ys = xs.ToAsyncEnumerable();
+            Assert.Equal(xs.Average(), await ys.AverageAsync((x, ct) => new ValueTask<float>(x), CancellationToken.None));
+        }
+#endif
+
+        [Fact]
+        public async Task AverageAsync_Single_Nullable_Empty()
+        {
+            var ys = new float?[0].ToAsyncEnumerable();
+            Assert.Null(await ys.AverageAsync());
+        }
+
+        [Fact]
+        public async Task AverageAsync_Single_Nullable_Many()
+        {
+            var xs = new float?[] { 2, 3, 5, 7, 11, 13, 17, 19 };
+            var ys = xs.ToAsyncEnumerable();
+            Assert.Equal(xs.Average(), await ys.AverageAsync());
+        }
+
+        [Fact]
+        public async Task AverageAsync_Selector_Single_Nullable_Empty()
+        {
+            var ys = new float?[0].ToAsyncEnumerable();
+            Assert.Null(await ys.AverageAsync(x => x));
+        }
+
+        [Fact]
+        public async Task AverageAsync_Selector_Single_Nullable_Many()
+        {
+            var xs = new float?[] { 2, 3, 5, 7, 11, 13, 17, 19 };
+            var ys = xs.ToAsyncEnumerable();
+            Assert.Equal(xs.Average(), await ys.AverageAsync(x => x));
+        }
+
+        [Fact]
+        public async Task AverageAsync_AsyncSelector_Single_Nullable_Empty()
+        {
+            var ys = new float?[0].ToAsyncEnumerable();
+            Assert.Null(await ys.AverageAsync(x => new ValueTask<float?>(x)));
+        }
+
+        [Fact]
+        public async Task AverageAsync_AsyncSelector_Single_Nullable_Many()
+        {
+            var xs = new float?[] { 2, 3, 5, 7, 11, 13, 17, 19 };
+            var ys = xs.ToAsyncEnumerable();
+            Assert.Equal(xs.Average(), await ys.AverageAsync(x => new ValueTask<float?>(x)));
+        }
+
+#if !NO_DEEP_CANCELLATION
+        [Fact]
+        public async Task AverageAsync_AsyncSelectorWithCancellation_Single_Nullable_Empty()
+        {
+            var ys = new float?[0].ToAsyncEnumerable();
+            Assert.Null(await ys.AverageAsync((x, ct) => new ValueTask<float?>(x), CancellationToken.None));
+        }
+
+        [Fact]
+        public async Task AverageAsync_AsyncSelectorWithCancellation_Single_Nullable_Many()
+        {
+            var xs = new float?[] { 2, 3, 5, 7, 11, 13, 17, 19 };
+            var ys = xs.ToAsyncEnumerable();
+            Assert.Equal(xs.Average(), await ys.AverageAsync((x, ct) => new ValueTask<float?>(x), CancellationToken.None));
+        }
+#endif
+
+        [Fact]
+        public async Task AverageAsync_Double_Empty()
+        {
+            var ys = new double[0].ToAsyncEnumerable();
+            await Assert.ThrowsAsync<InvalidOperationException>(() => ys.AverageAsync());
+        }
+
+        [Fact]
+        public async Task AverageAsync_Double_Many()
+        {
+            var xs = new double[] { 2, 3, 5, 7, 11, 13, 17, 19 };
+            var ys = xs.ToAsyncEnumerable();
+            Assert.Equal(xs.Average(), await ys.AverageAsync());
+        }
+
+        [Fact]
+        public async Task AverageAsync_Selector_Double_Empty()
+        {
+            var ys = new double[0].ToAsyncEnumerable();
+            await Assert.ThrowsAsync<InvalidOperationException>(() => ys.AverageAsync(x => x));
+        }
+
+        [Fact]
+        public async Task AverageAsync_Selector_Double_Many()
+        {
+            var xs = new double[] { 2, 3, 5, 7, 11, 13, 17, 19 };
+            var ys = xs.ToAsyncEnumerable();
+            Assert.Equal(xs.Average(), await ys.AverageAsync(x => x));
+        }
+
+        [Fact]
+        public async Task AverageAsync_AsyncSelector_Double_Empty()
+        {
+            var ys = new double[0].ToAsyncEnumerable();
+            await Assert.ThrowsAsync<InvalidOperationException>(() => ys.AverageAsync(x => new ValueTask<double>(x)));
+        }
+
+        [Fact]
+        public async Task AverageAsync_AsyncSelector_Double_Many()
+        {
+            var xs = new double[] { 2, 3, 5, 7, 11, 13, 17, 19 };
+            var ys = xs.ToAsyncEnumerable();
+            Assert.Equal(xs.Average(), await ys.AverageAsync(x => new ValueTask<double>(x)));
+        }
+
+#if !NO_DEEP_CANCELLATION
+        [Fact]
+        public async Task AverageAsync_AsyncSelectorWithCancellation_Double_Empty()
+        {
+            var ys = new double[0].ToAsyncEnumerable();
+            await Assert.ThrowsAsync<InvalidOperationException>(() => ys.AverageAsync((x, ct) => new ValueTask<double>(x), CancellationToken.None));
+        }
+
+        [Fact]
+        public async Task AverageAsync_AsyncSelectorWithCancellation_Double_Many()
+        {
+            var xs = new double[] { 2, 3, 5, 7, 11, 13, 17, 19 };
+            var ys = xs.ToAsyncEnumerable();
+            Assert.Equal(xs.Average(), await ys.AverageAsync((x, ct) => new ValueTask<double>(x), CancellationToken.None));
+        }
+#endif
+
+        [Fact]
+        public async Task AverageAsync_Double_Nullable_Empty()
+        {
+            var ys = new double?[0].ToAsyncEnumerable();
+            Assert.Null(await ys.AverageAsync());
+        }
+
+        [Fact]
+        public async Task AverageAsync_Double_Nullable_Many()
+        {
+            var xs = new double?[] { 2, 3, 5, 7, 11, 13, 17, 19 };
+            var ys = xs.ToAsyncEnumerable();
+            Assert.Equal(xs.Average(), await ys.AverageAsync());
+        }
+
+        [Fact]
+        public async Task AverageAsync_Selector_Double_Nullable_Empty()
+        {
+            var ys = new double?[0].ToAsyncEnumerable();
+            Assert.Null(await ys.AverageAsync(x => x));
+        }
+
+        [Fact]
+        public async Task AverageAsync_Selector_Double_Nullable_Many()
+        {
+            var xs = new double?[] { 2, 3, 5, 7, 11, 13, 17, 19 };
+            var ys = xs.ToAsyncEnumerable();
+            Assert.Equal(xs.Average(), await ys.AverageAsync(x => x));
+        }
+
+        [Fact]
+        public async Task AverageAsync_AsyncSelector_Double_Nullable_Empty()
+        {
+            var ys = new double?[0].ToAsyncEnumerable();
+            Assert.Null(await ys.AverageAsync(x => new ValueTask<double?>(x)));
+        }
+
+        [Fact]
+        public async Task AverageAsync_AsyncSelector_Double_Nullable_Many()
+        {
+            var xs = new double?[] { 2, 3, 5, 7, 11, 13, 17, 19 };
+            var ys = xs.ToAsyncEnumerable();
+            Assert.Equal(xs.Average(), await ys.AverageAsync(x => new ValueTask<double?>(x)));
+        }
+
+#if !NO_DEEP_CANCELLATION
+        [Fact]
+        public async Task AverageAsync_AsyncSelectorWithCancellation_Double_Nullable_Empty()
+        {
+            var ys = new double?[0].ToAsyncEnumerable();
+            Assert.Null(await ys.AverageAsync((x, ct) => new ValueTask<double?>(x), CancellationToken.None));
+        }
+
+        [Fact]
+        public async Task AverageAsync_AsyncSelectorWithCancellation_Double_Nullable_Many()
+        {
+            var xs = new double?[] { 2, 3, 5, 7, 11, 13, 17, 19 };
+            var ys = xs.ToAsyncEnumerable();
+            Assert.Equal(xs.Average(), await ys.AverageAsync((x, ct) => new ValueTask<double?>(x), CancellationToken.None));
+        }
+#endif
+
+        [Fact]
+        public async Task AverageAsync_Decimal_Empty()
+        {
+            var ys = new decimal[0].ToAsyncEnumerable();
+            await Assert.ThrowsAsync<InvalidOperationException>(() => ys.AverageAsync());
+        }
+
+        [Fact]
+        public async Task AverageAsync_Decimal_Many()
+        {
+            var xs = new decimal[] { 2, 3, 5, 7, 11, 13, 17, 19 };
+            var ys = xs.ToAsyncEnumerable();
+            Assert.Equal(xs.Average(), await ys.AverageAsync());
+        }
+
+        [Fact]
+        public async Task AverageAsync_Selector_Decimal_Empty()
+        {
+            var ys = new decimal[0].ToAsyncEnumerable();
+            await Assert.ThrowsAsync<InvalidOperationException>(() => ys.AverageAsync(x => x));
+        }
+
+        [Fact]
+        public async Task AverageAsync_Selector_Decimal_Many()
+        {
+            var xs = new decimal[] { 2, 3, 5, 7, 11, 13, 17, 19 };
+            var ys = xs.ToAsyncEnumerable();
+            Assert.Equal(xs.Average(), await ys.AverageAsync(x => x));
+        }
+
+        [Fact]
+        public async Task AverageAsync_AsyncSelector_Decimal_Empty()
+        {
+            var ys = new decimal[0].ToAsyncEnumerable();
+            await Assert.ThrowsAsync<InvalidOperationException>(() => ys.AverageAsync(x => new ValueTask<decimal>(x)));
+        }
+
+        [Fact]
+        public async Task AverageAsync_AsyncSelector_Decimal_Many()
+        {
+            var xs = new decimal[] { 2, 3, 5, 7, 11, 13, 17, 19 };
+            var ys = xs.ToAsyncEnumerable();
+            Assert.Equal(xs.Average(), await ys.AverageAsync(x => new ValueTask<decimal>(x)));
+        }
+
+#if !NO_DEEP_CANCELLATION
+        [Fact]
+        public async Task AverageAsync_AsyncSelectorWithCancellation_Decimal_Empty()
+        {
+            var ys = new decimal[0].ToAsyncEnumerable();
+            await Assert.ThrowsAsync<InvalidOperationException>(() => ys.AverageAsync((x, ct) => new ValueTask<decimal>(x), CancellationToken.None));
+        }
+
+        [Fact]
+        public async Task AverageAsync_AsyncSelectorWithCancellation_Decimal_Many()
+        {
+            var xs = new decimal[] { 2, 3, 5, 7, 11, 13, 17, 19 };
+            var ys = xs.ToAsyncEnumerable();
+            Assert.Equal(xs.Average(), await ys.AverageAsync((x, ct) => new ValueTask<decimal>(x), CancellationToken.None));
+        }
+#endif
+
+        [Fact]
+        public async Task AverageAsync_Decimal_Nullable_Empty()
+        {
+            var ys = new decimal?[0].ToAsyncEnumerable();
+            Assert.Null(await ys.AverageAsync());
+        }
+
+        [Fact]
+        public async Task AverageAsync_Decimal_Nullable_Many()
+        {
+            var xs = new decimal?[] { 2, 3, 5, 7, 11, 13, 17, 19 };
+            var ys = xs.ToAsyncEnumerable();
+            Assert.Equal(xs.Average(), await ys.AverageAsync());
+        }
+
+        [Fact]
+        public async Task AverageAsync_Selector_Decimal_Nullable_Empty()
+        {
+            var ys = new decimal?[0].ToAsyncEnumerable();
+            Assert.Null(await ys.AverageAsync(x => x));
+        }
+
+        [Fact]
+        public async Task AverageAsync_Selector_Decimal_Nullable_Many()
+        {
+            var xs = new decimal?[] { 2, 3, 5, 7, 11, 13, 17, 19 };
+            var ys = xs.ToAsyncEnumerable();
+            Assert.Equal(xs.Average(), await ys.AverageAsync(x => x));
+        }
+
+        [Fact]
+        public async Task AverageAsync_AsyncSelector_Decimal_Nullable_Empty()
+        {
+            var ys = new decimal?[0].ToAsyncEnumerable();
+            Assert.Null(await ys.AverageAsync(x => new ValueTask<decimal?>(x)));
+        }
+
+        [Fact]
+        public async Task AverageAsync_AsyncSelector_Decimal_Nullable_Many()
+        {
+            var xs = new decimal?[] { 2, 3, 5, 7, 11, 13, 17, 19 };
+            var ys = xs.ToAsyncEnumerable();
+            Assert.Equal(xs.Average(), await ys.AverageAsync(x => new ValueTask<decimal?>(x)));
+        }
+
+#if !NO_DEEP_CANCELLATION
+        [Fact]
+        public async Task AverageAsync_AsyncSelectorWithCancellation_Decimal_Nullable_Empty()
+        {
+            var ys = new decimal?[0].ToAsyncEnumerable();
+            Assert.Null(await ys.AverageAsync((x, ct) => new ValueTask<decimal?>(x), CancellationToken.None));
+        }
+
+        [Fact]
+        public async Task AverageAsync_AsyncSelectorWithCancellation_Decimal_Nullable_Many()
+        {
+            var xs = new decimal?[] { 2, 3, 5, 7, 11, 13, 17, 19 };
+            var ys = xs.ToAsyncEnumerable();
+            Assert.Equal(xs.Average(), await ys.AverageAsync((x, ct) => new ValueTask<decimal?>(x), CancellationToken.None));
+        }
+#endif
+
+    }
+}

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

@@ -0,0 +1,174 @@
+// 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. 
+
+<#@ template debug="false" hostspecific="false" language="C#" #>
+<#@ assembly name="System.Core" #>
+<#@ import namespace="System.Linq" #>
+<#@ import namespace="System.Text" #>
+<#@ import namespace="System.Collections.Generic" #>
+<#@ output extension=".cs" #>
+<#
+var types = new[] { typeof(int), typeof(long), typeof(float), typeof(double), typeof(decimal) };
+
+Func<Type, string> toCSharp = t =>
+{
+    if (t == typeof(int))
+        return "int";
+    else if (t == typeof(long))
+        return "long";
+    else if (t == typeof(float))
+        return "float";
+    else if (t == typeof(double))
+        return "double";
+    else if (t == typeof(decimal))
+        return "decimal";
+
+    throw new Exception();
+};
+#>
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace Tests
+{
+    public class AverageAsync : AsyncEnumerableTests
+    {
+<#
+foreach (var t in types)
+{
+    var cs = toCSharp(t);
+#>
+        [Fact]
+        public async Task AverageAsync_<#=t.Name#>_Empty()
+        {
+            var ys = new <#=cs#>[0].ToAsyncEnumerable();
+            await Assert.ThrowsAsync<InvalidOperationException>(() => ys.AverageAsync());
+        }
+
+        [Fact]
+        public async Task AverageAsync_<#=t.Name#>_Many()
+        {
+            var xs = new <#=cs#>[] { 2, 3, 5, 7, 11, 13, 17, 19 };
+            var ys = xs.ToAsyncEnumerable();
+            Assert.Equal(xs.Average(), await ys.AverageAsync());
+        }
+
+        [Fact]
+        public async Task AverageAsync_Selector_<#=t.Name#>_Empty()
+        {
+            var ys = new <#=cs#>[0].ToAsyncEnumerable();
+            await Assert.ThrowsAsync<InvalidOperationException>(() => ys.AverageAsync(x => x));
+        }
+
+        [Fact]
+        public async Task AverageAsync_Selector_<#=t.Name#>_Many()
+        {
+            var xs = new <#=cs#>[] { 2, 3, 5, 7, 11, 13, 17, 19 };
+            var ys = xs.ToAsyncEnumerable();
+            Assert.Equal(xs.Average(), await ys.AverageAsync(x => x));
+        }
+
+        [Fact]
+        public async Task AverageAsync_AsyncSelector_<#=t.Name#>_Empty()
+        {
+            var ys = new <#=cs#>[0].ToAsyncEnumerable();
+            await Assert.ThrowsAsync<InvalidOperationException>(() => ys.AverageAsync(x => new ValueTask<<#=cs#>>(x)));
+        }
+
+        [Fact]
+        public async Task AverageAsync_AsyncSelector_<#=t.Name#>_Many()
+        {
+            var xs = new <#=cs#>[] { 2, 3, 5, 7, 11, 13, 17, 19 };
+            var ys = xs.ToAsyncEnumerable();
+            Assert.Equal(xs.Average(), await ys.AverageAsync(x => new ValueTask<<#=cs#>>(x)));
+        }
+
+#if !NO_DEEP_CANCELLATION
+        [Fact]
+        public async Task AverageAsync_AsyncSelectorWithCancellation_<#=t.Name#>_Empty()
+        {
+            var ys = new <#=cs#>[0].ToAsyncEnumerable();
+            await Assert.ThrowsAsync<InvalidOperationException>(() => ys.AverageAsync((x, ct) => new ValueTask<<#=cs#>>(x), CancellationToken.None));
+        }
+
+        [Fact]
+        public async Task AverageAsync_AsyncSelectorWithCancellation_<#=t.Name#>_Many()
+        {
+            var xs = new <#=cs#>[] { 2, 3, 5, 7, 11, 13, 17, 19 };
+            var ys = xs.ToAsyncEnumerable();
+            Assert.Equal(xs.Average(), await ys.AverageAsync((x, ct) => new ValueTask<<#=cs#>>(x), CancellationToken.None));
+        }
+#endif
+
+        [Fact]
+        public async Task AverageAsync_<#=t.Name#>_Nullable_Empty()
+        {
+            var ys = new <#=cs#>?[0].ToAsyncEnumerable();
+            Assert.Null(await ys.AverageAsync());
+        }
+
+        [Fact]
+        public async Task AverageAsync_<#=t.Name#>_Nullable_Many()
+        {
+            var xs = new <#=cs#>?[] { 2, 3, 5, 7, 11, 13, 17, 19 };
+            var ys = xs.ToAsyncEnumerable();
+            Assert.Equal(xs.Average(), await ys.AverageAsync());
+        }
+
+        [Fact]
+        public async Task AverageAsync_Selector_<#=t.Name#>_Nullable_Empty()
+        {
+            var ys = new <#=cs#>?[0].ToAsyncEnumerable();
+            Assert.Null(await ys.AverageAsync(x => x));
+        }
+
+        [Fact]
+        public async Task AverageAsync_Selector_<#=t.Name#>_Nullable_Many()
+        {
+            var xs = new <#=cs#>?[] { 2, 3, 5, 7, 11, 13, 17, 19 };
+            var ys = xs.ToAsyncEnumerable();
+            Assert.Equal(xs.Average(), await ys.AverageAsync(x => x));
+        }
+
+        [Fact]
+        public async Task AverageAsync_AsyncSelector_<#=t.Name#>_Nullable_Empty()
+        {
+            var ys = new <#=cs#>?[0].ToAsyncEnumerable();
+            Assert.Null(await ys.AverageAsync(x => new ValueTask<<#=cs#>?>(x)));
+        }
+
+        [Fact]
+        public async Task AverageAsync_AsyncSelector_<#=t.Name#>_Nullable_Many()
+        {
+            var xs = new <#=cs#>?[] { 2, 3, 5, 7, 11, 13, 17, 19 };
+            var ys = xs.ToAsyncEnumerable();
+            Assert.Equal(xs.Average(), await ys.AverageAsync(x => new ValueTask<<#=cs#>?>(x)));
+        }
+
+#if !NO_DEEP_CANCELLATION
+        [Fact]
+        public async Task AverageAsync_AsyncSelectorWithCancellation_<#=t.Name#>_Nullable_Empty()
+        {
+            var ys = new <#=cs#>?[0].ToAsyncEnumerable();
+            Assert.Null(await ys.AverageAsync((x, ct) => new ValueTask<<#=cs#>?>(x), CancellationToken.None));
+        }
+
+        [Fact]
+        public async Task AverageAsync_AsyncSelectorWithCancellation_<#=t.Name#>_Nullable_Many()
+        {
+            var xs = new <#=cs#>?[] { 2, 3, 5, 7, 11, 13, 17, 19 };
+            var ys = xs.ToAsyncEnumerable();
+            Assert.Equal(xs.Average(), await ys.AverageAsync((x, ct) => new ValueTask<<#=cs#>?>(x), CancellationToken.None));
+        }
+#endif
+
+<#
+}
+#>
+    }
+}