AllAsync code coverage.

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

@@ -13,37 +13,31 @@ namespace Tests
     public class All : AsyncEnumerableTests
     {
         [Fact]
-        public async Task All_Null()
+        public async Task AllAsync_Sync_Null()
         {
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AllAsync<int>(default, x => true).AsTask());
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AllAsync(Return42, default(Func<int, bool>)).AsTask());
 
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AllAsync<int>(default, x => true, CancellationToken.None).AsTask());
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AllAsync(Return42, default(Func<int, bool>), CancellationToken.None).AsTask());
-
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AllAsync<int>(default, x => new ValueTask<bool>(true)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AllAsync(Return42, default(Func<int, ValueTask<bool>>)).AsTask());
-
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AllAsync<int>(default, x => new ValueTask<bool>(true), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AllAsync(Return42, default(Func<int, ValueTask<bool>>), CancellationToken.None).AsTask());
         }
 
         [Fact]
-        public async Task All1Async()
+        public async Task AllAsync_Sync_Simple_False()
         {
             var res = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().AllAsync(x => x % 2 == 0);
             Assert.False(await res);
         }
 
         [Fact]
-        public async Task All2Async()
+        public async Task AllAsync_Sync_Simple_True()
         {
             var res = new[] { 2, 8, 4 }.ToAsyncEnumerable().AllAsync(x => x % 2 == 0);
             Assert.True(await res);
         }
 
         [Fact]
-        public async Task All3Async()
+        public async Task AllAsync_Sync_Throw_Source()
         {
             var ex = new Exception("Bang!");
             var res = Throw<int>(ex).AllAsync(x => x % 2 == 0);
@@ -51,7 +45,7 @@ namespace Tests
         }
 
         [Fact]
-        public async Task All4Async()
+        public async Task AllAsync_Sync_Throw_Selector()
         {
             var ex = new Exception("Bang!");
             var res = new[] { 2, 8, 4 }.ToAsyncEnumerable().AllAsync(new Func<int, bool>(x => { throw ex; }));
@@ -59,21 +53,31 @@ namespace Tests
         }
 
         [Fact]
-        public async Task All5Async()
+        public async Task AllAsync_Async_Null()
+        {
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AllAsync<int>(default, x => new ValueTask<bool>(true)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AllAsync(Return42, default(Func<int, ValueTask<bool>>)).AsTask());
+
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AllAsync<int>(default, x => new ValueTask<bool>(true), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AllAsync(Return42, default(Func<int, ValueTask<bool>>), CancellationToken.None).AsTask());
+        }
+
+        [Fact]
+        public async Task AllAsync_Async_Simple_False()
         {
             var res = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().AllAsync(x => new ValueTask<bool>(x % 2 == 0));
             Assert.False(await res);
         }
 
         [Fact]
-        public async Task All6Async()
+        public async Task AllAsync_Async_Simple_True()
         {
             var res = new[] { 2, 8, 4 }.ToAsyncEnumerable().AllAsync(x => new ValueTask<bool>(x % 2 == 0));
             Assert.True(await res);
         }
 
         [Fact]
-        public async Task All7Async()
+        public async Task AllAsync_Async_Throw_Source()
         {
             var ex = new Exception("Bang!");
             var res = Throw<int>(ex).AllAsync(x => new ValueTask<bool>(x % 2 == 0));
@@ -81,11 +85,53 @@ namespace Tests
         }
 
         [Fact]
-        public async Task All8Async()
+        public async Task AllAsync_Async_Throw_Selector()
         {
             var ex = new Exception("Bang!");
             var res = new[] { 2, 8, 4 }.ToAsyncEnumerable().AllAsync(new Func<int, ValueTask<bool>>(x => { throw ex; }));
             await AssertThrowsAsync(res, ex);
         }
+
+#if !NO_DEEP_CANCELLATION
+        [Fact]
+        public async Task AllAsync_AsyncCancel_Null()
+        {
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AllAsync<int>(default, (x, ct) => new ValueTask<bool>(true)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AllAsync(Return42, default(Func<int, CancellationToken, ValueTask<bool>>)).AsTask());
+
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AllAsync<int>(default, (x, ct) => new ValueTask<bool>(true), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AllAsync(Return42, default(Func<int, CancellationToken, ValueTask<bool>>), CancellationToken.None).AsTask());
+        }
+
+        [Fact]
+        public async Task AllAsync_AsyncCancel_Simple_False()
+        {
+            var res = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().AllAsync((x, ct) => new ValueTask<bool>(x % 2 == 0));
+            Assert.False(await res);
+        }
+
+        [Fact]
+        public async Task AllAsync_AsyncCancel_Simple_True()
+        {
+            var res = new[] { 2, 8, 4 }.ToAsyncEnumerable().AllAsync((x, ct) => new ValueTask<bool>(x % 2 == 0));
+            Assert.True(await res);
+        }
+
+        [Fact]
+        public async Task AllAsync_AsyncCancel_Throw_Source()
+        {
+            var ex = new Exception("Bang!");
+            var res = Throw<int>(ex).AllAsync((x, ct) => new ValueTask<bool>(x % 2 == 0));
+            await AssertThrowsAsync(res, ex);
+        }
+
+        [Fact]
+        public async Task AllAsync_AsyncCancel_Throw_Selector()
+        {
+            var ex = new Exception("Bang!");
+            var res = new[] { 2, 8, 4 }.ToAsyncEnumerable().AllAsync(new Func<int, CancellationToken, ValueTask<bool>>((x, ct) => { throw ex; }));
+            await AssertThrowsAsync(res, ex);
+        }
+#endif
     }
 }