Converting a bunch of test code to async.

Ix.NET/Source/System.Linq.Async.Tests/System/Linq/AsyncEnumerableTests.cs

@@ -46,14 +46,14 @@ namespace Tests
             }
         }
 
-        public void NoNext<T>(IAsyncEnumerator<T> e)
+        public 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)
+        public 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.Linq.Async.Tests/System/Linq/Operators/Append.cs

@@ -15,11 +15,11 @@ namespace Tests
         [Fact]
         public void Append_Null()
         {
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Append(default, 42));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.Append(default, 42));
         }
 
         [Fact]
-        public void Append1()
+        public async Task Append1()
         {
             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
 
@@ -27,11 +27,11 @@ namespace Tests
 
             var e = res.GetAsyncEnumerator();
 
-            HasNext(e, 1);
-            HasNext(e, 2);
-            HasNext(e, 3);
-            HasNext(e, 4);
-            NoNext(e);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 3);
+            await HasNextAsync(e, 4);
+            await NoNextAsync(e);
         }
 
         [Fact]
@@ -108,7 +108,7 @@ namespace Tests
 
 
         [Fact]
-        public void AppendN1()
+        public async Task AppendN1()
         {
             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
 
@@ -118,13 +118,13 @@ namespace Tests
 
             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]

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

@@ -5,6 +5,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading.Tasks;
 using Xunit;
 
 namespace Tests
@@ -14,21 +15,21 @@ namespace Tests
         [Fact]
         public void Cast_Null()
         {
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Cast<int>(default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.Cast<int>(default));
         }
 
         [Fact]
-        public void Cast1()
+        public async Task Cast1()
         {
             var xs = new object[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
             var ys = xs.Cast<int>();
 
             var e = ys.GetAsyncEnumerator();
-            HasNext(e, 1);
-            HasNext(e, 2);
-            HasNext(e, 3);
-            HasNext(e, 4);
-            NoNext(e);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 3);
+            await HasNextAsync(e, 4);
+            await NoNextAsync(e);
         }
 
         [Fact]

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

@@ -15,35 +15,35 @@ namespace Tests
         [Fact]
         public void Concat_Null()
         {
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Concat(default, Return42));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Concat(Return42, default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.Concat(default, Return42));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.Concat(Return42, default));
         }
 
         [Fact]
-        public void Concat1()
+        public async Task Concat1Async()
         {
             var ys = new[] { 1, 2, 3 }.ToAsyncEnumerable().Concat(new[] { 4, 5, 6 }.ToAsyncEnumerable());
 
             var e = ys.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 Concat2()
+        public async Task Concat2Async()
         {
             var ex = new Exception("Bang");
             var ys = new[] { 1, 2, 3 }.ToAsyncEnumerable().Concat(Throw<int>(ex));
 
             var e = ys.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));
         }
 
@@ -58,7 +58,7 @@ namespace Tests
         }
 
         [Fact]
-        public void Concat7()
+        public async Task Concat7Async()
         {
             var ws = new[] { 1, 2, 3 }.ToAsyncEnumerable();
             var xs = new[] { 4, 5 }.ToAsyncEnumerable();
@@ -68,18 +68,18 @@ namespace Tests
             var res = ws.Concat(xs).Concat(ys).Concat(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);
-            HasNext(e, 9);
-            HasNext(e, 10);
-            HasNext(e, 11);
-            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 HasNextAsync(e, 9);
+            await HasNextAsync(e, 10);
+            await HasNextAsync(e, 11);
+            await NoNextAsync(e);
         }
 
         [Fact]

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

@@ -13,7 +13,7 @@ namespace Tests
         [Fact]
         public void CreateEnumerable_Null()
         {
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.CreateEnumerable<int>(default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.CreateEnumerable<int>(default));
         }
     }
 }

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

@@ -15,7 +15,7 @@ namespace Tests
         [Fact]
         public void CreateEnumerator_Null()
         {
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.CreateEnumerator(default, () => 3, () => TaskExt.CompletedTask));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.CreateEnumerator(default, () => 3, () => TaskExt.CompletedTask));
         }
 
         [Fact]
@@ -25,7 +25,7 @@ namespace Tests
 
             var enu = (IAsyncEnumerable<int>)iter;
 
-            AssertThrows<NotSupportedException>(() => enu.GetAsyncEnumerator());
+            Assert.Throws<NotSupportedException>(() => enu.GetAsyncEnumerator());
         }
     }
 }

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

@@ -15,74 +15,74 @@ namespace Tests
         [Fact]
         public void DefaultIfEmpty_Null()
         {
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.DefaultIfEmpty<int>(default));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.DefaultIfEmpty(default, 42));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.DefaultIfEmpty<int>(default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.DefaultIfEmpty(default, 42));
         }
 
         [Fact]
-        public void DefaultIfEmpty1()
+        public async Task DefaultIfEmpty1()
         {
             var xs = AsyncEnumerable.Empty<int>().DefaultIfEmpty();
 
             var e = xs.GetAsyncEnumerator();
-            HasNext(e, 0);
-            NoNext(e);
+            await HasNextAsync(e, 0);
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void DefaultIfEmpty2()
+        public async Task DefaultIfEmpty2()
         {
             var xs = AsyncEnumerable.Empty<int>().DefaultIfEmpty(42);
 
             var e = xs.GetAsyncEnumerator();
-            HasNext(e, 42);
-            NoNext(e);
+            await HasNextAsync(e, 42);
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void DefaultIfEmpty3()
+        public async Task DefaultIfEmpty3()
         {
             var xs = Return42.DefaultIfEmpty();
 
             var e = xs.GetAsyncEnumerator();
-            HasNext(e, 42);
-            NoNext(e);
+            await HasNextAsync(e, 42);
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void DefaultIfEmpty4()
+        public async Task DefaultIfEmpty4()
         {
             var xs = Return42.DefaultIfEmpty(24);
 
             var e = xs.GetAsyncEnumerator();
-            HasNext(e, 42);
-            NoNext(e);
+            await HasNextAsync(e, 42);
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void DefaultIfEmpty5()
+        public async Task DefaultIfEmpty5()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().DefaultIfEmpty();
 
             var e = xs.GetAsyncEnumerator();
-            HasNext(e, 1);
-            HasNext(e, 2);
-            HasNext(e, 3);
-            HasNext(e, 4);
-            NoNext(e);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 3);
+            await HasNextAsync(e, 4);
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void DefaultIfEmpty6()
+        public async Task DefaultIfEmpty6()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().DefaultIfEmpty(24);
 
             var e = xs.GetAsyncEnumerator();
-            HasNext(e, 1);
-            HasNext(e, 2);
-            HasNext(e, 3);
-            HasNext(e, 4);
-            NoNext(e);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 3);
+            await HasNextAsync(e, 4);
+            await NoNextAsync(e);
         }
 
         [Fact]

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

@@ -15,36 +15,36 @@ namespace Tests
         [Fact]
         public void Distinct_Null()
         {
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Distinct<int>(default));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Distinct(default, EqualityComparer<int>.Default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.Distinct<int>(default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.Distinct(default, EqualityComparer<int>.Default));
         }
 
         [Fact]
-        public void Distinct1()
+        public async Task Distinct1()
         {
             var xs = new[] { 1, 2, 1, 3, 5, 2, 1, 4 }.ToAsyncEnumerable().Distinct();
 
             var e = xs.GetAsyncEnumerator();
-            HasNext(e, 1);
-            HasNext(e, 2);
-            HasNext(e, 3);
-            HasNext(e, 5);
-            HasNext(e, 4);
-            NoNext(e);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 3);
+            await HasNextAsync(e, 5);
+            await HasNextAsync(e, 4);
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void Distinct2()
+        public async Task Distinct2()
         {
             var xs = new[] { 1, -2, -1, 3, 5, 2, 1, 4 }.ToAsyncEnumerable().Distinct(new Eq());
 
             var e = xs.GetAsyncEnumerator();
-            HasNext(e, 1);
-            HasNext(e, -2);
-            HasNext(e, 3);
-            HasNext(e, 5);
-            HasNext(e, 4);
-            NoNext(e);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, -2);
+            await HasNextAsync(e, 3);
+            await HasNextAsync(e, 5);
+            await HasNextAsync(e, 4);
+            await NoNextAsync(e);
         }
 
         [Fact]
@@ -82,13 +82,13 @@ namespace Tests
         }
 
         [Fact]
-        public void Distinct12()
+        public async Task Distinct12()
         {
             var xs = AsyncEnumerable.Empty<int>().Distinct();
 
             var e = xs.GetAsyncEnumerator();
 
-            NoNext(e);
+            await NoNextAsync(e);
         }
 
         private sealed class Eq : IEqualityComparer<int>

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

@@ -2,8 +2,8 @@
 // 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.Linq;
+using System.Threading.Tasks;
 using Xunit;
 
 namespace Tests
@@ -11,19 +11,10 @@ namespace Tests
     public class Empty : AsyncEnumerableTests
     {
         [Fact]
-        public void Empty1()
+        public async Task Empty1()
         {
             var xs = AsyncEnumerable.Empty<int>();
-            NoNext(xs.GetAsyncEnumerator());
-        }
-
-        [Fact]
-        public void Empty2()
-        {
-            var xs = AsyncEnumerable.Empty<int>();
-
-            var e = xs.GetAsyncEnumerator();
-            Assert.False(e.MoveNextAsync().Result);
+            await NoNextAsync(xs.GetAsyncEnumerator());
         }
     }
 }

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

@@ -15,35 +15,35 @@ namespace Tests
         [Fact]
         public void Except_Null()
         {
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Except(default, Return42));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Except(Return42, default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.Except(default, Return42));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.Except(Return42, default));
 
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Except(default, Return42, new Eq()));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Except(Return42, null, new Eq()));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.Except(default, Return42, new Eq()));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.Except(Return42, null, new Eq()));
         }
 
         [Fact]
-        public void Except1()
+        public async Task Except1()
         {
             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
             var ys = new[] { 3, 5, 1, 4 }.ToAsyncEnumerable();
             var res = xs.Except(ys);
 
             var e = res.GetAsyncEnumerator();
-            HasNext(e, 2);
-            NoNext(e);
+            await HasNextAsync(e, 2);
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void Except2()
+        public async Task Except2()
         {
             var xs = new[] { 1, 2, -3 }.ToAsyncEnumerable();
             var ys = new[] { 3, 5, -1, 4 }.ToAsyncEnumerable();
             var res = xs.Except(ys, new Eq());
 
             var e = res.GetAsyncEnumerator();
-            HasNext(e, 2);
-            NoNext(e);
+            await HasNextAsync(e, 2);
+            await NoNextAsync(e);
         }
 
         [Fact]

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

@@ -15,41 +15,41 @@ namespace Tests
         [Fact]
         public void GroupBy_Null()
         {
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int>(default, x => x));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupBy(Return42, default(Func<int, int>)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int>(default, x => x));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy(Return42, default(Func<int, int>)));
 
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int>(default, x => x, EqualityComparer<int>.Default));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupBy(Return42, default(Func<int, int>), EqualityComparer<int>.Default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int>(default, x => x, EqualityComparer<int>.Default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy(Return42, default(Func<int, int>), EqualityComparer<int>.Default));
 
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int>(default, x => x, x => x));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int>(Return42, default, x => x));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupBy(Return42, x => x, default(Func<int, int>)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int>(default, x => x, x => x));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int>(Return42, default, x => x));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy(Return42, x => x, default(Func<int, int>)));
 
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int>(default, x => x, x => x, EqualityComparer<int>.Default));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupBy(Return42, default, x => x, EqualityComparer<int>.Default));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupBy(Return42, x => x, default(Func<int, int>), EqualityComparer<int>.Default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int>(default, x => x, x => x, EqualityComparer<int>.Default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy(Return42, default, x => x, EqualityComparer<int>.Default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy(Return42, x => x, default(Func<int, int>), EqualityComparer<int>.Default));
 
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int>(default, x => x, (x, ys) => x));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int>(Return42, default, (x, ys) => x));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupBy(Return42, x => x, default(Func<int, IAsyncEnumerable<int>, int>)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int>(default, x => x, (x, ys) => x));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int>(Return42, default, (x, ys) => x));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy(Return42, x => x, default(Func<int, IAsyncEnumerable<int>, int>)));
 
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int>(default, x => x, (x, ys) => x, EqualityComparer<int>.Default));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupBy(Return42, default, (x, ys) => x, EqualityComparer<int>.Default));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupBy(Return42, x => x, default(Func<int, IAsyncEnumerable<int>, int>), EqualityComparer<int>.Default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int>(default, x => x, (x, ys) => x, EqualityComparer<int>.Default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy(Return42, default, (x, ys) => x, EqualityComparer<int>.Default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy(Return42, x => x, default(Func<int, IAsyncEnumerable<int>, int>), EqualityComparer<int>.Default));
 
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int, int>(default, x => x, x => x, (x, ys) => x));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int, int>(Return42, default, x => x, (x, ys) => x));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int, int>(Return42, x => x, default, (x, ys) => x));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int, int>(Return42, x => x, x => x, default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int, int>(default, x => x, x => x, (x, ys) => x));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int, int>(Return42, default, x => x, (x, ys) => x));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int, int>(Return42, x => x, default, (x, ys) => x));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int, int>(Return42, x => x, x => x, default));
 
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int, int>(default, x => x, x => x, (x, ys) => x, EqualityComparer<int>.Default));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupBy(Return42, default, x => x, (x, ys) => x, EqualityComparer<int>.Default));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int, int>(Return42, x => x, default, (x, ys) => x, EqualityComparer<int>.Default));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int, int>(Return42, x => x, x => x, default, EqualityComparer<int>.Default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int, int>(default, x => x, x => x, (x, ys) => x, EqualityComparer<int>.Default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy(Return42, default, x => x, (x, ys) => x, EqualityComparer<int>.Default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int, int>(Return42, x => x, default, (x, ys) => x, EqualityComparer<int>.Default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int, int>(Return42, x => x, x => x, default, EqualityComparer<int>.Default));
         }
 
         [Fact]
-        public void GroupBy1()
+        public async Task GroupBy1()
         {
             var xs = new[] {
                 new { Name = "Bart", Age = 27 },
@@ -70,35 +70,35 @@ namespace Tests
             Assert.True(e.MoveNextAsync().Result);
             Assert.Equal(2, e.Current.Key);
             var g1 = e.Current.GetAsyncEnumerator();
-            HasNext(g1, xs[0]);
-            HasNext(g1, xs[2]);
-            HasNext(g1, xs[4]);
-            HasNext(g1, xs[5]);
-            NoNext(g1);
+            await HasNextAsync(g1, xs[0]);
+            await HasNextAsync(g1, xs[2]);
+            await HasNextAsync(g1, xs[4]);
+            await HasNextAsync(g1, xs[5]);
+            await NoNextAsync(g1);
 
             Assert.True(e.MoveNextAsync().Result);
             Assert.Equal(6, e.Current.Key);
             var g2 = e.Current.GetAsyncEnumerator();
-            HasNext(g2, xs[1]);
-            NoNext(g2);
+            await HasNextAsync(g2, xs[1]);
+            await NoNextAsync(g2);
 
             Assert.True(e.MoveNextAsync().Result);
             Assert.Equal(1, e.Current.Key);
             var g3 = e.Current.GetAsyncEnumerator();
-            HasNext(g3, xs[3]);
-            NoNext(g3);
+            await HasNextAsync(g3, xs[3]);
+            await NoNextAsync(g3);
 
             Assert.True(e.MoveNextAsync().Result);
             Assert.Equal(4, e.Current.Key);
             var g4 = e.Current.GetAsyncEnumerator();
-            HasNext(g4, xs[6]);
-            NoNext(g4);
+            await HasNextAsync(g4, xs[6]);
+            await NoNextAsync(g4);
 
-            NoNext(e);
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void GroupBy2()
+        public async Task GroupBy2()
         {
             var xs = new[] {
                 new { Name = "Bart", Age = 27 },
@@ -132,36 +132,36 @@ namespace Tests
             var g4 = e.Current;
             Assert.Equal(4, g4.Key);
 
-            NoNext(e);
+            await NoNextAsync(e);
 
             var g1e = g1.GetAsyncEnumerator();
-            HasNext(g1e, xs[0]);
-            HasNext(g1e, xs[2]);
-            HasNext(g1e, xs[4]);
-            HasNext(g1e, xs[5]);
-            NoNext(g1e);
+            await HasNextAsync(g1e, xs[0]);
+            await HasNextAsync(g1e, xs[2]);
+            await HasNextAsync(g1e, xs[4]);
+            await HasNextAsync(g1e, xs[5]);
+            await NoNextAsync(g1e);
 
             var g2e = g2.GetAsyncEnumerator();
-            HasNext(g2e, xs[1]);
-            NoNext(g2e);
+            await HasNextAsync(g2e, xs[1]);
+            await NoNextAsync(g2e);
 
             var g3e = g3.GetAsyncEnumerator();
-            HasNext(g3e, xs[3]);
-            NoNext(g3e);
+            await HasNextAsync(g3e, xs[3]);
+            await NoNextAsync(g3e);
 
             var g4e = g4.GetAsyncEnumerator();
-            HasNext(g4e, xs[6]);
-            NoNext(g4e);
+            await HasNextAsync(g4e, xs[6]);
+            await NoNextAsync(g4e);
         }
 
         [Fact]
-        public void GroupBy3()
+        public async Task GroupBy3()
         {
             var xs = AsyncEnumerable.Empty<int>();
             var ys = xs.GroupBy(x => x);
 
             var e = ys.GetAsyncEnumerator();
-            NoNext(e);
+            await NoNextAsync(e);
         }
 
         [Fact]
@@ -189,13 +189,13 @@ namespace Tests
             //var g1 = e.Current;
             //Assert.Equal(g1.Key, 42);
             //var g1e = g1.GetEnumerator();
-            //HasNext(g1e, 42);
+            //await HasNextAsync(g1e, 42);
 
             //Assert.True(e.MoveNext().Result);
             //var g2 = e.Current;
             //Assert.Equal(g2.Key, 43);
             //var g2e = g2.GetEnumerator();
-            //HasNext(g2e, 43);
+            //await HasNextAsync(g2e, 43);
 
 
             //AssertThrows<Exception>(() => g1e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single().Message == "Bang!");
@@ -216,7 +216,7 @@ namespace Tests
             //var g1 = e.Current;
             //Assert.Equal(g1.Key, 42);
             //var g1e = g1.GetEnumerator();
-            //HasNext(g1e, 42);
+            //await HasNextAsync(g1e, 42);
             //AssertThrows<Exception>(() => g1e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single().Message == "Bang!");
 
 
@@ -255,13 +255,13 @@ namespace Tests
             //var g1 = e.Current;
             //Assert.Equal(g1.Key, 1);
             //var g1e = g1.GetEnumerator();
-            //HasNext(g1e, 1);
+            //await HasNextAsync(g1e, 1);
 
             //Assert.True(e.MoveNext().Result);
             //var g2 = e.Current;
             //Assert.Equal(g2.Key, 2);
             //var g2e = g2.GetEnumerator();
-            //HasNext(g2e, 2);
+            //await HasNextAsync(g2e, 2);
 
 
             //AssertThrows<Exception>(() => g1e.MoveNext().Wait(WaitTimeoutMs), SingleInnerExceptionMatches(ex));
@@ -269,7 +269,7 @@ namespace Tests
         }
 
         [Fact]
-        public void GroupBy9()
+        public async Task GroupBy9()
         {
             var xs = AsyncEnumerable.Range(0, 10);
             var ys = xs.GroupBy(x => x % 3, x => (char)('a' + x));
@@ -280,61 +280,61 @@ namespace Tests
             var g1 = e.Current;
             Assert.Equal(0, g1.Key);
             var g1e = g1.GetAsyncEnumerator();
-            HasNext(g1e, 'a');
-            HasNext(g1e, 'd');
-            HasNext(g1e, 'g');
-            HasNext(g1e, 'j');
-            NoNext(g1e);
+            await HasNextAsync(g1e, 'a');
+            await HasNextAsync(g1e, 'd');
+            await HasNextAsync(g1e, 'g');
+            await HasNextAsync(g1e, 'j');
+            await NoNextAsync(g1e);
 
             Assert.True(e.MoveNextAsync().Result);
             var g2 = e.Current;
             Assert.Equal(1, g2.Key);
             var g2e = g2.GetAsyncEnumerator();
-            HasNext(g2e, 'b');
-            HasNext(g2e, 'e');
-            HasNext(g2e, 'h');
-            NoNext(g2e);
+            await HasNextAsync(g2e, 'b');
+            await HasNextAsync(g2e, 'e');
+            await HasNextAsync(g2e, 'h');
+            await NoNextAsync(g2e);
 
             Assert.True(e.MoveNextAsync().Result);
             var g3 = e.Current;
             Assert.Equal(2, g3.Key);
             var g3e = g3.GetAsyncEnumerator();
-            HasNext(g3e, 'c');
-            HasNext(g3e, 'f');
-            HasNext(g3e, 'i');
-            NoNext(g3e);
+            await HasNextAsync(g3e, 'c');
+            await HasNextAsync(g3e, 'f');
+            await HasNextAsync(g3e, 'i');
+            await NoNextAsync(g3e);
 
-            NoNext(e);
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void GroupBy10()
+        public async Task GroupBy10()
         {
             var xs = AsyncEnumerable.Range(0, 10);
             var ys = xs.GroupBy(x => x % 3, x => (char)('a' + x), (k, cs) => k + " - " + cs.Aggregate("", (a, c) => a + c).Result);
 
             var e = ys.GetAsyncEnumerator();
-            HasNext(e, "0 - adgj");
-            HasNext(e, "1 - beh");
-            HasNext(e, "2 - cfi");
-            NoNext(e);
+            await HasNextAsync(e, "0 - adgj");
+            await HasNextAsync(e, "1 - beh");
+            await HasNextAsync(e, "2 - cfi");
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void GroupBy11()
+        public async Task GroupBy11()
         {
             var xs = AsyncEnumerable.Range(0, 10);
             var ys = xs.GroupBy(x => x % 3, (k, cs) => k + " - " + cs.Aggregate("", (a, c) => a + c).Result);
 
             var e = ys.GetAsyncEnumerator();
-            HasNext(e, "0 - 0369");
-            HasNext(e, "1 - 147");
-            HasNext(e, "2 - 258");
-            NoNext(e);
+            await HasNextAsync(e, "0 - 0369");
+            await HasNextAsync(e, "1 - 147");
+            await HasNextAsync(e, "2 - 258");
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void GroupBy12()
+        public async Task GroupBy12()
         {
             var xs = AsyncEnumerable.Range(0, 10);
             var ys = xs.GroupBy(x => x, new EqMod(3));
@@ -345,35 +345,35 @@ namespace Tests
             var g1 = e.Current;
             Assert.Equal(0, g1.Key);
             var g1e = g1.GetAsyncEnumerator();
-            HasNext(g1e, 0);
-            HasNext(g1e, 3);
-            HasNext(g1e, 6);
-            HasNext(g1e, 9);
-            NoNext(g1e);
+            await HasNextAsync(g1e, 0);
+            await HasNextAsync(g1e, 3);
+            await HasNextAsync(g1e, 6);
+            await HasNextAsync(g1e, 9);
+            await NoNextAsync(g1e);
 
             Assert.True(e.MoveNextAsync().Result);
             var g2 = e.Current;
             Assert.Equal(1, g2.Key);
             var g2e = g2.GetAsyncEnumerator();
-            HasNext(g2e, 1);
-            HasNext(g2e, 4);
-            HasNext(g2e, 7);
-            NoNext(g2e);
+            await HasNextAsync(g2e, 1);
+            await HasNextAsync(g2e, 4);
+            await HasNextAsync(g2e, 7);
+            await NoNextAsync(g2e);
 
             Assert.True(e.MoveNextAsync().Result);
             var g3 = e.Current;
             Assert.Equal(2, g3.Key);
             var g3e = g3.GetAsyncEnumerator();
-            HasNext(g3e, 2);
-            HasNext(g3e, 5);
-            HasNext(g3e, 8);
-            NoNext(g3e);
+            await HasNextAsync(g3e, 2);
+            await HasNextAsync(g3e, 5);
+            await HasNextAsync(g3e, 8);
+            await NoNextAsync(g3e);
 
-            NoNext(e);
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void GroupBy13()
+        public async Task GroupBy13()
         {
             var xs = AsyncEnumerable.Range(0, 10);
             var ys = xs.GroupBy(x => x, x => (char)('a' + x), new EqMod(3));
@@ -384,57 +384,57 @@ namespace Tests
             var g1 = e.Current;
             Assert.Equal(0, g1.Key);
             var g1e = g1.GetAsyncEnumerator();
-            HasNext(g1e, 'a');
-            HasNext(g1e, 'd');
-            HasNext(g1e, 'g');
-            HasNext(g1e, 'j');
-            NoNext(g1e);
+            await HasNextAsync(g1e, 'a');
+            await HasNextAsync(g1e, 'd');
+            await HasNextAsync(g1e, 'g');
+            await HasNextAsync(g1e, 'j');
+            await NoNextAsync(g1e);
 
             Assert.True(e.MoveNextAsync().Result);
             var g2 = e.Current;
             Assert.Equal(1, g2.Key);
             var g2e = g2.GetAsyncEnumerator();
-            HasNext(g2e, 'b');
-            HasNext(g2e, 'e');
-            HasNext(g2e, 'h');
-            NoNext(g2e);
+            await HasNextAsync(g2e, 'b');
+            await HasNextAsync(g2e, 'e');
+            await HasNextAsync(g2e, 'h');
+            await NoNextAsync(g2e);
 
             Assert.True(e.MoveNextAsync().Result);
             var g3 = e.Current;
             Assert.Equal(2, g3.Key);
             var g3e = g3.GetAsyncEnumerator();
-            HasNext(g3e, 'c');
-            HasNext(g3e, 'f');
-            HasNext(g3e, 'i');
-            NoNext(g3e);
+            await HasNextAsync(g3e, 'c');
+            await HasNextAsync(g3e, 'f');
+            await HasNextAsync(g3e, 'i');
+            await NoNextAsync(g3e);
 
-            NoNext(e);
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void GroupBy14()
+        public async Task GroupBy14()
         {
             var xs = AsyncEnumerable.Range(0, 10);
             var ys = xs.GroupBy(x => x, x => (char)('a' + x), (k, cs) => k + " - " + cs.Aggregate("", (a, c) => a + c).Result, new EqMod(3));
 
             var e = ys.GetAsyncEnumerator();
-            HasNext(e, "0 - adgj");
-            HasNext(e, "1 - beh");
-            HasNext(e, "2 - cfi");
-            NoNext(e);
+            await HasNextAsync(e, "0 - adgj");
+            await HasNextAsync(e, "1 - beh");
+            await HasNextAsync(e, "2 - cfi");
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void GroupBy15()
+        public async Task GroupBy15()
         {
             var xs = AsyncEnumerable.Range(0, 10);
             var ys = xs.GroupBy(x => x, (k, cs) => k + " - " + cs.Aggregate("", (a, c) => a + c).Result, new EqMod(3));
 
             var e = ys.GetAsyncEnumerator();
-            HasNext(e, "0 - 0369");
-            HasNext(e, "1 - 147");
-            HasNext(e, "2 - 258");
-            NoNext(e);
+            await HasNextAsync(e, "0 - 0369");
+            await HasNextAsync(e, "1 - 147");
+            await HasNextAsync(e, "2 - 258");
+            await NoNextAsync(e);
         }
 
         [Fact]
@@ -449,34 +449,34 @@ namespace Tests
             var g1 = e.Current;
             Assert.Equal(0, g1.Key);
             var g1e = g1.GetAsyncEnumerator();
-            HasNext(g1e, 'a');
-            HasNext(g1e, 'd');
-            HasNext(g1e, 'g');
-            HasNext(g1e, 'j');
-            NoNext(g1e);
+            await HasNextAsync(g1e, 'a');
+            await HasNextAsync(g1e, 'd');
+            await HasNextAsync(g1e, 'g');
+            await HasNextAsync(g1e, 'j');
+            await NoNextAsync(g1e);
             await g1e.DisposeAsync();
 
             Assert.True(e.MoveNextAsync().Result);
             var g2 = e.Current;
             Assert.Equal(1, g2.Key);
             var g2e = g2.GetAsyncEnumerator();
-            HasNext(g2e, 'b');
-            HasNext(g2e, 'e');
-            HasNext(g2e, 'h');
-            NoNext(g2e);
+            await HasNextAsync(g2e, 'b');
+            await HasNextAsync(g2e, 'e');
+            await HasNextAsync(g2e, 'h');
+            await NoNextAsync(g2e);
             await g2e.DisposeAsync();
 
             Assert.True(e.MoveNextAsync().Result);
             var g3 = e.Current;
             Assert.Equal(2, g3.Key);
             var g3e = g3.GetAsyncEnumerator();
-            HasNext(g3e, 'c');
-            HasNext(g3e, 'f');
-            HasNext(g3e, 'i');
-            NoNext(g3e);
+            await HasNextAsync(g3e, 'c');
+            await HasNextAsync(g3e, 'f');
+            await HasNextAsync(g3e, 'i');
+            await NoNextAsync(g3e);
             await g3e.DisposeAsync();
 
-            NoNext(e);
+            await NoNextAsync(e);
 
             await e.DisposeAsync();
         }
@@ -505,14 +505,14 @@ namespace Tests
             var g1 = e.Current;
             Assert.Equal(0, g1.Key);
             var g1e = g1.GetAsyncEnumerator();
-            HasNext(g1e, 'a');
+            await HasNextAsync(g1e, 'a');
 
             await e.DisposeAsync();
 
-            HasNext(g1e, 'd');
-            HasNext(g1e, 'g');
-            HasNext(g1e, 'j');
-            NoNext(g1e);
+            await HasNextAsync(g1e, 'd');
+            await HasNextAsync(g1e, 'g');
+            await HasNextAsync(g1e, 'j');
+            await NoNextAsync(g1e);
             await g1e.DisposeAsync();
 
             Assert.False(e.MoveNextAsync().Result);

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

@@ -5,6 +5,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading.Tasks;
 using Xunit;
 
 namespace Tests
@@ -14,21 +15,21 @@ namespace Tests
         [Fact]
         public void GroupJoin_Null()
         {
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupJoin<int, int, int, int>(default, Return42, x => x, x => x, (x, y) => x));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupJoin<int, int, int, int>(Return42, default, x => x, x => x, (x, y) => x));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupJoin(Return42, Return42, default, x => x, (x, y) => x));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupJoin(Return42, Return42, x => x, default, (x, y) => x));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupJoin<int, int, int, int>(Return42, Return42, x => x, x => x, default));
-
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupJoin<int, int, int, int>(default, Return42, x => x, x => x, (x, y) => x, EqualityComparer<int>.Default));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupJoin<int, int, int, int>(Return42, default, x => x, x => x, (x, y) => x, EqualityComparer<int>.Default));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupJoin(Return42, Return42, default, x => x, (x, y) => x, EqualityComparer<int>.Default));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupJoin(Return42, Return42, x => x, default, (x, y) => x, EqualityComparer<int>.Default));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupJoin<int, int, int, int>(Return42, Return42, x => x, x => x, default, EqualityComparer<int>.Default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupJoin<int, int, int, int>(default, Return42, x => x, x => x, (x, y) => x));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupJoin<int, int, int, int>(Return42, default, x => x, x => x, (x, y) => x));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupJoin(Return42, Return42, default, x => x, (x, y) => x));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupJoin(Return42, Return42, x => x, default, (x, y) => x));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupJoin<int, int, int, int>(Return42, Return42, x => x, x => x, default));
+
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupJoin<int, int, int, int>(default, Return42, x => x, x => x, (x, y) => x, EqualityComparer<int>.Default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupJoin<int, int, int, int>(Return42, default, x => x, x => x, (x, y) => x, EqualityComparer<int>.Default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupJoin(Return42, Return42, default, x => x, (x, y) => x, EqualityComparer<int>.Default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupJoin(Return42, Return42, x => x, default, (x, y) => x, EqualityComparer<int>.Default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupJoin<int, int, int, int>(Return42, Return42, x => x, x => x, default, EqualityComparer<int>.Default));
         }
 
         [Fact]
-        public void GroupJoin1()
+        public async Task GroupJoin1()
         {
             var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable();
             var ys = new[] { 4, 7, 6, 2, 3, 4, 8, 9 }.ToAsyncEnumerable();
@@ -36,14 +37,14 @@ namespace Tests
             var res = xs.GroupJoin(ys, x => x % 3, y => y % 3, (x, i) => x + " - " + i.Aggregate("", (s, j) => s + j).Result);
 
             var e = res.GetAsyncEnumerator();
-            HasNext(e, "0 - 639");
-            HasNext(e, "1 - 474");
-            HasNext(e, "2 - 28");
-            NoNext(e);
+            await HasNextAsync(e, "0 - 639");
+            await HasNextAsync(e, "1 - 474");
+            await HasNextAsync(e, "2 - 28");
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void GroupJoin2()
+        public async Task GroupJoin2()
         {
             var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable();
             var ys = new[] { 3, 6, 4 }.ToAsyncEnumerable();
@@ -51,10 +52,10 @@ namespace Tests
             var res = xs.GroupJoin(ys, x => x % 3, y => y % 3, (x, i) => x + " - " + i.Aggregate("", (s, j) => s + j).Result);
 
             var e = res.GetAsyncEnumerator();
-            HasNext(e, "0 - 36");
-            HasNext(e, "1 - 4");
-            HasNext(e, "2 - ");
-            NoNext(e);
+            await HasNextAsync(e, "0 - 36");
+            await HasNextAsync(e, "1 - 4");
+            await HasNextAsync(e, "2 - ");
+            await NoNextAsync(e);
         }
 
         [Fact]
@@ -110,7 +111,7 @@ namespace Tests
         }
 
         [Fact]
-        public void GroupJoin7()
+        public async Task GroupJoin7()
         {
             var ex = new Exception("Bang!");
             var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable();
@@ -124,7 +125,7 @@ namespace Tests
             });
 
             var e = res.GetAsyncEnumerator();
-            HasNext(e, "0 - 36");
+            await HasNextAsync(e, "0 - 36");
             AssertThrows(() => e.MoveNextAsync().Wait(WaitTimeoutMs), SingleInnerExceptionMatches(ex));
         }
     }

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

@@ -15,37 +15,37 @@ namespace Tests
         [Fact]
         public void Intersect_Null()
         {
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Intersect(default, Return42));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Intersect(Return42, default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.Intersect(default, Return42));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.Intersect(Return42, default));
 
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Intersect(default, Return42, new Eq()));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Intersect(Return42, default, new Eq()));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.Intersect(default, Return42, new Eq()));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.Intersect(Return42, default, new Eq()));
         }
 
         [Fact]
-        public void Intersect1()
+        public async Task Intersect1()
         {
             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
             var ys = new[] { 3, 5, 1, 4 }.ToAsyncEnumerable();
             var res = xs.Intersect(ys);
 
             var e = res.GetAsyncEnumerator();
-            HasNext(e, 1);
-            HasNext(e, 3);
-            NoNext(e);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 3);
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void Intersect2()
+        public async Task Intersect2()
         {
             var xs = new[] { 1, 2, -3 }.ToAsyncEnumerable();
             var ys = new[] { 3, 5, -1, 4 }.ToAsyncEnumerable();
             var res = xs.Intersect(ys, new Eq());
 
             var e = res.GetAsyncEnumerator();
-            HasNext(e, 1);
-            HasNext(e, -3);
-            NoNext(e);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, -3);
+            await NoNextAsync(e);
         }
 
         [Fact]

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

@@ -15,21 +15,21 @@ namespace Tests
         [Fact]
         public void Join_Null()
         {
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Join<int, int, int, int>(default, Return42, x => x, x => x, (x, y) => x));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Join<int, int, int, int>(Return42, default, x => x, x => x, (x, y) => x));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Join(Return42, Return42, default, x => x, (x, y) => x));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Join(Return42, Return42, x => x, default, (x, y) => x));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Join<int, int, int, int>(Return42, Return42, x => x, x => x, default));
-
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Join<int, int, int, int>(default, Return42, x => x, x => x, (x, y) => x, EqualityComparer<int>.Default));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Join<int, int, int, int>(Return42, default, x => x, x => x, (x, y) => x, EqualityComparer<int>.Default));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Join(Return42, Return42, default, x => x, (x, y) => x, EqualityComparer<int>.Default));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Join(Return42, Return42, x => x, default, (x, y) => x, EqualityComparer<int>.Default));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Join<int, int, int, int>(Return42, Return42, x => x, x => x, default, EqualityComparer<int>.Default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.Join<int, int, int, int>(default, Return42, x => x, x => x, (x, y) => x));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.Join<int, int, int, int>(Return42, default, x => x, x => x, (x, y) => x));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.Join(Return42, Return42, default, x => x, (x, y) => x));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.Join(Return42, Return42, x => x, default, (x, y) => x));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.Join<int, int, int, int>(Return42, Return42, x => x, x => x, default));
+
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.Join<int, int, int, int>(default, Return42, x => x, x => x, (x, y) => x, EqualityComparer<int>.Default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.Join<int, int, int, int>(Return42, default, x => x, x => x, (x, y) => x, EqualityComparer<int>.Default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.Join(Return42, Return42, default, x => x, (x, y) => x, EqualityComparer<int>.Default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.Join(Return42, Return42, x => x, default, (x, y) => x, EqualityComparer<int>.Default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.Join<int, int, int, int>(Return42, Return42, x => x, x => x, default, EqualityComparer<int>.Default));
         }
 
         [Fact]
-        public void Join1()
+        public async Task Join1()
         {
             var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable();
             var ys = new[] { 3, 6, 4 }.ToAsyncEnumerable();
@@ -37,14 +37,14 @@ namespace Tests
             var res = xs.Join(ys, x => x % 3, y => y % 3, (x, y) => x + y);
 
             var e = res.GetAsyncEnumerator();
-            HasNext(e, 0 + 3);
-            HasNext(e, 0 + 6);
-            HasNext(e, 1 + 4);
-            NoNext(e);
+            await HasNextAsync(e, 0 + 3);
+            await HasNextAsync(e, 0 + 6);
+            await HasNextAsync(e, 1 + 4);
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void Join2()
+        public async Task Join2()
         {
             var xs = new[] { 3, 6, 4 }.ToAsyncEnumerable();
             var ys = new[] { 0, 1, 2 }.ToAsyncEnumerable();
@@ -52,14 +52,14 @@ namespace Tests
             var res = xs.Join(ys, x => x % 3, y => y % 3, (x, y) => x + y);
 
             var e = res.GetAsyncEnumerator();
-            HasNext(e, 3 + 0);
-            HasNext(e, 6 + 0);
-            HasNext(e, 4 + 1);
-            NoNext(e);
+            await HasNextAsync(e, 3 + 0);
+            await HasNextAsync(e, 6 + 0);
+            await HasNextAsync(e, 4 + 1);
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void Join3()
+        public async Task Join3()
         {
             var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable();
             var ys = new[] { 3, 6 }.ToAsyncEnumerable();
@@ -67,13 +67,13 @@ namespace Tests
             var res = xs.Join(ys, x => x % 3, y => y % 3, (x, y) => x + y);
 
             var e = res.GetAsyncEnumerator();
-            HasNext(e, 0 + 3);
-            HasNext(e, 0 + 6);
-            NoNext(e);
+            await HasNextAsync(e, 0 + 3);
+            await HasNextAsync(e, 0 + 6);
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void Join4()
+        public async Task Join4()
         {
             var xs = new[] { 3, 6 }.ToAsyncEnumerable();
             var ys = new[] { 0, 1, 2 }.ToAsyncEnumerable();
@@ -81,9 +81,9 @@ namespace Tests
             var res = xs.Join(ys, x => x % 3, y => y % 3, (x, y) => x + y);
 
             var e = res.GetAsyncEnumerator();
-            HasNext(e, 3 + 0);
-            HasNext(e, 6 + 0);
-            NoNext(e);
+            await HasNextAsync(e, 3 + 0);
+            await HasNextAsync(e, 6 + 0);
+            await NoNextAsync(e);
         }
 
         [Fact]
@@ -163,7 +163,7 @@ namespace Tests
         }
 
         [Fact]
-        public void Join11()
+        public async Task Join11()
         {
             var customers = new List<Customer>
             {
@@ -187,17 +187,17 @@ namespace Tests
                                             (c, o) => new CustomerOrder { CustomerId = c.CustomerId, OrderId = o.OrderId });
 
             var e = asyncResult.GetAsyncEnumerator();
-            HasNext(e, new CustomerOrder { CustomerId = "ALFKI", OrderId = 1 });
-            HasNext(e, new CustomerOrder { CustomerId = "ALFKI", OrderId = 2 });
-            HasNext(e, new CustomerOrder { CustomerId = "ALFKI", OrderId = 3 });
-            HasNext(e, new CustomerOrder { CustomerId = "FISSA", OrderId = 4 });
-            HasNext(e, new CustomerOrder { CustomerId = "FISSA", OrderId = 5 });
-            HasNext(e, new CustomerOrder { CustomerId = "FISSA", OrderId = 6 });
-            NoNext(e);
+            await HasNextAsync(e, new CustomerOrder { CustomerId = "ALFKI", OrderId = 1 });
+            await HasNextAsync(e, new CustomerOrder { CustomerId = "ALFKI", OrderId = 2 });
+            await HasNextAsync(e, new CustomerOrder { CustomerId = "ALFKI", OrderId = 3 });
+            await HasNextAsync(e, new CustomerOrder { CustomerId = "FISSA", OrderId = 4 });
+            await HasNextAsync(e, new CustomerOrder { CustomerId = "FISSA", OrderId = 5 });
+            await HasNextAsync(e, new CustomerOrder { CustomerId = "FISSA", OrderId = 6 });
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void Join12()
+        public async Task Join12()
         {
             var customers = new List<Customer>
             {
@@ -220,13 +220,13 @@ namespace Tests
                                             (c, o) => new CustomerOrder { CustomerId = c.CustomerId, OrderId = o.OrderId });
 
             var e = asyncResult.GetAsyncEnumerator();
-            HasNext(e, new CustomerOrder { CustomerId = "ALFKI", OrderId = 1 });
-            HasNext(e, new CustomerOrder { CustomerId = "ALFKI", OrderId = 2 });
-            HasNext(e, new CustomerOrder { CustomerId = "ALFKI", OrderId = 3 });
-            HasNext(e, new CustomerOrder { CustomerId = "FISSA", OrderId = 4 });
-            HasNext(e, new CustomerOrder { CustomerId = "FISSA", OrderId = 5 });
-            HasNext(e, new CustomerOrder { CustomerId = "FISSA", OrderId = 6 });
-            NoNext(e);
+            await HasNextAsync(e, new CustomerOrder { CustomerId = "ALFKI", OrderId = 1 });
+            await HasNextAsync(e, new CustomerOrder { CustomerId = "ALFKI", OrderId = 2 });
+            await HasNextAsync(e, new CustomerOrder { CustomerId = "ALFKI", OrderId = 3 });
+            await HasNextAsync(e, new CustomerOrder { CustomerId = "FISSA", OrderId = 4 });
+            await HasNextAsync(e, new CustomerOrder { CustomerId = "FISSA", OrderId = 5 });
+            await HasNextAsync(e, new CustomerOrder { CustomerId = "FISSA", OrderId = 6 });
+            await NoNextAsync(e);
         }
 
         public class Customer

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

@@ -5,6 +5,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading.Tasks;
 using Xunit;
 
 namespace Tests
@@ -14,19 +15,19 @@ namespace Tests
         [Fact]
         public void OfType_Null()
         {
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.OfType<int>(default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.OfType<int>(default));
         }
 
         [Fact]
-        public void OfType1()
+        public async Task OfType1Async()
         {
             var xs = new object[] { 1, 1.2, true, 4, "" }.ToAsyncEnumerable();
             var ys = xs.OfType<int>();
 
             var e = ys.GetAsyncEnumerator();
-            HasNext(e, 1);
-            HasNext(e, 4);
-            NoNext(e);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 4);
+            await NoNextAsync(e);
         }
     }
 }

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

@@ -15,43 +15,43 @@ namespace Tests
         [Fact]
         public void OrderBy_Null()
         {
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.OrderBy<int, int>(default, x => x));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.OrderBy(Return42, default(Func<int, int>)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.OrderBy<int, int>(default, x => x));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.OrderBy(Return42, default(Func<int, int>)));
 
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.OrderBy<int, int>(default, x => x, Comparer<int>.Default));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.OrderBy(Return42, default(Func<int, int>), Comparer<int>.Default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.OrderBy<int, int>(default, x => x, Comparer<int>.Default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.OrderBy(Return42, default(Func<int, int>), Comparer<int>.Default));
 
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.OrderByDescending<int, int>(default, x => x));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.OrderByDescending(Return42, default(Func<int, int>)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.OrderByDescending<int, int>(default, x => x));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.OrderByDescending(Return42, default(Func<int, int>)));
 
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.OrderByDescending<int, int>(default, x => x, Comparer<int>.Default));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.OrderByDescending(Return42, default(Func<int, int>), Comparer<int>.Default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.OrderByDescending<int, int>(default, x => x, Comparer<int>.Default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.OrderByDescending(Return42, default(Func<int, int>), Comparer<int>.Default));
 
             var xs = Return42.OrderBy(x => x);
 
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ThenBy<int, int>(default, x => x));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ThenBy(xs, default(Func<int, int>)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.ThenBy<int, int>(default, x => x));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.ThenBy(xs, default(Func<int, int>)));
 
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ThenBy<int, int>(default, x => x, Comparer<int>.Default));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ThenBy(xs, default(Func<int, int>), Comparer<int>.Default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.ThenBy<int, int>(default, x => x, Comparer<int>.Default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.ThenBy(xs, default(Func<int, int>), Comparer<int>.Default));
 
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ThenByDescending<int, int>(default, x => x));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ThenByDescending(xs, default(Func<int, int>)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.ThenByDescending<int, int>(default, x => x));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.ThenByDescending(xs, default(Func<int, int>)));
 
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ThenByDescending<int, int>(default, x => x, Comparer<int>.Default));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ThenByDescending(xs, default(Func<int, int>), Comparer<int>.Default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.ThenByDescending<int, int>(default, x => x, Comparer<int>.Default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.ThenByDescending(xs, default(Func<int, int>), Comparer<int>.Default));
         }
 
         [Fact]
-        public void OrderBy1()
+        public async Task OrderBy1()
         {
             var xs = new[] { 2, 6, 1, 5, 7, 8, 9, 3, 4, 0 }.ToAsyncEnumerable();
             var ys = xs.OrderBy(x => x);
 
             var e = ys.GetAsyncEnumerator();
             for (var i = 0; i < 10; i++)
-                HasNext(e, i);
-            NoNext(e);
+                await HasNextAsync(e, i);
+            await NoNextAsync(e);
         }
 
         [Fact]
@@ -86,15 +86,15 @@ namespace Tests
         }
 
         [Fact]
-        public void OrderByDescending1()
+        public async Task OrderByDescending1()
         {
             var xs = new[] { 2, 6, 1, 5, 7, 8, 9, 3, 4, 0 }.ToAsyncEnumerable();
             var ys = xs.OrderByDescending(x => x);
 
             var e = ys.GetAsyncEnumerator();
             for (var i = 9; i >= 0; i--)
-                HasNext(e, i);
-            NoNext(e);
+                await HasNextAsync(e, i);
+            await NoNextAsync(e);
         }
 
         [Fact]

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

@@ -15,11 +15,11 @@ namespace Tests
         [Fact]
         public void Prepend_Null()
         {
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Prepend(default, 42));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.Prepend(default, 42));
         }
 
         [Fact]
-        public void Prepend1()
+        public async Task Prepend1Async()
         {
             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
 
@@ -27,11 +27,11 @@ namespace Tests
 
             var e = res.GetAsyncEnumerator();
 
-            HasNext(e, 4);
-            HasNext(e, 1);
-            HasNext(e, 2);
-            HasNext(e, 3);
-            NoNext(e);
+            await HasNextAsync(e, 4);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 3);
+            await NoNextAsync(e);
         }
 
         [Fact]
@@ -115,7 +115,7 @@ namespace Tests
         }
 
         [Fact]
-        public void PrependN1()
+        public async Task PrependN1Async()
         {
             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
 
@@ -125,13 +125,13 @@ namespace Tests
 
             var e = res.GetAsyncEnumerator();
 
-            HasNext(e, 6);
-            HasNext(e, 5);
-            HasNext(e, 4);
-            HasNext(e, 1);
-            HasNext(e, 2);
-            HasNext(e, 3);
-            NoNext(e);
+            await HasNextAsync(e, 6);
+            await HasNextAsync(e, 5);
+            await HasNextAsync(e, 4);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 3);
+            await NoNextAsync(e);
         }
 
         [Fact]

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

@@ -4,6 +4,7 @@
 
 using System;
 using System.Linq;
+using System.Threading.Tasks;
 using Xunit;
 
 namespace Tests
@@ -13,30 +14,30 @@ namespace Tests
         [Fact]
         public void Range_Null()
         {
-            AssertThrows<ArgumentOutOfRangeException>(() => AsyncEnumerable.Range(0, -1));
+            Assert.Throws<ArgumentOutOfRangeException>(() => AsyncEnumerable.Range(0, -1));
         }
 
         [Fact]
-        public void Range1()
+        public async Task Range1Async()
         {
             var xs = AsyncEnumerable.Range(2, 5);
 
             var e = xs.GetAsyncEnumerator();
-            HasNext(e, 2);
-            HasNext(e, 3);
-            HasNext(e, 4);
-            HasNext(e, 5);
-            HasNext(e, 6);
-            NoNext(e);
+            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 Range2()
+        public async Task Range2Async()
         {
             var xs = AsyncEnumerable.Range(2, 0);
 
             var e = xs.GetAsyncEnumerator();
-            NoNext(e);
+            await NoNextAsync(e);
         }
     }
 }

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

@@ -14,30 +14,30 @@ namespace Tests
         [Fact]
         public void Repeat_Null()
         {
-            AssertThrows<ArgumentOutOfRangeException>(() => AsyncEnumerable.Repeat(0, -1));
+            Assert.Throws<ArgumentOutOfRangeException>(() => AsyncEnumerable.Repeat(0, -1));
         }
 
         [Fact]
-        public void Repeat1()
+        public async Task Repeat1Async()
         {
             var xs = AsyncEnumerable.Repeat(2, 5);
 
             var e = xs.GetAsyncEnumerator();
-            HasNext(e, 2);
-            HasNext(e, 2);
-            HasNext(e, 2);
-            HasNext(e, 2);
-            HasNext(e, 2);
-            NoNext(e);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 2);
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void Repeat2()
+        public async Task Repeat2Async()
         {
             var xs = AsyncEnumerable.Repeat(2, 0);
 
             var e = xs.GetAsyncEnumerator();
-            NoNext(e);
+            await NoNextAsync(e);
         }
     }
 }

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

@@ -15,41 +15,41 @@ namespace Tests
         [Fact]
         public void Reverse_Null()
         {
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Reverse<int>(default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.Reverse<int>(default));
         }
 
         [Fact]
-        public void Reverse1()
+        public async Task Reverse1Async()
         {
             var xs = AsyncEnumerable.Empty<int>();
             var ys = xs.Reverse();
 
             var e = ys.GetAsyncEnumerator();
-            NoNext(e);
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void Reverse2()
+        public async Task Reverse2Async()
         {
             var xs = Return42;
             var ys = xs.Reverse();
 
             var e = ys.GetAsyncEnumerator();
-            HasNext(e, 42);
-            NoNext(e);
+            await HasNextAsync(e, 42);
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void Reverse3()
+        public async Task Reverse3Async()
         {
             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
             var ys = xs.Reverse();
 
             var e = ys.GetAsyncEnumerator();
-            HasNext(e, 3);
-            HasNext(e, 2);
-            HasNext(e, 1);
-            NoNext(e);
+            await HasNextAsync(e, 3);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 1);
+            await NoNextAsync(e);
         }
 
         [Fact]

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

@@ -15,36 +15,36 @@ namespace Tests
         [Fact]
         public void Select_Null()
         {
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Select<int, int>(default, x => x));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Select<int, int>(default, (x, i) => x));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Select(Return42, default(Func<int, int>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Select(Return42, default(Func<int, int, int>)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.Select<int, int>(default, x => x));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.Select<int, int>(default, (x, i) => x));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.Select(Return42, default(Func<int, int>)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.Select(Return42, default(Func<int, int, int>)));
         }
 
         [Fact]
-        public void Select1()
+        public async Task Select1()
         {
             var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable();
             var ys = xs.Select(x => (char)('a' + x));
 
             var e = ys.GetAsyncEnumerator();
-            HasNext(e, 'a');
-            HasNext(e, 'b');
-            HasNext(e, 'c');
-            NoNext(e);
+            await HasNextAsync(e, 'a');
+            await HasNextAsync(e, 'b');
+            await HasNextAsync(e, 'c');
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void Select2()
+        public async Task Select2()
         {
             var xs = new[] { 8, 5, 7 }.ToAsyncEnumerable();
             var ys = xs.Select((x, i) => (char)('a' + i));
 
             var e = ys.GetAsyncEnumerator();
-            HasNext(e, 'a');
-            HasNext(e, 'b');
-            HasNext(e, 'c');
-            NoNext(e);
+            await HasNextAsync(e, 'a');
+            await HasNextAsync(e, 'b');
+            await HasNextAsync(e, 'c');
+            await NoNextAsync(e);
         }
 
         [Fact]
@@ -68,16 +68,16 @@ namespace Tests
         }
 
         [Fact]
-        public void Select5()
+        public async Task Select5()
         {
             var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable();
             var ys = xs.Select(i => i + 3).Select(x => (char)('a' + x));
 
             var e = ys.GetAsyncEnumerator();
-            HasNext(e, 'd');
-            HasNext(e, 'e');
-            HasNext(e, 'f');
-            NoNext(e);
+            await HasNextAsync(e, 'd');
+            await HasNextAsync(e, 'e');
+            await HasNextAsync(e, 'f');
+            await NoNextAsync(e);
         }
 
         [Fact]

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

@@ -15,37 +15,37 @@ namespace Tests
         [Fact]
         public void SelectMany_Null()
         {
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SelectMany(default, default(Func<int, IAsyncEnumerable<int>>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SelectMany(default, default(Func<int, int, IAsyncEnumerable<int>>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SelectMany(Return42, default(Func<int, IAsyncEnumerable<int>>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SelectMany(Return42, default(Func<int, int, IAsyncEnumerable<int>>)));
-
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SelectMany(default, default(Func<int, IAsyncEnumerable<int>>), (x, y) => x));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SelectMany(default, default(Func<int, int, IAsyncEnumerable<int>>), (x, y) => x));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SelectMany(Return42, default(Func<int, IAsyncEnumerable<int>>), (x, y) => x));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SelectMany(Return42, default(Func<int, int, IAsyncEnumerable<int>>), (x, y) => x));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SelectMany(Return42, x => default, default(Func<int, int, int>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SelectMany(Return42, (x, i) => default, default(Func<int, int, int>)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.SelectMany(default, default(Func<int, IAsyncEnumerable<int>>)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.SelectMany(default, default(Func<int, int, IAsyncEnumerable<int>>)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.SelectMany(Return42, default(Func<int, IAsyncEnumerable<int>>)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.SelectMany(Return42, default(Func<int, int, IAsyncEnumerable<int>>)));
+
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.SelectMany(default, default(Func<int, IAsyncEnumerable<int>>), (x, y) => x));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.SelectMany(default, default(Func<int, int, IAsyncEnumerable<int>>), (x, y) => x));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.SelectMany(Return42, default(Func<int, IAsyncEnumerable<int>>), (x, y) => x));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.SelectMany(Return42, default(Func<int, int, IAsyncEnumerable<int>>), (x, y) => x));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.SelectMany(Return42, x => default, default(Func<int, int, int>)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.SelectMany(Return42, (x, i) => default, default(Func<int, int, int>)));
         }
 
         [Fact]
-        public void SelectMany1()
+        public async Task SelectMany1Async()
         {
             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
             var ys = xs.SelectMany(x => Enumerable.Range(0, x).ToAsyncEnumerable());
 
             var e = ys.GetAsyncEnumerator();
-            HasNext(e, 0);
-            HasNext(e, 0);
-            HasNext(e, 1);
-            HasNext(e, 0);
-            HasNext(e, 1);
-            HasNext(e, 2);
-            NoNext(e);
+            await HasNextAsync(e, 0);
+            await HasNextAsync(e, 0);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 0);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 2);
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void SelectMany2()
+        public async Task SelectMany2Async()
         {
             var ex = new Exception("Bang");
             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
@@ -58,9 +58,9 @@ namespace Tests
             });
 
             var e = ys.GetAsyncEnumerator();
-            HasNext(e, 0);
-            HasNext(e, 0);
-            HasNext(e, 1);
+            await HasNextAsync(e, 0);
+            await HasNextAsync(e, 0);
+            await HasNextAsync(e, 1);
             AssertThrows(() => e.MoveNextAsync().Wait(WaitTimeoutMs), SingleInnerExceptionMatches(ex));
         }
 
@@ -76,7 +76,7 @@ namespace Tests
         }
 
         [Fact]
-        public void SelectMany4()
+        public async Task SelectMany4Async()
         {
             var ex = new Exception("Bang");
             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
@@ -89,30 +89,30 @@ namespace Tests
             });
 
             var e = ys.GetAsyncEnumerator();
-            HasNext(e, 0);
-            HasNext(e, 0);
-            HasNext(e, 1);
+            await HasNextAsync(e, 0);
+            await HasNextAsync(e, 0);
+            await HasNextAsync(e, 1);
             AssertThrows(() => e.MoveNextAsync().Wait(WaitTimeoutMs), SingleInnerExceptionMatches(ex));
         }
 
         [Fact]
-        public void SelectMany5()
+        public async Task SelectMany5Async()
         {
             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
             var ys = xs.SelectMany((x, i) => Enumerable.Range(i + 5, x).ToAsyncEnumerable());
 
             var e = ys.GetAsyncEnumerator();
-            HasNext(e, 5);
-            HasNext(e, 6);
-            HasNext(e, 7);
-            HasNext(e, 7);
-            HasNext(e, 8);
-            HasNext(e, 9);
-            NoNext(e);
+            await HasNextAsync(e, 5);
+            await HasNextAsync(e, 6);
+            await HasNextAsync(e, 7);
+            await HasNextAsync(e, 7);
+            await HasNextAsync(e, 8);
+            await HasNextAsync(e, 9);
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void SelectMany6()
+        public async Task SelectMany6Async()
         {
             var ex = new Exception("Bang");
             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
@@ -125,9 +125,9 @@ namespace Tests
             });
 
             var e = ys.GetAsyncEnumerator();
-            HasNext(e, 0);
-            HasNext(e, 0);
-            HasNext(e, 1);
+            await HasNextAsync(e, 0);
+            await HasNextAsync(e, 0);
+            await HasNextAsync(e, 1);
             AssertThrows(() => e.MoveNextAsync().Wait(WaitTimeoutMs), SingleInnerExceptionMatches(ex));
         }
 
@@ -143,7 +143,7 @@ namespace Tests
         }
 
         [Fact]
-        public void SelectMany8()
+        public async Task SelectMany8Async()
         {
             var ex = new Exception("Bang");
             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
@@ -156,46 +156,46 @@ namespace Tests
             });
 
             var e = ys.GetAsyncEnumerator();
-            HasNext(e, 0);
-            HasNext(e, 0);
-            HasNext(e, 1);
+            await HasNextAsync(e, 0);
+            await HasNextAsync(e, 0);
+            await HasNextAsync(e, 1);
             AssertThrows(() => e.MoveNextAsync().Wait(WaitTimeoutMs), SingleInnerExceptionMatches(ex));
         }
 
         [Fact]
-        public void SelectMany9()
+        public async Task SelectMany9Async()
         {
             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
             var ys = xs.SelectMany(x => Enumerable.Range(3, x).ToAsyncEnumerable(), (x, y) => x * y);
 
             var e = ys.GetAsyncEnumerator();
-            HasNext(e, 3);
-            HasNext(e, 6);
-            HasNext(e, 8);
-            HasNext(e, 9);
-            HasNext(e, 12);
-            HasNext(e, 15);
-            NoNext(e);
+            await HasNextAsync(e, 3);
+            await HasNextAsync(e, 6);
+            await HasNextAsync(e, 8);
+            await HasNextAsync(e, 9);
+            await HasNextAsync(e, 12);
+            await HasNextAsync(e, 15);
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void SelectMany10()
+        public async Task SelectMany10Async()
         {
             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
             var ys = xs.SelectMany((x, i) => Enumerable.Range(i + 3, x).ToAsyncEnumerable(), (x, y) => x * y);
 
             var e = ys.GetAsyncEnumerator();
-            HasNext(e, 3);
-            HasNext(e, 8);
-            HasNext(e, 10);
-            HasNext(e, 15);
-            HasNext(e, 18);
-            HasNext(e, 21);
-            NoNext(e);
+            await HasNextAsync(e, 3);
+            await HasNextAsync(e, 8);
+            await HasNextAsync(e, 10);
+            await HasNextAsync(e, 15);
+            await HasNextAsync(e, 18);
+            await HasNextAsync(e, 21);
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void SelectMany11()
+        public async Task SelectMany11Async()
         {
             var ex = new Exception("Bang");
             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
@@ -207,15 +207,15 @@ namespace Tests
             });
 
             var e = ys.GetAsyncEnumerator();
-            HasNext(e, 3);
-            HasNext(e, 6);
-            HasNext(e, 8);
-            HasNext(e, 9);
+            await HasNextAsync(e, 3);
+            await HasNextAsync(e, 6);
+            await HasNextAsync(e, 8);
+            await HasNextAsync(e, 9);
             AssertThrows(() => e.MoveNextAsync().Wait(WaitTimeoutMs), SingleInnerExceptionMatches(ex));
         }
 
         [Fact]
-        public void SelectMany12()
+        public async Task SelectMany12Async()
         {
             var ex = new Exception("Bang");
             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
@@ -227,9 +227,9 @@ namespace Tests
             });
 
             var e = ys.GetAsyncEnumerator();
-            HasNext(e, 3);
-            HasNext(e, 8);
-            HasNext(e, 10);
+            await HasNextAsync(e, 3);
+            await HasNextAsync(e, 8);
+            await HasNextAsync(e, 10);
             AssertThrows(() => e.MoveNextAsync().Wait(WaitTimeoutMs), SingleInnerExceptionMatches(ex));
         }
 

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

@@ -15,7 +15,7 @@ namespace Tests
         [Fact]
         public void Skip_Null()
         {
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Skip<int>(default, 5));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.Skip<int>(default, 5));
         }
 
         //[Fact]
@@ -25,43 +25,43 @@ namespace Tests
         //    var ys = xs.Skip(-2);
 
         //    var e = ys.GetEnumerator();
-        //    NoNext(e);
+        //    await NoNextAsync(e);
         //}
 
         [Fact]
-        public void Skip1()
+        public async Task Skip1()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
             var ys = xs.Skip(2);
 
             var e = ys.GetAsyncEnumerator();
-            HasNext(e, 3);
-            HasNext(e, 4);
-            NoNext(e);
+            await HasNextAsync(e, 3);
+            await HasNextAsync(e, 4);
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void Skip2()
+        public async Task Skip2()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
             var ys = xs.Skip(10);
 
             var e = ys.GetAsyncEnumerator();
-            NoNext(e);
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void Skip3()
+        public async Task Skip3()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
             var ys = xs.Skip(0);
 
             var e = ys.GetAsyncEnumerator();
-            HasNext(e, 1);
-            HasNext(e, 2);
-            HasNext(e, 3);
-            HasNext(e, 4);
-            NoNext(e);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 3);
+            await HasNextAsync(e, 4);
+            await NoNextAsync(e);
         }
 
         [Fact]

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

@@ -15,27 +15,27 @@ namespace Tests
         [Fact]
         public void SkipLast_Null()
         {
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SkipLast(default(IAsyncEnumerable<int>), 5));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.SkipLast(default(IAsyncEnumerable<int>), 5));
         }
 
         [Fact]
-        public void SkipLast1()
+        public async Task SkipLast1Async()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().SkipLast(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 SkipLast2()
+        public async Task SkipLast2Async()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().SkipLast(5);
 
             var e = xs.GetAsyncEnumerator();
-            NoNext(e);
+            await NoNextAsync(e);
         }
 
         [Fact]
@@ -47,17 +47,17 @@ namespace Tests
         }
 
         [Fact]
-        public void SkipLast4()
+        public async Task SkipLast4Async()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().SkipLast(0);
 
             var e = xs.GetAsyncEnumerator();
 
-            HasNext(e, 1);
-            HasNext(e, 2);
-            HasNext(e, 3);
-            HasNext(e, 4);
-            NoNext(e);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 3);
+            await HasNextAsync(e, 4);
+            await NoNextAsync(e);
         }
     }
 }

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

@@ -15,61 +15,61 @@ namespace Tests
         [Fact]
         public void SkipWhile_Null()
         {
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SkipWhile<int>(default, x => true));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SkipWhile<int>(default, (x, i) => true));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SkipWhile(Return42, default(Func<int, bool>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SkipWhile(Return42, default(Func<int, int, bool>)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.SkipWhile<int>(default, x => true));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.SkipWhile<int>(default, (x, i) => true));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.SkipWhile(Return42, default(Func<int, bool>)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.SkipWhile(Return42, default(Func<int, int, bool>)));
         }
 
         [Fact]
-        public void SkipWhile1()
+        public async Task SkipWhile1Async()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
             var ys = xs.SkipWhile(x => x < 3);
 
             var e = ys.GetAsyncEnumerator();
-            HasNext(e, 3);
-            HasNext(e, 4);
-            NoNext(e);
+            await HasNextAsync(e, 3);
+            await HasNextAsync(e, 4);
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void SkipWhile2()
+        public async Task SkipWhile2Async()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
             var ys = xs.SkipWhile(x => false);
 
             var e = ys.GetAsyncEnumerator();
-            HasNext(e, 1);
-            HasNext(e, 2);
-            HasNext(e, 3);
-            HasNext(e, 4);
-            NoNext(e);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 3);
+            await HasNextAsync(e, 4);
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void SkipWhile3()
+        public async Task SkipWhile3Async()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
             var ys = xs.SkipWhile(x => true);
 
             var e = ys.GetAsyncEnumerator();
-            NoNext(e);
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void SkipWhile4()
+        public async Task SkipWhile4Async()
         {
             var xs = new[] { 1, 2, 3, 4, 3, 2, 1 }.ToAsyncEnumerable();
             var ys = xs.SkipWhile(x => x < 3);
 
             var e = ys.GetAsyncEnumerator();
-            HasNext(e, 3);
-            HasNext(e, 4);
-            HasNext(e, 3);
-            HasNext(e, 2);
-            HasNext(e, 1);
-            NoNext(e);
+            await HasNextAsync(e, 3);
+            await HasNextAsync(e, 4);
+            await HasNextAsync(e, 3);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 1);
+            await NoNextAsync(e);
         }
 
         [Fact]
@@ -84,39 +84,39 @@ namespace Tests
         }
 
         [Fact]
-        public void SkipWhile6()
+        public async Task SkipWhile6Async()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
             var ys = xs.SkipWhile((x, i) => i < 2);
 
             var e = ys.GetAsyncEnumerator();
-            HasNext(e, 3);
-            HasNext(e, 4);
-            NoNext(e);
+            await HasNextAsync(e, 3);
+            await HasNextAsync(e, 4);
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void SkipWhile7()
+        public async Task SkipWhile7Async()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
             var ys = xs.SkipWhile((x, i) => false);
 
             var e = ys.GetAsyncEnumerator();
-            HasNext(e, 1);
-            HasNext(e, 2);
-            HasNext(e, 3);
-            HasNext(e, 4);
-            NoNext(e);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 3);
+            await HasNextAsync(e, 4);
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void SkipWhile8()
+        public async Task SkipWhile8Async()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
             var ys = xs.SkipWhile((x, i) => true);
 
             var e = ys.GetAsyncEnumerator();
-            NoNext(e);
+            await NoNextAsync(e);
         }
 
         [Fact]

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

@@ -15,53 +15,53 @@ namespace Tests
         [Fact]
         public void Take_Null()
         {
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Take<int>(default, 5));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.Take<int>(default, 5));
         }
 
         [Fact]
-        public void Take0()
+        public async Task Take0Async()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
             var ys = xs.Take(-2);
 
             var e = ys.GetAsyncEnumerator();
-            NoNext(e);
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void Take1()
+        public async Task Take1Async()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
             var ys = xs.Take(2);
 
             var e = ys.GetAsyncEnumerator();
-            HasNext(e, 1);
-            HasNext(e, 2);
-            NoNext(e);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 2);
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void Take2()
+        public async Task Take2Async()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
             var ys = xs.Take(10);
 
             var e = ys.GetAsyncEnumerator();
-            HasNext(e, 1);
-            HasNext(e, 2);
-            HasNext(e, 3);
-            HasNext(e, 4);
-            NoNext(e);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 3);
+            await HasNextAsync(e, 4);
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void Take3()
+        public async Task Take3Async()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
             var ys = xs.Take(0);
 
             var e = ys.GetAsyncEnumerator();
-            NoNext(e);
+            await NoNextAsync(e);
         }
 
         [Fact]

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

@@ -15,40 +15,40 @@ namespace Tests
         [Fact]
         public void TakeLast_Null()
         {
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.TakeLast(default(IAsyncEnumerable<int>), 5));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.TakeLast(default(IAsyncEnumerable<int>), 5));
         }
 
         [Fact]
-        public void TakeLast0()
+        public async Task TakeLast0()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().TakeLast(-2);
 
             var e = xs.GetAsyncEnumerator();
-            NoNext(e);
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void TakeLast1()
+        public async Task TakeLast1()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().TakeLast(2);
 
             var e = xs.GetAsyncEnumerator();
-            HasNext(e, 3);
-            HasNext(e, 4);
-            NoNext(e);
+            await HasNextAsync(e, 3);
+            await HasNextAsync(e, 4);
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void TakeLast2()
+        public async Task TakeLast2()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().TakeLast(5);
 
             var e = xs.GetAsyncEnumerator();
-            HasNext(e, 1);
-            HasNext(e, 2);
-            HasNext(e, 3);
-            HasNext(e, 4);
-            NoNext(e);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 3);
+            await HasNextAsync(e, 4);
+            await NoNextAsync(e);
         }
 
         [Fact]
@@ -60,13 +60,13 @@ namespace Tests
         }
 
         [Fact]
-        public void TakeLast_BugFix_TakeLast_Zero_TakesForever()
+        public async Task TakeLast_BugFix_TakeLast_Zero_TakesForever()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().TakeLast(0);
 
             var e = xs.GetAsyncEnumerator();
 
-            NoNext(e);
+            await NoNextAsync(e);
         }
     }
 }

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

@@ -15,58 +15,58 @@ namespace Tests
         [Fact]
         public void TakeWhile_Null()
         {
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.TakeWhile<int>(default, x => true));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.TakeWhile<int>(default, (x, i) => true));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.TakeWhile(Return42, default(Func<int, bool>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.TakeWhile(Return42, default(Func<int, int, bool>)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.TakeWhile<int>(default, x => true));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.TakeWhile<int>(default, (x, i) => true));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.TakeWhile(Return42, default(Func<int, bool>)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.TakeWhile(Return42, default(Func<int, int, bool>)));
         }
 
         [Fact]
-        public void TakeWhile1()
+        public async Task TakeWhile1Async()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
             var ys = xs.TakeWhile(x => x < 3);
 
             var e = ys.GetAsyncEnumerator();
-            HasNext(e, 1);
-            HasNext(e, 2);
-            NoNext(e);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 2);
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void TakeWhile2()
+        public async Task TakeWhile2Async()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
             var ys = xs.TakeWhile(x => false);
 
             var e = ys.GetAsyncEnumerator();
-            NoNext(e);
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void TakeWhile3()
+        public async Task TakeWhile3Async()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
             var ys = xs.TakeWhile(x => true);
 
             var e = ys.GetAsyncEnumerator();
-            HasNext(e, 1);
-            HasNext(e, 2);
-            HasNext(e, 3);
-            HasNext(e, 4);
-            NoNext(e);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 3);
+            await HasNextAsync(e, 4);
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void TakeWhile4()
+        public async Task TakeWhile4Async()
         {
             var xs = new[] { 1, 2, 3, 4, 3, 2, 1 }.ToAsyncEnumerable();
             var ys = xs.TakeWhile(x => x < 3);
 
             var e = ys.GetAsyncEnumerator();
-            HasNext(e, 1);
-            HasNext(e, 2);
-            NoNext(e);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 2);
+            await NoNextAsync(e);
         }
 
         [Fact]
@@ -81,39 +81,39 @@ namespace Tests
         }
 
         [Fact]
-        public void TakeWhile6()
+        public async Task TakeWhile6Async()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
             var ys = xs.TakeWhile((x, i) => i < 2);
 
             var e = ys.GetAsyncEnumerator();
-            HasNext(e, 1);
-            HasNext(e, 2);
-            NoNext(e);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 2);
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void TakeWhile7()
+        public async Task TakeWhile7Async()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
             var ys = xs.TakeWhile((x, i) => false);
 
             var e = ys.GetAsyncEnumerator();
-            NoNext(e);
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void TakeWhile8()
+        public async Task TakeWhile8Async()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
             var ys = xs.TakeWhile((x, i) => true);
 
             var e = ys.GetAsyncEnumerator();
-            HasNext(e, 1);
-            HasNext(e, 2);
-            HasNext(e, 3);
-            HasNext(e, 4);
-            NoNext(e);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 3);
+            await HasNextAsync(e, 4);
+            await NoNextAsync(e);
         }
 
         [Fact]

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

@@ -13,7 +13,7 @@ namespace Tests
         [Fact]
         public void Throw_Null()
         {
-            AssertThrows<ArgumentNullException>(() => Throw<int>(default));
+            Assert.Throws<ArgumentNullException>(() => Throw<int>(default));
         }
 
         [Fact]

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

@@ -15,30 +15,30 @@ namespace Tests
         [Fact]
         public void ToAsyncEnumerable_Null()
         {
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToAsyncEnumerable(default(IEnumerable<int>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToAsyncEnumerable(default(IObservable<int>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToAsyncEnumerable(default(Task<int>)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.ToAsyncEnumerable(default(IEnumerable<int>)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.ToAsyncEnumerable(default(IObservable<int>)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.ToAsyncEnumerable(default(Task<int>)));
         }
 
         [Fact]
-        public void ToAsyncEnumerable1()
+        public async Task ToAsyncEnumerable1Async()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
             var e = xs.GetAsyncEnumerator();
-            HasNext(e, 1);
-            HasNext(e, 2);
-            HasNext(e, 3);
-            HasNext(e, 4);
-            NoNext(e);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 3);
+            await HasNextAsync(e, 4);
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void ToAsyncEnumerable2()
+        public async Task ToAsyncEnumerable2Async()
         {
             var ex = new Exception("Bang");
             var xs = ToAsyncEnumerable_Sequence(ex).ToAsyncEnumerable();
             var e = xs.GetAsyncEnumerator();
-            HasNext(e, 42);
+            await HasNextAsync(e, 42);
             AssertThrows(() => e.MoveNextAsync().Wait(WaitTimeoutMs), (Exception ex_) => ((AggregateException)ex_).InnerExceptions.Single() == ex);
         }
 
@@ -49,7 +49,7 @@ namespace Tests
         }
 
         [Fact]
-        public void ToAsyncEnumerable3()
+        public async Task ToAsyncEnumerable3Async()
         {
             var subscribed = false;
 
@@ -69,8 +69,8 @@ namespace Tests
 
             Assert.True(subscribed);
 
-            HasNext(e, 42);
-            NoNext(e);
+            await HasNextAsync(e, 42);
+            await NoNextAsync(e);
         }
 
         [Fact]
@@ -98,17 +98,17 @@ namespace Tests
         }
 
         [Fact]
-        public void ToAsyncEnumerable5()
+        public async Task ToAsyncEnumerable5Async()
         {
             var set = new HashSet<int>(new[] { 1, 2, 3, 4 });
 
             var xs = set.ToAsyncEnumerable();
             var e = xs.GetAsyncEnumerator();
-            HasNext(e, 1);
-            HasNext(e, 2);
-            HasNext(e, 3);
-            HasNext(e, 4);
-            NoNext(e);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 3);
+            await HasNextAsync(e, 4);
+            await NoNextAsync(e);
         }
 
         [Fact]

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

@@ -13,7 +13,7 @@ namespace Tests
         [Fact]
         public void ToEnumerable_Null()
         {
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToEnumerable<int>(null));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.ToEnumerable<int>(null));
         }
 
         [Fact]

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

@@ -16,7 +16,7 @@ namespace Tests
         [Fact]
         public void ToObservable_Null()
         {
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToObservable<int>(null));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.ToObservable<int>(null));
         }
 
         [Fact]

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

@@ -5,6 +5,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading.Tasks;
 using Xunit;
 
 namespace Tests
@@ -14,46 +15,46 @@ namespace Tests
         [Fact]
         public void Union_Null()
         {
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Union(default, Return42));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.Union(default, Return42));
 
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Union(default, Return42, new Eq()));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Union(Return42, default, new Eq()));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.Union(default, Return42, new Eq()));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.Union(Return42, default, new Eq()));
         }
 
         [Fact]
-        public void Union1()
+        public async Task Union1()
         {
             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
             var ys = new[] { 3, 5, 1, 4 }.ToAsyncEnumerable();
             var res = xs.Union(ys);
 
             var e = res.GetAsyncEnumerator();
-            HasNext(e, 1);
-            HasNext(e, 2);
-            HasNext(e, 3);
-            HasNext(e, 5);
-            HasNext(e, 4);
-            NoNext(e);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 3);
+            await HasNextAsync(e, 5);
+            await HasNextAsync(e, 4);
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void Union2()
+        public async Task Union2()
         {
             var xs = new[] { 1, 2, -3 }.ToAsyncEnumerable();
             var ys = new[] { 3, 5, -1, 4 }.ToAsyncEnumerable();
             var res = xs.Union(ys, new Eq());
 
             var e = res.GetAsyncEnumerator();
-            HasNext(e, 1);
-            HasNext(e, 2);
-            HasNext(e, -3);
-            HasNext(e, 5);
-            HasNext(e, 4);
-            NoNext(e);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, -3);
+            await HasNextAsync(e, 5);
+            await HasNextAsync(e, 4);
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void Union3()
+        public async Task Union3()
         {
             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
             var ys = new[] { 3, 5, 1, 4 }.ToAsyncEnumerable();
@@ -61,14 +62,14 @@ namespace Tests
             var res = xs.Union(ys).Union(zs);
 
             var e = res.GetAsyncEnumerator();
-            HasNext(e, 1);
-            HasNext(e, 2);
-            HasNext(e, 3);
-            HasNext(e, 5);
-            HasNext(e, 4);
-            HasNext(e, 7);
-            HasNext(e, 8);
-            NoNext(e);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 3);
+            await HasNextAsync(e, 5);
+            await HasNextAsync(e, 4);
+            await HasNextAsync(e, 7);
+            await HasNextAsync(e, 8);
+            await NoNextAsync(e);
         }
 
         private sealed class Eq : IEqualityComparer<int>

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

@@ -15,66 +15,66 @@ namespace Tests
         [Fact]
         public void Where_Null()
         {
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Where<int>(default, x => true));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Where<int>(default, (x, i) => true));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Where(Return42, default(Func<int, bool>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Where(Return42, default(Func<int, int, bool>)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.Where<int>(default, x => true));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.Where<int>(default, (x, i) => true));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.Where(Return42, default(Func<int, bool>)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.Where(Return42, default(Func<int, int, bool>)));
         }
 
         [Fact]
-        public void Where1()
+        public async Task Where1()
         {
             var xs = new[] { 8, 5, 7, 4, 6, 9, 2, 1, 0 }.ToAsyncEnumerable();
             var ys = xs.Where(x => x % 2 == 0);
             var e = ys.GetAsyncEnumerator();
-            HasNext(e, 8);
-            HasNext(e, 4);
-            HasNext(e, 6);
-            HasNext(e, 2);
-            HasNext(e, 0);
-            NoNext(e);
+            await HasNextAsync(e, 8);
+            await HasNextAsync(e, 4);
+            await HasNextAsync(e, 6);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 0);
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void Where2()
+        public async Task Where2()
         {
             var xs = new[] { 8, 5, 7, 4, 6, 9, 2, 1, 0 }.ToAsyncEnumerable();
             var ys = xs.Where((x, i) => i % 2 == 0);
 
             var e = ys.GetAsyncEnumerator();
-            HasNext(e, 8);
-            HasNext(e, 7);
-            HasNext(e, 6);
-            HasNext(e, 2);
-            HasNext(e, 0);
-            NoNext(e);
+            await HasNextAsync(e, 8);
+            await HasNextAsync(e, 7);
+            await HasNextAsync(e, 6);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 0);
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void Where3()
+        public async Task Where3()
         {
             var xs = new[] { 8, 5, 7, 4, 6, 9, 2, 1, 0 }.ToAsyncEnumerable();
             var ex = new Exception("Bang");
             var ys = xs.Where(x => { if (x == 4) throw ex; return true; });
 
             var e = ys.GetAsyncEnumerator();
-            HasNext(e, 8);
-            HasNext(e, 5);
-            HasNext(e, 7);
+            await HasNextAsync(e, 8);
+            await HasNextAsync(e, 5);
+            await HasNextAsync(e, 7);
             AssertThrows(() => e.MoveNextAsync().Wait(WaitTimeoutMs), SingleInnerExceptionMatches(ex));
         }
 
         [Fact]
-        public void Where4()
+        public async Task Where4()
         {
             var xs = new[] { 8, 5, 7, 4, 6, 9, 2, 1, 0 }.ToAsyncEnumerable();
             var ex = new Exception("Bang");
             var ys = xs.Where((x, i) => { if (i == 3) throw ex; return true; });
 
             var e = ys.GetAsyncEnumerator();
-            HasNext(e, 8);
-            HasNext(e, 5);
-            HasNext(e, 7);
+            await HasNextAsync(e, 8);
+            await HasNextAsync(e, 5);
+            await HasNextAsync(e, 7);
             AssertThrows(() => e.MoveNextAsync().Wait(WaitTimeoutMs), SingleInnerExceptionMatches(ex));
         }
 
@@ -102,14 +102,14 @@ namespace Tests
 
 
         [Fact]
-        public void Where7()
+        public async Task Where7()
         {
             var xs = new[] { 8, 5, 7, 4, 6, 9, 2, 1, 0 }.ToAsyncEnumerable();
             var ys = xs.Where(x => x % 2 == 0).Where(x => x > 5);
             var e = ys.GetAsyncEnumerator();
-            HasNext(e, 8);
-            HasNext(e, 6);
-            NoNext(e);
+            await HasNextAsync(e, 8);
+            await HasNextAsync(e, 6);
+            await NoNextAsync(e);
         }
 
         [Fact]

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

@@ -15,51 +15,51 @@ namespace Tests
         [Fact]
         public void Zip_Null()
         {
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Zip<int, int, int>(default, Return42, (x, y) => x + y));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Zip<int, int, int>(Return42, default, (x, y) => x + y));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Zip(Return42, Return42, default(Func<int, int, int>)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.Zip<int, int, int>(default, Return42, (x, y) => x + y));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.Zip<int, int, int>(Return42, default, (x, y) => x + y));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.Zip(Return42, Return42, default(Func<int, int, int>)));
         }
 
         [Fact]
-        public void Zip1()
+        public async Task Zip1Async()
         {
             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
             var ys = new[] { 4, 5, 6 }.ToAsyncEnumerable();
             var res = xs.Zip(ys, (x, y) => x * y);
 
             var e = res.GetAsyncEnumerator();
-            HasNext(e, 1 * 4);
-            HasNext(e, 2 * 5);
-            HasNext(e, 3 * 6);
-            NoNext(e);
+            await HasNextAsync(e, 1 * 4);
+            await HasNextAsync(e, 2 * 5);
+            await HasNextAsync(e, 3 * 6);
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void Zip2()
+        public async Task Zip2Async()
         {
             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
             var ys = new[] { 4, 5, 6, 7 }.ToAsyncEnumerable();
             var res = xs.Zip(ys, (x, y) => x * y);
 
             var e = res.GetAsyncEnumerator();
-            HasNext(e, 1 * 4);
-            HasNext(e, 2 * 5);
-            HasNext(e, 3 * 6);
-            NoNext(e);
+            await HasNextAsync(e, 1 * 4);
+            await HasNextAsync(e, 2 * 5);
+            await HasNextAsync(e, 3 * 6);
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void Zip3()
+        public async Task Zip3Async()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
             var ys = new[] { 4, 5, 6 }.ToAsyncEnumerable();
             var res = xs.Zip(ys, (x, y) => x * y);
 
             var e = res.GetAsyncEnumerator();
-            HasNext(e, 1 * 4);
-            HasNext(e, 2 * 5);
-            HasNext(e, 3 * 6);
-            NoNext(e);
+            await HasNextAsync(e, 1 * 4);
+            await HasNextAsync(e, 2 * 5);
+            await HasNextAsync(e, 3 * 6);
+            await NoNextAsync(e);
         }
 
         [Fact]

Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Optimizations.cs

@@ -12,43 +12,43 @@ namespace Tests
     public class Optimizations : AsyncEnumerableTests
     {
         [Fact]
-        public void SelectWhere2()
+        public async Task SelectWhere2Async()
         {
             var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable();
             var ys = xs.Select(i => i + 2).Where(i => i % 2 == 0);
 
             var e = ys.GetAsyncEnumerator();
-            HasNext(e, 2);
-            HasNext(e, 4);
-            NoNext(e);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 4);
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void WhereSelect2()
+        public async Task WhereSelect2Async()
         {
             var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable();
             var ys = xs.Where(i => i % 2 == 0).Select(i => i + 2);
 
             var e = ys.GetAsyncEnumerator();
-            HasNext(e, 2);
-            HasNext(e, 4);
-            NoNext(e);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 4);
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void WhereSelect3()
+        public async Task WhereSelect3Async()
         {
             var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable();
             var ys = xs.Where(i => i % 2 == 0).Select(i => i + 2).Select(i => i + 2);
 
             var e = ys.GetAsyncEnumerator();
-            HasNext(e, 4);
-            HasNext(e, 6);
-            NoNext(e);
+            await HasNextAsync(e, 4);
+            await HasNextAsync(e, 6);
+            await NoNextAsync(e);
         }
 
         [Fact]
-        public void AppendPrepend1()
+        public async Task AppendPrepend1Async()
         {
             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
 
@@ -62,17 +62,17 @@ namespace Tests
 
             var e = res.GetAsyncEnumerator();
 
-            HasNext(e, 10);
-            HasNext(e, 9);
-            HasNext(e, 7);
-            HasNext(e, 4);
-            HasNext(e, 1);
-            HasNext(e, 2);
-            HasNext(e, 3);
-            HasNext(e, 5);
-            HasNext(e, 6);
-            HasNext(e, 8);
-            NoNext(e);
+            await HasNextAsync(e, 10);
+            await HasNextAsync(e, 9);
+            await HasNextAsync(e, 7);
+            await HasNextAsync(e, 4);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 3);
+            await HasNextAsync(e, 5);
+            await HasNextAsync(e, 6);
+            await HasNextAsync(e, 8);
+            await NoNextAsync(e);
         }
 
         [Fact]
@@ -183,7 +183,7 @@ namespace Tests
         }
 
         [Fact]
-        public void AppendPrepend8()
+        public async Task AppendPrepend8Async()
         {
             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
 
@@ -192,12 +192,12 @@ namespace Tests
 
             var e = res.GetAsyncEnumerator();
 
-            HasNext(e, 5);
-            HasNext(e, 1);
-            HasNext(e, 2);
-            HasNext(e, 3);
-            HasNext(e, 4);
-            NoNext(e);
+            await HasNextAsync(e, 5);
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 3);
+            await HasNextAsync(e, 4);
+            await NoNextAsync(e);
         }
 
         [Fact]