MinAsync and MaxAsync code coverage.

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

@@ -203,101 +203,131 @@ namespace Tests
         [Fact]
         public async Task MaxAsync_Int32()
         {
-            var xs = new[] { 2, 7, 3 };
+            var xs = new[] { 2, 1, 3 };
             var ys = xs.ToAsyncEnumerable();
             Assert.Equal(xs.Max(), await ys.MaxAsync());
             Assert.Equal(xs.Max(), await ys.MaxAsync(x => x));
             Assert.Equal(xs.Max(), await ys.MaxAsync(x => new ValueTask<int>(x)));
+#if !NO_DEEP_CANCELLATION
+            Assert.Equal(xs.Max(), await ys.MaxAsync((x, ct) => new ValueTask<int>(x)));
+#endif
         }
 
         [Fact]
         public async Task MaxAsync_Nullable_Int32()
         {
-            var xs = new[] { 2, default(int?), 3, 1 };
+            var xs = new[] { 2, default(int?), 3 };
             var ys = xs.ToAsyncEnumerable();
             Assert.Equal(xs.Max(), await ys.MaxAsync());
             Assert.Equal(xs.Max(), await ys.MaxAsync(x => x));
             Assert.Equal(xs.Max(), await ys.MaxAsync(x => new ValueTask<int?>(x)));
+#if !NO_DEEP_CANCELLATION
+            Assert.Equal(xs.Max(), await ys.MaxAsync((x, ct) => new ValueTask<int?>(x)));
+#endif
         }
 
         [Fact]
         public async Task MaxAsync_Int64()
         {
-            var xs = new[] { 2L, 7L, 3L };
+            var xs = new[] { 2L, 1L, 3L };
             var ys = xs.ToAsyncEnumerable();
             Assert.Equal(xs.Max(), await ys.MaxAsync());
             Assert.Equal(xs.Max(), await ys.MaxAsync(x => x));
             Assert.Equal(xs.Max(), await ys.MaxAsync(x => new ValueTask<long>(x)));
+#if !NO_DEEP_CANCELLATION
+            Assert.Equal(xs.Max(), await ys.MaxAsync((x, ct) => new ValueTask<long>(x)));
+#endif
         }
 
         [Fact]
         public async Task MaxAsync_Nullable_Int64()
         {
-            var xs = new[] { 2L, default(long?), 3L, 1L };
+            var xs = new[] { 2L, default(long?), 3L };
             var ys = xs.ToAsyncEnumerable();
             Assert.Equal(xs.Max(), await ys.MaxAsync());
             Assert.Equal(xs.Max(), await ys.MaxAsync(x => x));
             Assert.Equal(xs.Max(), await ys.MaxAsync(x => new ValueTask<long?>(x)));
+#if !NO_DEEP_CANCELLATION
+            Assert.Equal(xs.Max(), await ys.MaxAsync((x, ct) => new ValueTask<long?>(x)));
+#endif
         }
 
         [Fact]
         public async Task MaxAsync_Double()
         {
-            var xs = new[] { 2.0, 7.0, 3.0 };
+            var xs = new[] { 2.0, 1.0, 3.0 };
             var ys = xs.ToAsyncEnumerable();
             Assert.Equal(xs.Max(), await ys.MaxAsync());
             Assert.Equal(xs.Max(), await ys.MaxAsync(x => x));
             Assert.Equal(xs.Max(), await ys.MaxAsync(x => new ValueTask<double>(x)));
+#if !NO_DEEP_CANCELLATION
+            Assert.Equal(xs.Max(), await ys.MaxAsync((x, ct) => new ValueTask<double>(x)));
+#endif
         }
 
         [Fact]
         public async Task MaxAsync_Nullable_Double()
         {
-            var xs = new[] { 2.0, default(double?), 3.0, 1.0 };
+            var xs = new[] { 2.0, default(double?), 3.0 };
             var ys = xs.ToAsyncEnumerable();
             Assert.Equal(xs.Max(), await ys.MaxAsync());
             Assert.Equal(xs.Max(), await ys.MaxAsync(x => x));
             Assert.Equal(xs.Max(), await ys.MaxAsync(x => new ValueTask<double?>(x)));
+#if !NO_DEEP_CANCELLATION
+            Assert.Equal(xs.Max(), await ys.MaxAsync((x, ct) => new ValueTask<double?>(x)));
+#endif
         }
 
         [Fact]
         public async Task MaxAsync_Single()
         {
-            var xs = new[] { 2.0f, 7.0f, 3.0f };
+            var xs = new[] { 2.0f, 1.0f, 3.0f };
             var ys = xs.ToAsyncEnumerable();
             Assert.Equal(xs.Max(), await ys.MaxAsync());
             Assert.Equal(xs.Max(), await ys.MaxAsync(x => x));
             Assert.Equal(xs.Max(), await ys.MaxAsync(x => new ValueTask<float>(x)));
+#if !NO_DEEP_CANCELLATION
+            Assert.Equal(xs.Max(), await ys.MaxAsync((x, ct) => new ValueTask<float>(x)));
+#endif
         }
 
         [Fact]
         public async Task MaxAsync_Nullable_Single()
         {
-            var xs = new[] { 2.0f, default(float?), 3.0f, 1.0f };
+            var xs = new[] { 2.0f, default(float?), 3.0f };
             var ys = xs.ToAsyncEnumerable();
             Assert.Equal(xs.Max(), await ys.MaxAsync());
             Assert.Equal(xs.Max(), await ys.MaxAsync(x => x));
             Assert.Equal(xs.Max(), await ys.MaxAsync(x => new ValueTask<float?>(x)));
+#if !NO_DEEP_CANCELLATION
+            Assert.Equal(xs.Max(), await ys.MaxAsync((x, ct) => new ValueTask<float?>(x)));
+#endif
         }
 
         [Fact]
         public async Task MaxAsync_Decimal()
         {
-            var xs = new[] { 2.0m, 7.0m, 3.0m };
+            var xs = new[] { 2.0m, 1.0m, 3.0m };
             var ys = xs.ToAsyncEnumerable();
             Assert.Equal(xs.Max(), await ys.MaxAsync());
             Assert.Equal(xs.Max(), await ys.MaxAsync(x => x));
             Assert.Equal(xs.Max(), await ys.MaxAsync(x => new ValueTask<decimal>(x)));
+#if !NO_DEEP_CANCELLATION
+            Assert.Equal(xs.Max(), await ys.MaxAsync((x, ct) => new ValueTask<decimal>(x)));
+#endif
         }
 
         [Fact]
         public async Task MaxAsync_Nullable_Decimal()
         {
-            var xs = new[] { 2.0m, default(decimal?), 3.0m, 1.0m };
+            var xs = new[] { 2.0m, default(decimal?), 3.0m };
             var ys = xs.ToAsyncEnumerable();
             Assert.Equal(xs.Max(), await ys.MaxAsync());
             Assert.Equal(xs.Max(), await ys.MaxAsync(x => x));
             Assert.Equal(xs.Max(), await ys.MaxAsync(x => new ValueTask<decimal?>(x)));
+#if !NO_DEEP_CANCELLATION
+            Assert.Equal(xs.Max(), await ys.MaxAsync((x, ct) => new ValueTask<decimal?>(x)));
+#endif
         }
 
         [Fact]
@@ -308,6 +338,9 @@ namespace Tests
             Assert.Equal(xs.Max(), await ys.MaxAsync());
             Assert.Equal(xs.Max(), await ys.MaxAsync(x => x));
             Assert.Equal(xs.Max(), await ys.MaxAsync(x => new ValueTask<DateTime>(x)));
+#if !NO_DEEP_CANCELLATION
+            Assert.Equal(xs.Max(), await ys.MaxAsync((x, ct) => new ValueTask<DateTime>(x)));
+#endif
         }
 
         [Fact]
@@ -318,6 +351,58 @@ namespace Tests
             Assert.Equal(xs.Max(), await ys.MaxAsync());
             Assert.Equal(xs.Max(), await ys.MaxAsync(x => x));
             Assert.Equal(xs.Max(), await ys.MaxAsync(x => new ValueTask<string>(x)));
+#if !NO_DEEP_CANCELLATION
+            Assert.Equal(xs.Max(), await ys.MaxAsync((x, ct) => new ValueTask<string>(x)));
+#endif
+        }
+
+        [Fact]
+        public async Task MaxAsync_TSource_Value_Empty()
+        {
+            var xs = new DateTimeOffset[0].ToAsyncEnumerable();
+            await AssertThrowsAsync<InvalidOperationException>(xs.MaxAsync().AsTask());
+            await AssertThrowsAsync<InvalidOperationException>(xs.MaxAsync(x => x).AsTask());
+            await AssertThrowsAsync<InvalidOperationException>(xs.MaxAsync(x => new ValueTask<DateTimeOffset>(x)).AsTask());
+#if !NO_DEEP_CANCELLATION
+            await AssertThrowsAsync<InvalidOperationException>(xs.MaxAsync((x, ct) => new ValueTask<DateTimeOffset>(x)).AsTask());
+#endif
+        }
+
+        [Fact]
+        public async Task MaxAsync_TSource_NonValue_Empty()
+        {
+            var xs = new string[0].ToAsyncEnumerable();
+            Assert.Null(await xs.MaxAsync());
+            Assert.Null(await xs.MaxAsync(x => x));
+            Assert.Null(await xs.MaxAsync(x => new ValueTask<string>(x)));
+#if !NO_DEEP_CANCELLATION
+            Assert.Null(await xs.MaxAsync((x, ct) => new ValueTask<string>(x)));
+#endif
+        }
+
+        [Fact]
+        public async Task MaxAsync_TSource_NullableValue_Empty()
+        {
+            var xs = new DateTimeOffset?[0].ToAsyncEnumerable();
+            Assert.Null(await xs.MaxAsync());
+            Assert.Null(await xs.MaxAsync(x => x));
+            Assert.Null(await xs.MaxAsync(x => new ValueTask<DateTimeOffset?>(x)));
+#if !NO_DEEP_CANCELLATION
+            Assert.Null(await xs.MaxAsync((x, ct) => new ValueTask<DateTimeOffset?>(x)));
+#endif
+        }
+
+        [Fact]
+        public async Task MaxAsync_TSource_NullableValue_SomeNull()
+        {
+            var xs = new DateTimeOffset?[] { null, null, DateTime.Now.AddDays(1), DateTime.Now.Subtract(TimeSpan.FromDays(1)), null, DateTime.Now.AddDays(2), DateTime.Now, null };
+            var ys = xs.ToAsyncEnumerable();
+            Assert.Equal(xs.Max(), await ys.MaxAsync());
+            Assert.Equal(xs.Max(), await ys.MaxAsync(x => x));
+            Assert.Equal(xs.Max(), await ys.MaxAsync(x => new ValueTask<DateTimeOffset?>(x)));
+#if !NO_DEEP_CANCELLATION
+            Assert.Equal(xs.Max(), await ys.MaxAsync((x, ct) => new ValueTask<DateTimeOffset?>(x)));
+#endif
         }
     }
 }

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

@@ -208,6 +208,9 @@ namespace Tests
             Assert.Equal(xs.Min(), await ys.MinAsync());
             Assert.Equal(xs.Min(), await ys.MinAsync(x => x));
             Assert.Equal(xs.Min(), await ys.MinAsync(x => new ValueTask<int>(x)));
+#if !NO_DEEP_CANCELLATION
+            Assert.Equal(xs.Min(), await ys.MinAsync((x, ct) => new ValueTask<int>(x)));
+#endif
         }
 
         [Fact]
@@ -218,6 +221,9 @@ namespace Tests
             Assert.Equal(xs.Min(), await ys.MinAsync());
             Assert.Equal(xs.Min(), await ys.MinAsync(x => x));
             Assert.Equal(xs.Min(), await ys.MinAsync(x => new ValueTask<int?>(x)));
+#if !NO_DEEP_CANCELLATION
+            Assert.Equal(xs.Min(), await ys.MinAsync((x, ct) => new ValueTask<int?>(x)));
+#endif
         }
 
         [Fact]
@@ -228,6 +234,9 @@ namespace Tests
             Assert.Equal(xs.Min(), await ys.MinAsync());
             Assert.Equal(xs.Min(), await ys.MinAsync(x => x));
             Assert.Equal(xs.Min(), await ys.MinAsync(x => new ValueTask<long>(x)));
+#if !NO_DEEP_CANCELLATION
+            Assert.Equal(xs.Min(), await ys.MinAsync((x, ct) => new ValueTask<long>(x)));
+#endif
         }
 
         [Fact]
@@ -238,6 +247,9 @@ namespace Tests
             Assert.Equal(xs.Min(), await ys.MinAsync());
             Assert.Equal(xs.Min(), await ys.MinAsync(x => x));
             Assert.Equal(xs.Min(), await ys.MinAsync(x => new ValueTask<long?>(x)));
+#if !NO_DEEP_CANCELLATION
+            Assert.Equal(xs.Min(), await ys.MinAsync((x, ct) => new ValueTask<long?>(x)));
+#endif
         }
 
         [Fact]
@@ -248,6 +260,9 @@ namespace Tests
             Assert.Equal(xs.Min(), await ys.MinAsync());
             Assert.Equal(xs.Min(), await ys.MinAsync(x => x));
             Assert.Equal(xs.Min(), await ys.MinAsync(x => new ValueTask<double>(x)));
+#if !NO_DEEP_CANCELLATION
+            Assert.Equal(xs.Min(), await ys.MinAsync((x, ct) => new ValueTask<double>(x)));
+#endif
         }
 
         [Fact]
@@ -258,6 +273,9 @@ namespace Tests
             Assert.Equal(xs.Min(), await ys.MinAsync());
             Assert.Equal(xs.Min(), await ys.MinAsync(x => x));
             Assert.Equal(xs.Min(), await ys.MinAsync(x => new ValueTask<double?>(x)));
+#if !NO_DEEP_CANCELLATION
+            Assert.Equal(xs.Min(), await ys.MinAsync((x, ct) => new ValueTask<double?>(x)));
+#endif
         }
 
         [Fact]
@@ -268,6 +286,9 @@ namespace Tests
             Assert.Equal(xs.Min(), await ys.MinAsync());
             Assert.Equal(xs.Min(), await ys.MinAsync(x => x));
             Assert.Equal(xs.Min(), await ys.MinAsync(x => new ValueTask<float>(x)));
+#if !NO_DEEP_CANCELLATION
+            Assert.Equal(xs.Min(), await ys.MinAsync((x, ct) => new ValueTask<float>(x)));
+#endif
         }
 
         [Fact]
@@ -278,6 +299,9 @@ namespace Tests
             Assert.Equal(xs.Min(), await ys.MinAsync());
             Assert.Equal(xs.Min(), await ys.MinAsync(x => x));
             Assert.Equal(xs.Min(), await ys.MinAsync(x => new ValueTask<float?>(x)));
+#if !NO_DEEP_CANCELLATION
+            Assert.Equal(xs.Min(), await ys.MinAsync((x, ct) => new ValueTask<float?>(x)));
+#endif
         }
 
         [Fact]
@@ -288,6 +312,9 @@ namespace Tests
             Assert.Equal(xs.Min(), await ys.MinAsync());
             Assert.Equal(xs.Min(), await ys.MinAsync(x => x));
             Assert.Equal(xs.Min(), await ys.MinAsync(x => new ValueTask<decimal>(x)));
+#if !NO_DEEP_CANCELLATION
+            Assert.Equal(xs.Min(), await ys.MinAsync((x, ct) => new ValueTask<decimal>(x)));
+#endif
         }
 
         [Fact]
@@ -298,6 +325,9 @@ namespace Tests
             Assert.Equal(xs.Min(), await ys.MinAsync());
             Assert.Equal(xs.Min(), await ys.MinAsync(x => x));
             Assert.Equal(xs.Min(), await ys.MinAsync(x => new ValueTask<decimal?>(x)));
+#if !NO_DEEP_CANCELLATION
+            Assert.Equal(xs.Min(), await ys.MinAsync((x, ct) => new ValueTask<decimal?>(x)));
+#endif
         }
 
         [Fact]
@@ -308,6 +338,9 @@ namespace Tests
             Assert.Equal(xs.Min(), await ys.MinAsync());
             Assert.Equal(xs.Min(), await ys.MinAsync(x => x));
             Assert.Equal(xs.Min(), await ys.MinAsync(x => new ValueTask<DateTime>(x)));
+#if !NO_DEEP_CANCELLATION
+            Assert.Equal(xs.Min(), await ys.MinAsync((x, ct) => new ValueTask<DateTime>(x)));
+#endif
         }
 
         [Fact]
@@ -318,6 +351,58 @@ namespace Tests
             Assert.Equal(xs.Min(), await ys.MinAsync());
             Assert.Equal(xs.Min(), await ys.MinAsync(x => x));
             Assert.Equal(xs.Min(), await ys.MinAsync(x => new ValueTask<string>(x)));
+#if !NO_DEEP_CANCELLATION
+            Assert.Equal(xs.Min(), await ys.MinAsync((x, ct) => new ValueTask<string>(x)));
+#endif
+        }
+
+        [Fact]
+        public async Task MinAsync_TSource_Value_Empty()
+        {
+            var xs = new DateTimeOffset[0].ToAsyncEnumerable();
+            await AssertThrowsAsync<InvalidOperationException>(xs.MinAsync().AsTask());
+            await AssertThrowsAsync<InvalidOperationException>(xs.MinAsync(x => x).AsTask());
+            await AssertThrowsAsync<InvalidOperationException>(xs.MinAsync(x => new ValueTask<DateTimeOffset>(x)).AsTask());
+#if !NO_DEEP_CANCELLATION
+            await AssertThrowsAsync<InvalidOperationException>(xs.MinAsync((x, ct) => new ValueTask<DateTimeOffset>(x)).AsTask());
+#endif
+        }
+
+        [Fact]
+        public async Task MinAsync_TSource_NonValue_Empty()
+        {
+            var xs = new string[0].ToAsyncEnumerable();
+            Assert.Null(await xs.MinAsync());
+            Assert.Null(await xs.MinAsync(x => x));
+            Assert.Null(await xs.MinAsync(x => new ValueTask<string>(x)));
+#if !NO_DEEP_CANCELLATION
+            Assert.Null(await xs.MinAsync((x, ct) => new ValueTask<string>(x)));
+#endif
+        }
+
+        [Fact]
+        public async Task MinAsync_TSource_NullableValue_Empty()
+        {
+            var xs = new DateTimeOffset?[0].ToAsyncEnumerable();
+            Assert.Null(await xs.MinAsync());
+            Assert.Null(await xs.MinAsync(x => x));
+            Assert.Null(await xs.MinAsync(x => new ValueTask<DateTimeOffset?>(x)));
+#if !NO_DEEP_CANCELLATION
+            Assert.Null(await xs.MinAsync((x, ct) => new ValueTask<DateTimeOffset?>(x)));
+#endif
+        }
+
+        [Fact]
+        public async Task MinAsync_TSource_NullableValue_SomeNull()
+        {
+            var xs = new DateTimeOffset?[] { null, null, DateTime.Now.AddDays(1), DateTime.Now.Subtract(TimeSpan.FromDays(1)), null, DateTime.Now.AddDays(2), DateTime.Now, null };
+            var ys = xs.ToAsyncEnumerable();
+            Assert.Equal(xs.Min(), await ys.MinAsync());
+            Assert.Equal(xs.Min(), await ys.MinAsync(x => x));
+            Assert.Equal(xs.Min(), await ys.MinAsync(x => new ValueTask<DateTimeOffset?>(x)));
+#if !NO_DEEP_CANCELLATION
+            Assert.Equal(xs.Min(), await ys.MinAsync((x, ct) => new ValueTask<DateTimeOffset?>(x)));
+#endif
         }
     }
 }