CountAsync code coverage.

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

@@ -13,33 +13,45 @@ namespace Tests
     public class Count : AsyncEnumerableTests
     {
         [Fact]
-        public async Task Count_Null()
+        public async Task CountAsync_Simple_Null()
         {
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.CountAsync<int>(default).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.CountAsync<int>(default, x => true).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.CountAsync(Return42, default(Func<int, bool>)).AsTask());
-
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.CountAsync<int>(default, CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.CountAsync<int>(default, x => true, CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.CountAsync(Return42, default(Func<int, bool>), CancellationToken.None).AsTask());
         }
 
         [Fact]
-        public async Task Count1()
+        public async Task CountAsync_Simple()
         {
             Assert.Equal(0, await new int[0].ToAsyncEnumerable().CountAsync());
             Assert.Equal(3, await new[] { 1, 2, 3 }.ToAsyncEnumerable().CountAsync());
         }
 
         [Fact]
-        public async Task Count2()
+        public async Task CountAsync_Simple_Throws_Source()
+        {
+            var ex = new Exception("Bang!");
+            await AssertThrowsAsync(Throw<int>(ex).CountAsync(), ex);
+        }
+
+        [Fact]
+        public async Task CountAsync_Predicate_Null()
+        {
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.CountAsync<int>(default, x => true).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.CountAsync(Return42, default(Func<int, bool>)).AsTask());
+
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.CountAsync<int>(default, x => true, CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.CountAsync(Return42, default(Func<int, bool>), CancellationToken.None).AsTask());
+        }
+
+        [Fact]
+        public async Task CountAsync_Predicate()
         {
             Assert.Equal(0, await new int[0].ToAsyncEnumerable().CountAsync(x => x < 3));
             Assert.Equal(2, await new[] { 1, 2, 3 }.ToAsyncEnumerable().CountAsync(x => x < 3));
         }
 
         [Fact]
-        public async Task Count3Async()
+        public async Task CountAsync_Predicate_Throws_Predicate()
         {
             var ex = new Exception("Bang!");
             var ys = new[] { 1, 2, 3 }.ToAsyncEnumerable().CountAsync(new Func<int, bool>(x => { throw ex; }));
@@ -47,17 +59,76 @@ namespace Tests
         }
 
         [Fact]
-        public async Task Count4Async()
+        public async Task CountAsync_Predicate_Throws_Source()
         {
             var ex = new Exception("Bang!");
-            await AssertThrowsAsync(Throw<int>(ex).CountAsync(), ex);
+            await AssertThrowsAsync(Throw<int>(ex).CountAsync(x => x < 3), ex);
+        }
+
+        [Fact]
+        public async Task CountAsync_AsyncPredicate_Null()
+        {
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.CountAsync<int>(default, x => new ValueTask<bool>(true)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.CountAsync(Return42, default(Func<int, ValueTask<bool>>)).AsTask());
+
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.CountAsync<int>(default, x => new ValueTask<bool>(true), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.CountAsync(Return42, default(Func<int, ValueTask<bool>>), CancellationToken.None).AsTask());
+        }
+
+        [Fact]
+        public async Task CountAsync_AsyncPredicate()
+        {
+            Assert.Equal(0, await new int[0].ToAsyncEnumerable().CountAsync(x => new ValueTask<bool>(x < 3)));
+            Assert.Equal(2, await new[] { 1, 2, 3 }.ToAsyncEnumerable().CountAsync(x => new ValueTask<bool>(x < 3)));
         }
 
         [Fact]
-        public async Task Count5Async()
+        public async Task CountAsync_AsyncPredicate_Throws_Predicate()
         {
             var ex = new Exception("Bang!");
-            await AssertThrowsAsync(Throw<int>(ex).CountAsync(x => x < 3), ex);
+            var ys = new[] { 1, 2, 3 }.ToAsyncEnumerable().CountAsync(new Func<int, ValueTask<bool>>(x => { throw ex; }));
+            await AssertThrowsAsync(ys, ex);
+        }
+
+        [Fact]
+        public async Task CountAsync_AsyncPredicate_Throws_Source()
+        {
+            var ex = new Exception("Bang!");
+            await AssertThrowsAsync(Throw<int>(ex).CountAsync(x => new ValueTask<bool>(x < 3)), ex);
+        }
+
+#if !NO_DEEP_CANCELLATION
+        [Fact]
+        public async Task CountAsync_AsyncPredicateCancel_Null()
+        {
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.CountAsync<int>(default, (x, ct) => new ValueTask<bool>(true)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.CountAsync(Return42, default(Func<int, CancellationToken, ValueTask<bool>>)).AsTask());
+
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.CountAsync<int>(default, (x, ct) => new ValueTask<bool>(true), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.CountAsync(Return42, default(Func<int, CancellationToken, ValueTask<bool>>), CancellationToken.None).AsTask());
+        }
+
+        [Fact]
+        public async Task CountAsync_AsyncPredicateCancel()
+        {
+            Assert.Equal(0, await new int[0].ToAsyncEnumerable().CountAsync((x, ct) => new ValueTask<bool>(x < 3)));
+            Assert.Equal(2, await new[] { 1, 2, 3 }.ToAsyncEnumerable().CountAsync((x, ct) => new ValueTask<bool>(x < 3)));
+        }
+
+        [Fact]
+        public async Task CountAsync_AsyncPredicateCancel_Throws_Predicate()
+        {
+            var ex = new Exception("Bang!");
+            var ys = new[] { 1, 2, 3 }.ToAsyncEnumerable().CountAsync(new Func<int, CancellationToken, ValueTask<bool>>((x, ct) => { throw ex; }));
+            await AssertThrowsAsync(ys, ex);
+        }
+
+        [Fact]
+        public async Task CountAsync_AsyncPredicateCancel_Throws_Source()
+        {
+            var ex = new Exception("Bang!");
+            await AssertThrowsAsync(Throw<int>(ex).CountAsync((x, ct) => new ValueTask<bool>(x < 3)), ex);
         }
+#endif
     }
 }