Switch to async variants of NoNext and HasNext.

Ix.NET/Source/System.Interactive.Async.Tests/System/Linq/AsyncEnumerableExTests.cs

@@ -41,14 +41,14 @@ namespace Tests
             }
         }
 
-        public void NoNext<T>(IAsyncEnumerator<T> e)
+        protected async Task NoNextAsync<T>(IAsyncEnumerator<T> e)
         {
-            Assert.False(e.MoveNextAsync().Result);
+            Assert.False(await e.MoveNextAsync());
         }
 
-        public void HasNext<T>(IAsyncEnumerator<T> e, T value)
+        protected async Task HasNextAsync<T>(IAsyncEnumerator<T> e, T value)
         {
-            Assert.True(e.MoveNextAsync().Result);
+            Assert.True(await e.MoveNextAsync());
             Assert.Equal(value, e.Current);
         }
 

Ix.NET/Source/System.Interactive.Async.Tests/System/Linq/Operators/Catch.cs

@@ -25,7 +25,7 @@ namespace Tests
         }
 
         [Fact]
-        public void Catch1()
+        public async Task Catch1Async()
         {
             var err = false;
             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
@@ -34,16 +34,16 @@ namespace Tests
             var res = xs.Catch<int, Exception>(ex_ => { err = true; return ys; });
 
             var e = res.GetAsyncEnumerator();
-            HasNext(e, 1);
-            HasNext(e, 2);
-            HasNext(e, 3);
-            NoNext(e);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 3);
+            await NoNextAsync(e);
 
             Assert.False(err);
         }
 
         [Fact]
-        public void Catch2()
+        public async Task Catch2Async()
         {
             var ex = new InvalidOperationException("Bang!");
 
@@ -54,23 +54,23 @@ namespace Tests
             var res = xs.Catch<int, InvalidOperationException>(ex_ => { err = true; return ys; });
 
             var e = res.GetAsyncEnumerator();
-            HasNext(e, 1);
-            HasNext(e, 2);
-            HasNext(e, 3);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 3);
 
             Assert.False(err);
 
-            HasNext(e, 4);
+            await HasNextAsync(e, 4);
 
             Assert.True(err);
 
-            HasNext(e, 5);
-            HasNext(e, 6);
-            NoNext(e);
+            await HasNextAsync(e, 5);
+            await HasNextAsync(e, 6);
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void Catch3()
+        public async Task Catch3Async()
         {
             var ex = new InvalidOperationException("Bang!");
 
@@ -81,23 +81,23 @@ namespace Tests
             var res = xs.Catch<int, Exception>(ex_ => { err = true; return ys; });
 
             var e = res.GetAsyncEnumerator();
-            HasNext(e, 1);
-            HasNext(e, 2);
-            HasNext(e, 3);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 3);
 
             Assert.False(err);
 
-            HasNext(e, 4);
+            await HasNextAsync(e, 4);
 
             Assert.True(err);
 
-            HasNext(e, 5);
-            HasNext(e, 6);
-            NoNext(e);
+            await HasNextAsync(e, 5);
+            await HasNextAsync(e, 6);
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void Catch4()
+        public async Task Catch4Async()
         {
             var ex = new DivideByZeroException();
 
@@ -108,9 +108,9 @@ namespace Tests
             var res = xs.Catch<int, InvalidOperationException>(ex_ => { err = true; return ys; });
 
             var e = res.GetAsyncEnumerator();
-            HasNext(e, 1);
-            HasNext(e, 2);
-            HasNext(e, 3);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 3);
 
             AssertThrows(() => e.MoveNextAsync().Wait(WaitTimeoutMs), SingleInnerExceptionMatches(ex));
 
@@ -118,7 +118,7 @@ namespace Tests
         }
 
         [Fact]
-        public void Catch5()
+        public async Task Catch5Async()
         {
             var ex = new InvalidOperationException("Bang!");
             var ex2 = new Exception("Oops!");
@@ -129,15 +129,15 @@ namespace Tests
             var res = xs.Catch<int, InvalidOperationException>(ex_ => { if (ex_.Message == "Bang!") throw ex2; return ys; });
 
             var e = res.GetAsyncEnumerator();
-            HasNext(e, 1);
-            HasNext(e, 2);
-            HasNext(e, 3);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 3);
 
             AssertThrows(() => e.MoveNextAsync().Wait(WaitTimeoutMs), SingleInnerExceptionMatches(ex2));
         }
 
         [Fact]
-        public void Catch6()
+        public async Task Catch6Async()
         {
             var ex = new InvalidOperationException("Bang!");
 
@@ -147,24 +147,24 @@ namespace Tests
             var res = xs.Catch<int, InvalidOperationException>(ex_ => { err = true; return xs; });
 
             var e = res.GetAsyncEnumerator();
-            HasNext(e, 1);
-            HasNext(e, 2);
-            HasNext(e, 3);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 3);
 
             Assert.False(err);
 
-            HasNext(e, 1);
+            await HasNextAsync(e, 1);
 
             Assert.True(err);
 
-            HasNext(e, 2);
-            HasNext(e, 3);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 3);
 
             AssertThrows(() => e.MoveNextAsync().Wait(WaitTimeoutMs), SingleInnerExceptionMatches(ex));
         }
 
         [Fact]
-        public void Catch7()
+        public async Task Catch7Async()
         {
             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
             var ys = new[] { 4, 5, 6 }.ToAsyncEnumerable();
@@ -172,14 +172,14 @@ namespace Tests
             var res = AsyncEnumerableEx.Catch(xs, ys);
 
             var e = res.GetAsyncEnumerator();
-            HasNext(e, 1);
-            HasNext(e, 2);
-            HasNext(e, 3);
-            NoNext(e);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 3);
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void Catch8()
+        public async Task Catch8Async()
         {
             var ex = new InvalidOperationException("Bang!");
 
@@ -189,17 +189,17 @@ namespace Tests
             var res = AsyncEnumerableEx.Catch(xs, ys);
 
             var e = res.GetAsyncEnumerator();
-            HasNext(e, 1);
-            HasNext(e, 2);
-            HasNext(e, 3);
-            HasNext(e, 4);
-            HasNext(e, 5);
-            HasNext(e, 6);
-            NoNext(e);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 3);
+            await HasNextAsync(e, 4);
+            await HasNextAsync(e, 5);
+            await HasNextAsync(e, 6);
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void Catch9()
+        public async Task Catch9Async()
         {
             var ex = new InvalidOperationException("Bang!");
 
@@ -209,27 +209,27 @@ namespace Tests
             var res = AsyncEnumerableEx.Catch(new[] { xs, xs, ys, ys });
 
             var e = res.GetAsyncEnumerator();
-            HasNext(e, 1);
-            HasNext(e, 2);
-            HasNext(e, 3);
-            HasNext(e, 1);
-            HasNext(e, 2);
-            HasNext(e, 3);
-            HasNext(e, 4);
-            HasNext(e, 5);
-            HasNext(e, 6);
-            NoNext(e);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 3);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 3);
+            await HasNextAsync(e, 4);
+            await HasNextAsync(e, 5);
+            await HasNextAsync(e, 6);
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void Catch10()
+        public async Task Catch10Async()
         {
             var res = CatchXss().Catch();
 
             var e = res.GetAsyncEnumerator();
-            HasNext(e, 1);
-            HasNext(e, 2);
-            HasNext(e, 3);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 3);
 
             AssertThrows(() => e.MoveNextAsync().Wait(WaitTimeoutMs), (Exception ex_) => ((AggregateException)ex_).Flatten().InnerExceptions.Single().Message == "Bang!");
         }
@@ -241,7 +241,7 @@ namespace Tests
         }
 
         [Fact]
-        public void Catch11()
+        public async Task Catch11Async()
         {
             var ex = new InvalidOperationException("Bang!");
 
@@ -250,23 +250,23 @@ namespace Tests
             var res = AsyncEnumerableEx.Catch(new[] { xs, xs });
 
             var e = res.GetAsyncEnumerator();
-            HasNext(e, 1);
-            HasNext(e, 2);
-            HasNext(e, 3);
-            HasNext(e, 1);
-            HasNext(e, 2);
-            HasNext(e, 3);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 3);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 3);
 
             AssertThrows(() => e.MoveNextAsync().Wait(WaitTimeoutMs), SingleInnerExceptionMatches(ex));
         }
 
         [Fact]
-        public void Catch12()
+        public async Task Catch12Async()
         {
             var res = AsyncEnumerableEx.Catch(Enumerable.Empty<IAsyncEnumerable<int>>());
 
             var e = res.GetAsyncEnumerator();
-            NoNext(e);
+            await NoNextAsync(e);
         }
 
         [Fact]

Ix.NET/Source/System.Interactive.Async.Tests/System/Linq/Operators/Concat.cs

@@ -20,7 +20,7 @@ namespace Tests
         }
 
         [Fact]
-        public void Concat4()
+        public async Task Concat4Async()
         {
             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
             var ys = new[] { 4, 5 }.ToAsyncEnumerable();
@@ -29,19 +29,19 @@ namespace Tests
             var res = AsyncEnumerableEx.Concat(xs, ys, zs);
 
             var e = res.GetAsyncEnumerator();
-            HasNext(e, 1);
-            HasNext(e, 2);
-            HasNext(e, 3);
-            HasNext(e, 4);
-            HasNext(e, 5);
-            HasNext(e, 6);
-            HasNext(e, 7);
-            HasNext(e, 8);
-            NoNext(e);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 3);
+            await HasNextAsync(e, 4);
+            await HasNextAsync(e, 5);
+            await HasNextAsync(e, 6);
+            await HasNextAsync(e, 7);
+            await HasNextAsync(e, 8);
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void Concat5()
+        public async Task Concat5Async()
         {
             var ex = new Exception("Bang");
             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
@@ -51,25 +51,25 @@ namespace Tests
             var res = AsyncEnumerableEx.Concat(xs, ys, zs);
 
             var e = res.GetAsyncEnumerator();
-            HasNext(e, 1);
-            HasNext(e, 2);
-            HasNext(e, 3);
-            HasNext(e, 4);
-            HasNext(e, 5);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 3);
+            await HasNextAsync(e, 4);
+            await HasNextAsync(e, 5);
             AssertThrows(() => e.MoveNextAsync().Wait(WaitTimeoutMs), SingleInnerExceptionMatches(ex));
         }
 
         [Fact]
-        public void Concat6()
+        public async Task Concat6Async()
         {
             var res = AsyncEnumerableEx.Concat(ConcatXss());
 
             var e = res.GetAsyncEnumerator();
-            HasNext(e, 1);
-            HasNext(e, 2);
-            HasNext(e, 3);
-            HasNext(e, 4);
-            HasNext(e, 5);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 3);
+            await HasNextAsync(e, 4);
+            await HasNextAsync(e, 5);
             AssertThrows(() => e.MoveNextAsync().Wait(WaitTimeoutMs), (Exception ex_) => ((AggregateException)ex_).Flatten().InnerExceptions.Single().Message == "Bang!");
         }
 

Ix.NET/Source/System.Interactive.Async.Tests/System/Linq/Operators/Defer.cs

@@ -18,22 +18,22 @@ namespace Tests
         }
 
         [Fact]
-        public void Defer1()
+        public async System.Threading.Tasks.Task Defer1Async()
         {
             var x = 0;
             var xs = AsyncEnumerableEx.Defer<int>(() => new[] { x }.ToAsyncEnumerable());
 
             {
                 var e = xs.GetAsyncEnumerator();
-                HasNext(e, 0);
-                NoNext(e);
+                await HasNextAsync(e, 0);
+                await NoNextAsync(e);
             }
 
             {
                 x++;
                 var e = xs.GetAsyncEnumerator();
-                HasNext(e, 1);
-                NoNext(e);
+                await HasNextAsync(e, 1);
+                await NoNextAsync(e);
             }
         }
     }

Ix.NET/Source/System.Interactive.Async.Tests/System/Linq/Operators/Distinct.cs

@@ -25,15 +25,15 @@ namespace Tests
         }
 
         [Fact]
-        public void Distinct1()
+        public async Task Distinct1Async()
         {
             var xs = new[] { 1, 2, 3, 4, 5 }.ToAsyncEnumerable().Distinct(x => x / 2);
 
             var e = xs.GetAsyncEnumerator();
-            HasNext(e, 1);
-            HasNext(e, 2);
-            HasNext(e, 4);
-            NoNext(e);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 4);
+            await NoNextAsync(e);
         }
 
         [Fact]
@@ -71,13 +71,13 @@ namespace Tests
         }
 
         [Fact]
-        public void Distinct11()
+        public async Task Distinct11Async()
         {
             var xs = AsyncEnumerable.Empty<int>().Distinct(k => k);
 
             var e = xs.GetAsyncEnumerator();
 
-            NoNext(e);
+            await NoNextAsync(e);
         }
     }
 }

Ix.NET/Source/System.Interactive.Async.Tests/System/Linq/Operators/DistinctUntilChanged.cs

@@ -27,47 +27,47 @@ namespace Tests
         }
 
         [Fact]
-        public void DistinctUntilChanged1()
+        public async Task DistinctUntilChanged1Async()
         {
             var xs = new[] { 1, 2, 2, 3, 4, 4, 4, 4, 5, 6, 6, 7, 3, 2, 2, 1, 1 }.ToAsyncEnumerable().DistinctUntilChanged();
 
             var e = xs.GetAsyncEnumerator();
-            HasNext(e, 1);
-            HasNext(e, 2);
-            HasNext(e, 3);
-            HasNext(e, 4);
-            HasNext(e, 5);
-            HasNext(e, 6);
-            HasNext(e, 7);
-            HasNext(e, 3);
-            HasNext(e, 2);
-            HasNext(e, 1);
-            NoNext(e);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 3);
+            await HasNextAsync(e, 4);
+            await HasNextAsync(e, 5);
+            await HasNextAsync(e, 6);
+            await HasNextAsync(e, 7);
+            await HasNextAsync(e, 3);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 1);
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void DistinctUntilChanged2()
+        public async Task DistinctUntilChanged2Async()
         {
             var xs = new[] { 1, 2, 3, 4, 3, 5, 2 }.ToAsyncEnumerable().DistinctUntilChanged(x => (x + 1) / 2);
 
             var e = xs.GetAsyncEnumerator();
-            HasNext(e, 1);
-            HasNext(e, 3);
-            HasNext(e, 5);
-            HasNext(e, 2);
-            NoNext(e);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 3);
+            await HasNextAsync(e, 5);
+            await HasNextAsync(e, 2);
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void DistinctUntilChanged3()
+        public async Task DistinctUntilChanged3Async()
         {
             var ex = new Exception("Bang!");
             var xs = new[] { 1, 2, 3, 4, 3, 5, 2 }.ToAsyncEnumerable().DistinctUntilChanged(x => { if (x == 4) throw ex; return x; });
 
             var e = xs.GetAsyncEnumerator();
-            HasNext(e, 1);
-            HasNext(e, 2);
-            HasNext(e, 3);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 3);
             AssertThrows(() => e.MoveNextAsync().Wait(WaitTimeoutMs), SingleInnerExceptionMatches(ex));
         }
 

Ix.NET/Source/System.Interactive.Async.Tests/System/Linq/Operators/Do.cs

@@ -36,22 +36,22 @@ namespace Tests
         }
 
         [Fact]
-        public void Do1()
+        public async Task Do1Async()
         {
             var sum = 0;
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
             var ys = xs.Do(x => sum += x);
 
             var e = ys.GetAsyncEnumerator();
-            HasNext(e, 1);
+            await HasNextAsync(e, 1);
             Assert.Equal(1, sum);
-            HasNext(e, 2);
+            await HasNextAsync(e, 2);
             Assert.Equal(3, sum);
-            HasNext(e, 3);
+            await HasNextAsync(e, 3);
             Assert.Equal(6, sum);
-            HasNext(e, 4);
+            await HasNextAsync(e, 4);
             Assert.Equal(10, sum);
-            NoNext(e);
+            await NoNextAsync(e);
         }
 
         [Fact]
@@ -66,7 +66,7 @@ namespace Tests
         }
 
         [Fact]
-        public void Do3()
+        public async Task Do3Async()
         {
             var sum = 0;
             var fail = false;
@@ -75,22 +75,22 @@ namespace Tests
             var ys = xs.Do(x => sum += x, ex => { fail = true; }, () => { done = true; });
 
             var e = ys.GetAsyncEnumerator();
-            HasNext(e, 1);
+            await HasNextAsync(e, 1);
             Assert.Equal(1, sum);
-            HasNext(e, 2);
+            await HasNextAsync(e, 2);
             Assert.Equal(3, sum);
-            HasNext(e, 3);
+            await HasNextAsync(e, 3);
             Assert.Equal(6, sum);
-            HasNext(e, 4);
+            await HasNextAsync(e, 4);
             Assert.Equal(10, sum);
-            NoNext(e);
+            await NoNextAsync(e);
 
             Assert.False(fail);
             Assert.True(done);
         }
 
         [Fact]
-        public void Do4()
+        public async Task Do4Async()
         {
             var sum = 0;
             var done = false;
@@ -98,15 +98,15 @@ namespace Tests
             var ys = xs.Do(x => sum += x, () => { done = true; });
 
             var e = ys.GetAsyncEnumerator();
-            HasNext(e, 1);
+            await HasNextAsync(e, 1);
             Assert.Equal(1, sum);
-            HasNext(e, 2);
+            await HasNextAsync(e, 2);
             Assert.Equal(3, sum);
-            HasNext(e, 3);
+            await HasNextAsync(e, 3);
             Assert.Equal(6, sum);
-            HasNext(e, 4);
+            await HasNextAsync(e, 4);
             Assert.Equal(10, sum);
-            NoNext(e);
+            await NoNextAsync(e);
 
             Assert.True(done);
         }

Ix.NET/Source/System.Interactive.Async.Tests/System/Linq/Operators/Expand.cs

@@ -20,19 +20,19 @@ namespace Tests
         }
 
         [Fact]
-        public void Expand1()
+        public async Task Expand1Async()
         {
             var xs = new[] { 2, 3 }.ToAsyncEnumerable().Expand(x => AsyncEnumerableEx.Return(x - 1).Repeat(x - 1));
 
             var e = xs.GetAsyncEnumerator();
-            HasNext(e, 2);
-            HasNext(e, 3);
-            HasNext(e, 1);
-            HasNext(e, 2);
-            HasNext(e, 2);
-            HasNext(e, 1);
-            HasNext(e, 1);
-            NoNext(e);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 3);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 1);
+            await NoNextAsync(e);
         }
 
         [Fact]
@@ -46,13 +46,13 @@ namespace Tests
         }
 
         [Fact]
-        public void Expand3()
+        public async Task Expand3Async()
         {
             var xs = new[] { 2, 3 }.ToAsyncEnumerable().Expand(x => default(IAsyncEnumerable<int>));
 
             var e = xs.GetAsyncEnumerator();
-            HasNext(e, 2);
-            HasNext(e, 3);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 3);
             AssertThrows(() => e.MoveNextAsync().Wait(WaitTimeoutMs), (Exception ex_) => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is NullReferenceException);
         }
 

Ix.NET/Source/System.Interactive.Async.Tests/System/Linq/Operators/Finally.cs

@@ -20,7 +20,7 @@ namespace Tests
         }
 
         [Fact]
-        public void Finally1()
+        public async Task Finally1Async()
         {
             var b = false;
 
@@ -29,13 +29,13 @@ namespace Tests
             var e = xs.GetAsyncEnumerator();
 
             Assert.False(b);
-            NoNext(e);
+            await NoNextAsync(e);
 
             Assert.True(b);
         }
 
         [Fact]
-        public void Finally2()
+        public async Task Finally2Async()
         {
             var b = false;
 
@@ -44,10 +44,10 @@ namespace Tests
             var e = xs.GetAsyncEnumerator();
 
             Assert.False(b);
-            HasNext(e, 42);
+            await HasNextAsync(e, 42);
 
             Assert.False(b);
-            NoNext(e);
+            await NoNextAsync(e);
 
             Assert.True(b);
         }
@@ -70,7 +70,7 @@ namespace Tests
         }
 
         [Fact]
-        public void Finally4()
+        public async Task Finally4Async()
         {
             var b = false;
 
@@ -79,13 +79,13 @@ namespace Tests
             var e = xs.GetAsyncEnumerator();
 
             Assert.False(b);
-            HasNext(e, 1);
+            await HasNextAsync(e, 1);
 
             Assert.False(b);
-            HasNext(e, 2);
+            await HasNextAsync(e, 2);
 
             Assert.False(b);
-            NoNext(e);
+            await NoNextAsync(e);
 
             Assert.True(b);
         }
@@ -100,7 +100,7 @@ namespace Tests
             var e = xs.GetAsyncEnumerator();
 
             Assert.False(b);
-            HasNext(e, 1);
+            await HasNextAsync(e, 1);
 
             await e.DisposeAsync();
 

Ix.NET/Source/System.Interactive.Async.Tests/System/Linq/Operators/Generate.cs

@@ -25,12 +25,12 @@ namespace Tests
             var xs = AsyncEnumerableEx.Generate(0, x => x < 5, x => x + 1, x => x * x);
 
             var e = xs.GetAsyncEnumerator();
-            HasNext(e, 0);
-            HasNext(e, 1);
-            HasNext(e, 4);
-            HasNext(e, 9);
-            HasNext(e, 16);
-            NoNext(e);
+            await HasNextAsync(e, 0);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 4);
+            await HasNextAsync(e, 9);
+            await HasNextAsync(e, 16);
+            await NoNextAsync(e);
             await e.DisposeAsync();
         }
 
@@ -45,24 +45,24 @@ namespace Tests
         }
 
         [Fact]
-        public void Generate3()
+        public async Task Generate3Async()
         {
             var ex = new Exception("Bang!");
             var xs = AsyncEnumerableEx.Generate(0, x => true, x => x + 1, x => { if (x == 1) throw ex; return x * x; });
 
             var e = xs.GetAsyncEnumerator();
-            HasNext(e, 0);
+            await HasNextAsync(e, 0);
             AssertThrows(() => e.MoveNextAsync().Wait(WaitTimeoutMs), (Exception ex_) => ((AggregateException)ex_).InnerExceptions.Single() == ex);
         }
 
         [Fact]
-        public void Generate4()
+        public async Task Generate4Async()
         {
             var ex = new Exception("Bang!");
             var xs = AsyncEnumerableEx.Generate(0, x => true, x => { throw ex; }, x => x * x);
 
             var e = xs.GetAsyncEnumerator();
-            HasNext(e, 0);
+            await HasNextAsync(e, 0);
             AssertThrows(() => e.MoveNextAsync().Wait(WaitTimeoutMs), (Exception ex_) => ((AggregateException)ex_).InnerExceptions.Single() == ex);
         }
 

Ix.NET/Source/System.Interactive.Async.Tests/System/Linq/Operators/IgnoreElements.cs

@@ -19,30 +19,30 @@ namespace Tests
         }
 
         [Fact]
-        public void IgnoreElements1()
+        public async Task IgnoreElements1Async()
         {
             var xs = AsyncEnumerable.Empty<int>().IgnoreElements();
 
             var e = xs.GetAsyncEnumerator();
-            NoNext(e);
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void IgnoreElements2()
+        public async Task IgnoreElements2Async()
         {
             var xs = Return42.IgnoreElements();
 
             var e = xs.GetAsyncEnumerator();
-            NoNext(e);
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void IgnoreElements3()
+        public async Task IgnoreElements3Async()
         {
             var xs = AsyncEnumerable.Range(0, 10).IgnoreElements();
 
             var e = xs.GetAsyncEnumerator();
-            NoNext(e);
+            await NoNextAsync(e);
         }
 
         [Fact]

Ix.NET/Source/System.Interactive.Async.Tests/System/Linq/Operators/OnErrorResumeNext.cs

@@ -22,7 +22,7 @@ namespace Tests
         }
 
         [Fact]
-        public void OnErrorResumeNext7()
+        public async Task OnErrorResumeNext7Async()
         {
             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
             var ys = new[] { 4, 5, 6 }.ToAsyncEnumerable();
@@ -30,17 +30,17 @@ namespace Tests
             var res = AsyncEnumerableEx.OnErrorResumeNext(xs, ys);
 
             var e = res.GetAsyncEnumerator();
-            HasNext(e, 1);
-            HasNext(e, 2);
-            HasNext(e, 3);
-            HasNext(e, 4);
-            HasNext(e, 5);
-            HasNext(e, 6);
-            NoNext(e);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 3);
+            await HasNextAsync(e, 4);
+            await HasNextAsync(e, 5);
+            await HasNextAsync(e, 6);
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void OnErrorResumeNext8()
+        public async Task OnErrorResumeNext8Async()
         {
             var ex = new InvalidOperationException("Bang!");
 
@@ -50,17 +50,17 @@ namespace Tests
             var res = AsyncEnumerableEx.OnErrorResumeNext(xs, ys);
 
             var e = res.GetAsyncEnumerator();
-            HasNext(e, 1);
-            HasNext(e, 2);
-            HasNext(e, 3);
-            HasNext(e, 4);
-            HasNext(e, 5);
-            HasNext(e, 6);
-            NoNext(e);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 3);
+            await HasNextAsync(e, 4);
+            await HasNextAsync(e, 5);
+            await HasNextAsync(e, 6);
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void OnErrorResumeNext9()
+        public async Task OnErrorResumeNext9Async()
         {
             var ex = new InvalidOperationException("Bang!");
 
@@ -70,30 +70,30 @@ namespace Tests
             var res = AsyncEnumerableEx.OnErrorResumeNext(new[] { xs, xs, ys, ys });
 
             var e = res.GetAsyncEnumerator();
-            HasNext(e, 1);
-            HasNext(e, 2);
-            HasNext(e, 3);
-            HasNext(e, 1);
-            HasNext(e, 2);
-            HasNext(e, 3);
-            HasNext(e, 4);
-            HasNext(e, 5);
-            HasNext(e, 6);
-            HasNext(e, 4);
-            HasNext(e, 5);
-            HasNext(e, 6);
-            NoNext(e);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 3);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 3);
+            await HasNextAsync(e, 4);
+            await HasNextAsync(e, 5);
+            await HasNextAsync(e, 6);
+            await HasNextAsync(e, 4);
+            await HasNextAsync(e, 5);
+            await HasNextAsync(e, 6);
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void OnErrorResumeNext10()
+        public async Task OnErrorResumeNext10Async()
         {
             var res = OnErrorResumeNextXss().OnErrorResumeNext();
 
             var e = res.GetAsyncEnumerator();
-            HasNext(e, 1);
-            HasNext(e, 2);
-            HasNext(e, 3);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 3);
 
             AssertThrows(() => e.MoveNextAsync().Wait(WaitTimeoutMs), (Exception ex_) => ((AggregateException)ex_).Flatten().InnerExceptions.Single().Message == "Bang!");
         }
@@ -105,7 +105,7 @@ namespace Tests
         }
 
         [Fact]
-        public void OnErrorResumeNext11()
+        public async Task OnErrorResumeNext11Async()
         {
             var ex = new InvalidOperationException("Bang!");
 
@@ -114,22 +114,22 @@ namespace Tests
             var res = AsyncEnumerableEx.OnErrorResumeNext(new[] { xs, xs });
 
             var e = res.GetAsyncEnumerator();
-            HasNext(e, 1);
-            HasNext(e, 2);
-            HasNext(e, 3);
-            HasNext(e, 1);
-            HasNext(e, 2);
-            HasNext(e, 3);
-            NoNext(e);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 3);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 3);
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void OnErrorResumeNext12()
+        public async Task OnErrorResumeNext12Async()
         {
             var res = AsyncEnumerableEx.OnErrorResumeNext(Enumerable.Empty<IAsyncEnumerable<int>>());
 
             var e = res.GetAsyncEnumerator();
-            NoNext(e);
+            await NoNextAsync(e);
         }
 
         [Fact]

Ix.NET/Source/System.Interactive.Async.Tests/System/Linq/Operators/Repeat.cs

@@ -18,11 +18,11 @@ namespace Tests
             var xs = AsyncEnumerableEx.Repeat(2);
 
             var e = xs.GetAsyncEnumerator();
-            HasNext(e, 2);
-            HasNext(e, 2);
-            HasNext(e, 2);
-            HasNext(e, 2);
-            HasNext(e, 2);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 2);
             await e.DisposeAsync();
         }
 
@@ -43,67 +43,67 @@ namespace Tests
         }
 
         [Fact]
-        public void RepeatSequence1()
+        public async Task RepeatSequence1Async()
         {
             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable().Repeat();
 
             var e = xs.GetAsyncEnumerator();
-            HasNext(e, 1);
-            HasNext(e, 2);
-            HasNext(e, 3);
-            HasNext(e, 1);
-            HasNext(e, 2);
-            HasNext(e, 3);
-            HasNext(e, 1);
-            HasNext(e, 2);
-            HasNext(e, 3);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 3);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 3);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 3);
         }
 
         [Fact]
-        public void RepeatSequence2()
+        public async Task RepeatSequence2Async()
         {
             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable().Repeat(3);
 
             var e = xs.GetAsyncEnumerator();
-            HasNext(e, 1);
-            HasNext(e, 2);
-            HasNext(e, 3);
-            HasNext(e, 1);
-            HasNext(e, 2);
-            HasNext(e, 3);
-            HasNext(e, 1);
-            HasNext(e, 2);
-            HasNext(e, 3);
-            NoNext(e);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 3);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 3);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 3);
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void RepeatSequence3()
+        public async Task RepeatSequence3Async()
         {
             var i = 0;
             var xs = RepeatXs(() => i++).ToAsyncEnumerable().Repeat(3);
 
             var e = xs.GetAsyncEnumerator();
-            HasNext(e, 1);
-            HasNext(e, 2);
-            HasNext(e, 1);
-            HasNext(e, 2);
-            HasNext(e, 1);
-            HasNext(e, 2);
-            NoNext(e);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 2);
+            await NoNextAsync(e);
 
             Assert.Equal(3, i);
         }
 
         [Fact]
-        public void RepeatSequence4()
+        public async Task RepeatSequence4Async()
         {
             var i = 0;
             var xs = RepeatXs(() => i++).ToAsyncEnumerable().Repeat(0);
 
             var e = xs.GetAsyncEnumerator();
 
-            NoNext(e);
+            await NoNextAsync(e);
         }
 
         [Fact]

Ix.NET/Source/System.Interactive.Async.Tests/System/Linq/Operators/Retry.cs

@@ -21,21 +21,21 @@ namespace Tests
         }
 
         [Fact]
-        public void Retry1()
+        public async System.Threading.Tasks.Task Retry1Async()
         {
             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
 
             var res = xs.Retry();
 
             var e = res.GetAsyncEnumerator();
-            HasNext(e, 1);
-            HasNext(e, 2);
-            HasNext(e, 3);
-            NoNext(e);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 3);
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void Retry2()
+        public async System.Threading.Tasks.Task Retry2Async()
         {
             var ex = new InvalidOperationException("Bang!");
 
@@ -44,15 +44,15 @@ namespace Tests
             var res = xs.Retry();
 
             var e = res.GetAsyncEnumerator();
-            HasNext(e, 1);
-            HasNext(e, 2);
-            HasNext(e, 3);
-            HasNext(e, 1);
-            HasNext(e, 2);
-            HasNext(e, 3);
-            HasNext(e, 1);
-            HasNext(e, 2);
-            HasNext(e, 3);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 3);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 3);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 3);
         }
     }
 }

Ix.NET/Source/System.Interactive.Async.Tests/System/Linq/Operators/Return.cs

@@ -10,10 +10,10 @@ namespace Tests
     public class Return : AsyncEnumerableExTests
     {
         [Fact]
-        public void Return1()
+        public async System.Threading.Tasks.Task Return1Async()
         {
             var xs = AsyncEnumerableEx.Return(42);
-            HasNext(xs.GetAsyncEnumerator(), 42);
+            await HasNextAsync(xs.GetAsyncEnumerator(), 42);
         }
     }
 }

Ix.NET/Source/System.Interactive.Async.Tests/System/Linq/Operators/Scan.cs

@@ -23,26 +23,26 @@ namespace Tests
         }
 
         [Fact]
-        public void Scan1()
+        public async Task Scan1Async()
         {
             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable().Scan(8, (x, y) => x + y);
 
             var e = xs.GetAsyncEnumerator();
-            HasNext(e, 9);
-            HasNext(e, 11);
-            HasNext(e, 14);
-            NoNext(e);
+            await HasNextAsync(e, 9);
+            await HasNextAsync(e, 11);
+            await HasNextAsync(e, 14);
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void Scan2()
+        public async Task Scan2Async()
         {
             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable().Scan((x, y) => x + y);
 
             var e = xs.GetAsyncEnumerator();
-            HasNext(e, 3);
-            HasNext(e, 6);
-            NoNext(e);
+            await HasNextAsync(e, 3);
+            await HasNextAsync(e, 6);
+            await NoNextAsync(e);
         }
 
         [Fact]

Ix.NET/Source/System.Interactive.Async.Tests/System/Linq/Operators/SelectMany.cs

@@ -18,7 +18,7 @@ namespace Tests
         }
 
         [Fact]
-        public void SelectMany1()
+        public async System.Threading.Tasks.Task SelectMany1Async()
         {
             var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable();
             var ys = new[] { 3, 4 }.ToAsyncEnumerable();
@@ -26,13 +26,13 @@ namespace Tests
             var res = xs.SelectMany(ys);
 
             var e = res.GetAsyncEnumerator();
-            HasNext(e, 3);
-            HasNext(e, 4);
-            HasNext(e, 3);
-            HasNext(e, 4);
-            HasNext(e, 3);
-            HasNext(e, 4);
-            NoNext(e);
+            await HasNextAsync(e, 3);
+            await HasNextAsync(e, 4);
+            await HasNextAsync(e, 3);
+            await HasNextAsync(e, 4);
+            await HasNextAsync(e, 3);
+            await HasNextAsync(e, 4);
+            await NoNextAsync(e);
         }
     }
 }

Ix.NET/Source/System.Interactive.Async.Tests/System/Linq/Operators/StartWith.cs

@@ -18,37 +18,37 @@ namespace Tests
         }
 
         [Fact]
-        public void StartWith1()
+        public async System.Threading.Tasks.Task StartWith1Async()
         {
             var xs = AsyncEnumerable.Empty<int>().StartWith(1, 2);
 
             var e = xs.GetAsyncEnumerator();
-            HasNext(e, 1);
-            HasNext(e, 2);
-            NoNext(e);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 2);
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void StartWith2()
+        public async System.Threading.Tasks.Task StartWith2Async()
         {
             var xs = Return42.StartWith(40, 41);
 
             var e = xs.GetAsyncEnumerator();
-            HasNext(e, 40);
-            HasNext(e, 41);
-            HasNext(e, 42);
-            NoNext(e);
+            await HasNextAsync(e, 40);
+            await HasNextAsync(e, 41);
+            await HasNextAsync(e, 42);
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void StartWith3()
+        public async System.Threading.Tasks.Task StartWith3Async()
         {
             var ex = new Exception("Bang!");
             var xs = Throw<int>(ex).StartWith(1, 2);
 
             var e = xs.GetAsyncEnumerator();
-            HasNext(e, 1);
-            HasNext(e, 2);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 2);
             AssertThrows(() => e.MoveNextAsync().Wait(WaitTimeoutMs), SingleInnerExceptionMatches(ex));
         }
     }

Ix.NET/Source/System.Interactive.Async.Tests/System/Linq/Operators/Using.cs

@@ -102,7 +102,7 @@ namespace Tests
         }
 
         [Fact]
-        public void Using4()
+        public async Task Using4Async()
         {
             var i = 0;
             var disposed = new TaskCompletionSource<bool>();
@@ -122,11 +122,11 @@ namespace Tests
 
             Assert.Equal(0, i);
 
-            HasNext(e, 42);
+            await HasNextAsync(e, 42);
 
             Assert.Equal(1, i);
 
-            NoNext(e);
+            await NoNextAsync(e);
 
             Assert.True(disposed.Task.Result);
         }