Centralize the use of timeouts.

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

@@ -14,9 +14,9 @@ namespace Tests
     public class AsyncEnumerableTests
     {
         protected static readonly IAsyncEnumerable<int> Return42 = new[] { 42 }.ToAsyncEnumerable();
-        protected static Func<Exception, bool> SingleInnerExceptionMatches(Exception ex) => e => ((AggregateException)e).Flatten().InnerExceptions.Single() == ex;
+        private static Func<Exception, bool> SingleInnerExceptionMatches(Exception ex) => e => ((AggregateException)e).Flatten().InnerExceptions.Single() == ex;
 
-        protected const int WaitTimeoutMs = 5000;
+        private const int WaitTimeoutMs = 5000;
 
 #pragma warning disable xUnit1013 // Public method should be marked as test
         public void AssertThrows<E>(Action a, Func<E, bool> assert)
@@ -40,6 +40,11 @@ namespace Tests
             }
         }
 
+        public void AssertThrowsAsync<TException>(Task t)
+        {
+            AssertThrows<AggregateException>(() => t.Wait(WaitTimeoutMs), ex => ex.Flatten().InnerExceptions.Single() is TException);
+        }
+
         public void AssertThrowsAsync(Task t, Exception e)
         {
             AssertThrows(() => t.Wait(WaitTimeoutMs), SingleInnerExceptionMatches(e));

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

@@ -37,11 +37,11 @@ namespace Tests
         }
 
         [Fact]
-        public void Aggregate1()
+        public async Task Aggregate1Async()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
             var ys = xs.Aggregate((x, y) => x * y);
-            Assert.Equal(24, ys.Result);
+            Assert.Equal(24, await ys);
         }
 
         [Fact]
@@ -49,7 +49,7 @@ namespace Tests
         {
             var xs = new int[0].ToAsyncEnumerable();
             var ys = xs.Aggregate((x, y) => x * y);
-            AssertThrows<Exception>(() => ys.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
+            AssertThrowsAsync<InvalidOperationException>(ys);
         }
 
         [Fact]
@@ -71,19 +71,19 @@ namespace Tests
         }
 
         [Fact]
-        public void Aggregate5()
+        public async Task Aggregate5Async()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
             var ys = xs.Aggregate(1, (x, y) => x * y);
-            Assert.Equal(24, ys.Result);
+            Assert.Equal(24, await ys);
         }
 
         [Fact]
-        public void Aggregate6()
+        public async Task Aggregate6Async()
         {
             var xs = new int[0].ToAsyncEnumerable();
             var ys = xs.Aggregate(1, (x, y) => x * y);
-            Assert.Equal(1, ys.Result);
+            Assert.Equal(1, await ys);
         }
 
         [Fact]
@@ -105,19 +105,19 @@ namespace Tests
         }
 
         [Fact]
-        public void Aggregate9()
+        public async Task Aggregate9Async()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
             var ys = xs.Aggregate(1, (x, y) => x * y, x => x + 1);
-            Assert.Equal(25, ys.Result);
+            Assert.Equal(25, await ys);
         }
 
         [Fact]
-        public void Aggregate10()
+        public async Task Aggregate10Async()
         {
             var xs = new int[0].ToAsyncEnumerable();
             var ys = xs.Aggregate(1, (x, y) => x * y, x => x + 1);
-            Assert.Equal(2, ys.Result);
+            Assert.Equal(2, await ys);
         }
 
         [Fact]

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

@@ -23,17 +23,17 @@ namespace Tests
         }
 
         [Fact]
-        public void All1()
+        public async Task All1Async()
         {
             var res = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().All(x => x % 2 == 0);
-            Assert.False(res.Result);
+            Assert.False(await res);
         }
 
         [Fact]
-        public void All2()
+        public async Task All2Async()
         {
             var res = new[] { 2, 8, 4 }.ToAsyncEnumerable().All(x => x % 2 == 0);
-            Assert.True(res.Result);
+            Assert.True(await res);
         }
 
         [Fact]

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

@@ -25,17 +25,17 @@ namespace Tests
         }
 
         [Fact]
-        public void Any1()
+        public async Task Any1Async()
         {
             var res = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().Any(x => x % 2 == 0);
-            Assert.True(res.Result);
+            Assert.True(await res);
         }
 
         [Fact]
-        public void Any2()
+        public async Task Any2Async()
         {
             var res = new[] { 2, 8, 4 }.ToAsyncEnumerable().Any(x => x % 2 != 0);
-            Assert.False(res.Result);
+            Assert.False(await res);
         }
 
         [Fact]
@@ -55,17 +55,17 @@ namespace Tests
         }
 
         [Fact]
-        public void Any5()
+        public async Task Any5Async()
         {
             var res = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().Any();
-            Assert.True(res.Result);
+            Assert.True(await res);
         }
 
         [Fact]
-        public void Any6()
+        public async Task Any6Async()
         {
             var res = new int[0].ToAsyncEnumerable().Any();
-            Assert.False(res.Result);
+            Assert.False(await res);
         }
     }
 }

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

@@ -84,173 +84,173 @@ namespace Tests
         }
 
         [Fact]
-        public void Average1()
+        public async Task Average1()
         {
             var xs = new[] { 1, 2, 3 };
             var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Average(), ys.Average().Result);
-            Assert.Equal(xs.Average(), ys.Average(x => x).Result);
+            Assert.Equal(xs.Average(), await ys.Average());
+            Assert.Equal(xs.Average(), await ys.Average(x => x));
         }
 
         [Fact]
-        public void Average2()
+        public async Task Average2()
         {
             var xs = new[] { 1, default(int?), 3 };
             var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Average(), ys.Average().Result);
-            Assert.Equal(xs.Average(), ys.Average(x => x).Result);
+            Assert.Equal(xs.Average(), await ys.Average());
+            Assert.Equal(xs.Average(), await ys.Average(x => x));
         }
 
         [Fact]
-        public void Average3()
+        public async Task Average3()
         {
             var xs = new[] { 1L, 2L, 3L };
             var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Average(), ys.Average().Result);
-            Assert.Equal(xs.Average(), ys.Average(x => x).Result);
+            Assert.Equal(xs.Average(), await ys.Average());
+            Assert.Equal(xs.Average(), await ys.Average(x => x));
         }
 
         [Fact]
-        public void Average4()
+        public async Task Average4()
         {
             var xs = new[] { 1L, default(long?), 3L };
             var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Average(), ys.Average().Result);
-            Assert.Equal(xs.Average(), ys.Average(x => x).Result);
+            Assert.Equal(xs.Average(), await ys.Average());
+            Assert.Equal(xs.Average(), await ys.Average(x => x));
         }
 
         [Fact]
-        public void Average5()
+        public async Task Average5()
         {
             var xs = new[] { 1.0, 2.0, 3.0 };
             var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Average(), ys.Average().Result);
-            Assert.Equal(xs.Average(), ys.Average(x => x).Result);
+            Assert.Equal(xs.Average(), await ys.Average());
+            Assert.Equal(xs.Average(), await ys.Average(x => x));
         }
 
         [Fact]
-        public void Average6()
+        public async Task Average6()
         {
             var xs = new[] { 1.0, default(double?), 3.0 };
             var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Average(), ys.Average().Result);
-            Assert.Equal(xs.Average(), ys.Average(x => x).Result);
+            Assert.Equal(xs.Average(), await ys.Average());
+            Assert.Equal(xs.Average(), await ys.Average(x => x));
         }
 
         [Fact]
-        public void Average7()
+        public async Task Average7()
         {
             var xs = new[] { 1.0f, 2.0f, 3.0f };
             var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Average(), ys.Average().Result);
-            Assert.Equal(xs.Average(), ys.Average(x => x).Result);
+            Assert.Equal(xs.Average(), await ys.Average());
+            Assert.Equal(xs.Average(), await ys.Average(x => x));
         }
 
         [Fact]
-        public void Average8()
+        public async Task Average8()
         {
             var xs = new[] { 1.0f, default(float?), 3.0f };
             var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Average(), ys.Average().Result);
-            Assert.Equal(xs.Average(), ys.Average(x => x).Result);
+            Assert.Equal(xs.Average(), await ys.Average());
+            Assert.Equal(xs.Average(), await ys.Average(x => x));
         }
 
         [Fact]
-        public void Average9()
+        public async Task Average9()
         {
             var xs = new[] { 1.0m, 2.0m, 3.0m };
             var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Average(), ys.Average().Result);
-            Assert.Equal(xs.Average(), ys.Average(x => x).Result);
+            Assert.Equal(xs.Average(), await ys.Average());
+            Assert.Equal(xs.Average(), await ys.Average(x => x));
         }
 
         [Fact]
-        public void Average10()
+        public async Task Average10()
         {
             var xs = new[] { 1.0m, default(decimal?), 3.0m };
             var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Average(), ys.Average().Result);
-            Assert.Equal(xs.Average(), ys.Average(x => x).Result);
+            Assert.Equal(xs.Average(), await ys.Average());
+            Assert.Equal(xs.Average(), await ys.Average(x => x));
         }
 
         [Fact]
-        public void Average11()
+        public async Task Average11()
         {
             var xs = new int[0];
             var ys = xs.ToAsyncEnumerable();
-            AssertThrows<Exception>(() => ys.Average().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
+            await Assert.ThrowsAsync<InvalidOperationException>(() => ys.Average());
         }
 
         [Fact]
-        public void Average12()
+        public async Task Average12()
         {
             var xs = new int?[0];
             var ys = xs.ToAsyncEnumerable();
-            Assert.Null(ys.Average().Result);
+            Assert.Null(await ys.Average());
         }
 
         [Fact]
-        public void Average13()
+        public async Task Average13()
         {
             var xs = new long[0];
             var ys = xs.ToAsyncEnumerable();
-            AssertThrows<Exception>(() => ys.Average().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
+            await Assert.ThrowsAsync<InvalidOperationException>(() => ys.Average());
         }
 
         [Fact]
-        public void Average14()
+        public async Task Average14()
         {
             var xs = new long?[0];
             var ys = xs.ToAsyncEnumerable();
-            Assert.Null(ys.Average().Result);
+            Assert.Null(await ys.Average());
         }
 
         [Fact]
-        public void Average15()
+        public async Task Average15()
         {
             var xs = new double[0];
             var ys = xs.ToAsyncEnumerable();
-            AssertThrows<Exception>(() => ys.Average().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
+            await Assert.ThrowsAsync<InvalidOperationException>(() => ys.Average());
         }
 
         [Fact]
-        public void Average16()
+        public async Task Average16()
         {
             var xs = new double?[0];
             var ys = xs.ToAsyncEnumerable();
-            Assert.Null(ys.Average().Result);
+            Assert.Null(await ys.Average());
         }
 
         [Fact]
-        public void Average17()
+        public async Task Average17()
         {
             var xs = new float[0];
             var ys = xs.ToAsyncEnumerable();
-            AssertThrows<Exception>(() => ys.Average().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
+            await Assert.ThrowsAsync<InvalidOperationException>(() => ys.Average());
         }
 
         [Fact]
-        public void Average18()
+        public async Task Average18()
         {
             var xs = new float?[0];
             var ys = xs.ToAsyncEnumerable();
-            Assert.Null(ys.Average().Result);
+            Assert.Null(await ys.Average());
         }
 
         [Fact]
-        public void Average19()
+        public async Task Average19()
         {
             var xs = new decimal[0];
             var ys = xs.ToAsyncEnumerable();
-            AssertThrows<Exception>(() => ys.Average().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
+            await Assert.ThrowsAsync<InvalidOperationException>(() => ys.Average());
         }
 
         [Fact]
-        public void Average20()
+        public async Task Average20()
         {
             var xs = new decimal?[0];
             var ys = xs.ToAsyncEnumerable();
-            Assert.Null(ys.Average().Result);
+            Assert.Null(await ys.Average());
         }
     }
 }

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

@@ -24,35 +24,35 @@ namespace Tests
         }
 
         [Fact]
-        public void Contains1()
+        public async Task Contains1Async()
         {
             var xs = new[] { 1, 2, 3, 4, 5 }.ToAsyncEnumerable();
             var ys = xs.Contains(3);
-            Assert.True(ys.Result);
+            Assert.True(await ys);
         }
 
         [Fact]
-        public void Contains2()
+        public async Task Contains2Async()
         {
             var xs = new[] { 1, 2, 3, 4, 5 }.ToAsyncEnumerable();
             var ys = xs.Contains(6);
-            Assert.False(ys.Result);
+            Assert.False(await ys);
         }
 
         [Fact]
-        public void Contains3()
+        public async Task Contains3Async()
         {
             var xs = new[] { 1, 2, 3, 4, 5 }.ToAsyncEnumerable();
             var ys = xs.Contains(-3, new Eq());
-            Assert.True(ys.Result);
+            Assert.True(await ys);
         }
 
         [Fact]
-        public void Contains4()
+        public async Task Contains4Async()
         {
             var xs = new[] { 1, 2, 3, 4, 5 }.ToAsyncEnumerable();
             var ys = xs.Contains(-6, new Eq());
-            Assert.False(ys.Result);
+            Assert.False(await ys);
         }
 
         private sealed class Eq : IEqualityComparer<int>

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

@@ -27,35 +27,35 @@ namespace Tests
         public void ElementAt1()
         {
             var res = AsyncEnumerable.Empty<int>().ElementAt(0);
-            AssertThrows<Exception>(() => res.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is ArgumentOutOfRangeException);
+            AssertThrowsAsync<ArgumentOutOfRangeException>(res);
         }
 
         [Fact]
-        public void ElementAt2()
+        public async Task ElementAt2Async()
         {
             var res = Return42.ElementAt(0);
-            Assert.Equal(42, res.Result);
+            Assert.Equal(42, await res);
         }
 
         [Fact]
         public void ElementAt3()
         {
             var res = Return42.ElementAt(1);
-            AssertThrows<Exception>(() => res.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is ArgumentOutOfRangeException);
+            AssertThrowsAsync<ArgumentOutOfRangeException>(res);
         }
 
         [Fact]
-        public void ElementAt4()
+        public async Task ElementAt4Async()
         {
             var res = new[] { 1, 42, 3 }.ToAsyncEnumerable().ElementAt(1);
-            Assert.Equal(42, res.Result);
+            Assert.Equal(42, await res);
         }
 
         [Fact]
         public void ElementAt5()
         {
             var res = new[] { 1, 42, 3 }.ToAsyncEnumerable().ElementAt(7);
-            AssertThrows<Exception>(() => res.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is ArgumentOutOfRangeException);
+            AssertThrowsAsync<ArgumentOutOfRangeException>(res);
         }
 
         [Fact]

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

@@ -21,45 +21,45 @@ namespace Tests
         }
 
         [Fact]
-        public void ElementAtOrDefault1()
+        public async Task ElementAtOrDefault1Async()
         {
             var res = AsyncEnumerable.Empty<int>().ElementAtOrDefault(0);
-            Assert.Equal(0, res.Result);
+            Assert.Equal(0, await res);
         }
 
         [Fact]
-        public void ElementAtOrDefault2()
+        public async Task ElementAtOrDefault2Async()
         {
             var res = Return42.ElementAtOrDefault(0);
-            Assert.Equal(42, res.Result);
+            Assert.Equal(42, await res);
         }
 
         [Fact]
-        public void ElementAtOrDefault3()
+        public async Task ElementAtOrDefault3Async()
         {
             var res = Return42.ElementAtOrDefault(1);
-            Assert.Equal(0, res.Result);
+            Assert.Equal(0, await res);
         }
 
         [Fact]
-        public void ElementAtOrDefault4()
+        public async Task ElementAtOrDefault4Async()
         {
             var res = new[] { 1, 42, 3 }.ToAsyncEnumerable().ElementAtOrDefault(1);
-            Assert.Equal(42, res.Result);
+            Assert.Equal(42, await res);
         }
 
         [Fact]
-        public void ElementAtOrDefault5()
+        public async Task ElementAtOrDefault5Async()
         {
             var res = new[] { 1, 42, 3 }.ToAsyncEnumerable().ElementAtOrDefault(7);
-            Assert.Equal(0, res.Result);
+            Assert.Equal(0, await res);
         }
 
         [Fact]
-        public void ElementAtOrDefault6()
+        public async Task ElementAtOrDefault6Async()
         {
             var res = Return42.ElementAtOrDefault(-1);
-            Assert.Equal(0, res.Result);
+            Assert.Equal(0, await res);
         }
 
         [Fact]

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

@@ -29,35 +29,35 @@ namespace Tests
         public void First1()
         {
             var res = AsyncEnumerable.Empty<int>().First();
-            AssertThrows<Exception>(() => res.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
+            AssertThrowsAsync<InvalidOperationException>(res);
         }
 
         [Fact]
         public void First2()
         {
             var res = AsyncEnumerable.Empty<int>().First(x => true);
-            AssertThrows<Exception>(() => res.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
+            AssertThrowsAsync<InvalidOperationException>(res);
         }
 
         [Fact]
         public void First3()
         {
             var res = Return42.First(x => x % 2 != 0);
-            AssertThrows<Exception>(() => res.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
+            AssertThrowsAsync<InvalidOperationException>(res);
         }
 
         [Fact]
-        public void First4()
+        public async Task First4Async()
         {
             var res = Return42.First();
-            Assert.Equal(42, res.Result);
+            Assert.Equal(42, await res);
         }
 
         [Fact]
-        public void First5()
+        public async Task First5Async()
         {
             var res = Return42.First(x => x % 2 == 0);
-            Assert.Equal(42, res.Result);
+            Assert.Equal(42, await res);
         }
 
         [Fact]
@@ -77,17 +77,17 @@ namespace Tests
         }
 
         [Fact]
-        public void First8()
+        public async Task First8Async()
         {
             var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().First();
-            Assert.Equal(42, res.Result);
+            Assert.Equal(42, await res);
         }
 
         [Fact]
-        public void First9()
+        public async Task First9Async()
         {
             var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().First(x => x % 2 != 0);
-            Assert.Equal(45, res.Result);
+            Assert.Equal(45, await res);
         }
     }
 }

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

@@ -26,38 +26,38 @@ namespace Tests
         }
 
         [Fact]
-        public void FirstOrDefault1()
+        public async Task FirstOrDefault1Async()
         {
             var res = AsyncEnumerable.Empty<int>().FirstOrDefault();
-            Assert.Equal(0, res.Result);
+            Assert.Equal(0, await res);
         }
 
         [Fact]
-        public void FirstOrDefault2()
+        public async Task FirstOrDefault2Async()
         {
             var res = AsyncEnumerable.Empty<int>().FirstOrDefault(x => true);
-            Assert.Equal(0, res.Result);
+            Assert.Equal(0, await res);
         }
 
         [Fact]
-        public void FirstOrDefault3()
+        public async Task FirstOrDefault3Async()
         {
             var res = Return42.FirstOrDefault(x => x % 2 != 0);
-            Assert.Equal(0, res.Result);
+            Assert.Equal(0, await res);
         }
 
         [Fact]
-        public void FirstOrDefault4()
+        public async Task FirstOrDefault4Async()
         {
             var res = Return42.FirstOrDefault();
-            Assert.Equal(42, res.Result);
+            Assert.Equal(42, await res);
         }
 
         [Fact]
-        public void FirstOrDefault5()
+        public async Task FirstOrDefault5Async()
         {
             var res = Return42.FirstOrDefault(x => x % 2 == 0);
-            Assert.Equal(42, res.Result);
+            Assert.Equal(42, await res);
         }
 
         [Fact]
@@ -77,24 +77,24 @@ namespace Tests
         }
 
         [Fact]
-        public void FirstOrDefault8()
+        public async Task FirstOrDefault8Async()
         {
             var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().FirstOrDefault();
-            Assert.Equal(42, res.Result);
+            Assert.Equal(42, await res);
         }
 
         [Fact]
-        public void FirstOrDefault9()
+        public async Task FirstOrDefault9Async()
         {
             var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().FirstOrDefault(x => x % 2 != 0);
-            Assert.Equal(45, res.Result);
+            Assert.Equal(45, await res);
         }
 
         [Fact]
-        public void FirstOrDefault10()
+        public async Task FirstOrDefault10Async()
         {
             var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().FirstOrDefault(x => x < 10);
-            Assert.Equal(0, res.Result);
+            Assert.Equal(0, await res);
         }
     }
 }

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

@@ -28,22 +28,22 @@ namespace Tests
         }
 
         [Fact]
-        public void ForEachAsync1()
+        public async Task ForEachAsync1()
         {
             var sum = 0;
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
 
-            xs.ForEachAsync(x => sum += x).Wait(WaitTimeoutMs);
+            await xs.ForEachAsync(x => sum += x);
             Assert.Equal(10, sum);
         }
 
         [Fact]
-        public void ForEachAsync2()
+        public async Task ForEachAsync2()
         {
             var sum = 0;
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
 
-            xs.ForEachAsync((x, i) => sum += x * i).Wait(WaitTimeoutMs);
+            await xs.ForEachAsync((x, i) => sum += x * i);
             Assert.Equal(1 * 0 + 2 * 1 + 3 * 2 + 4 * 3, sum);
         }
 

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

@@ -67,7 +67,7 @@ namespace Tests
 
             var e = res.GetAsyncEnumerator();
 
-            Assert.True(e.MoveNextAsync().Result);
+            Assert.True(await e.MoveNextAsync());
             Assert.Equal(2, e.Current.Key);
             var g1 = e.Current.GetAsyncEnumerator();
             await HasNextAsync(g1, xs[0]);
@@ -76,19 +76,19 @@ namespace Tests
             await HasNextAsync(g1, xs[5]);
             await NoNextAsync(g1);
 
-            Assert.True(e.MoveNextAsync().Result);
+            Assert.True(await e.MoveNextAsync());
             Assert.Equal(6, e.Current.Key);
             var g2 = e.Current.GetAsyncEnumerator();
             await HasNextAsync(g2, xs[1]);
             await NoNextAsync(g2);
 
-            Assert.True(e.MoveNextAsync().Result);
+            Assert.True(await e.MoveNextAsync());
             Assert.Equal(1, e.Current.Key);
             var g3 = e.Current.GetAsyncEnumerator();
             await HasNextAsync(g3, xs[3]);
             await NoNextAsync(g3);
 
-            Assert.True(e.MoveNextAsync().Result);
+            Assert.True(await e.MoveNextAsync());
             Assert.Equal(4, e.Current.Key);
             var g4 = e.Current.GetAsyncEnumerator();
             await HasNextAsync(g4, xs[6]);
@@ -116,19 +116,19 @@ namespace Tests
 
             var e = res.GetAsyncEnumerator();
 
-            Assert.True(e.MoveNextAsync().Result);
+            Assert.True(await e.MoveNextAsync());
             var g1 = e.Current;
             Assert.Equal(2, g1.Key);
 
-            Assert.True(e.MoveNextAsync().Result);
+            Assert.True(await e.MoveNextAsync());
             var g2 = e.Current;
             Assert.Equal(6, g2.Key);
 
-            Assert.True(e.MoveNextAsync().Result);
+            Assert.True(await e.MoveNextAsync());
             var g3 = e.Current;
             Assert.Equal(1, g3.Key);
 
-            Assert.True(e.MoveNextAsync().Result);
+            Assert.True(await e.MoveNextAsync());
             var g4 = e.Current;
             Assert.Equal(4, g4.Key);
 
@@ -178,55 +178,32 @@ namespace Tests
         [Fact]
         public void GroupBy5()
         {
-            var xs = GetXs().ToAsyncEnumerable();
+            var ex = new Exception("Bang!");
+            var xs = GetXs(ex).ToAsyncEnumerable();
             var ys = xs.GroupBy(x => x);
 
             var e = ys.GetAsyncEnumerator();
 
-            AssertThrows(() => e.MoveNextAsync().Wait(WaitTimeoutMs), (Exception ex_) => ((AggregateException)ex_).Flatten().InnerExceptions.Single().Message == "Bang!");
-
-            //Assert.True(e.MoveNext().Result);
-            //var g1 = e.Current;
-            //Assert.Equal(g1.Key, 42);
-            //var g1e = g1.GetEnumerator();
-            //await HasNextAsync(g1e, 42);
-
-            //Assert.True(e.MoveNext().Result);
-            //var g2 = e.Current;
-            //Assert.Equal(g2.Key, 43);
-            //var g2e = g2.GetEnumerator();
-            //await HasNextAsync(g2e, 43);
-
-
-            //AssertThrows<Exception>(() => g1e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single().Message == "Bang!");
-            //AssertThrows<Exception>(() => g2e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single().Message == "Bang!");
+            AssertThrowsAsync(e.MoveNextAsync(), ex);
         }
 
         [Fact]
         public void GroupBy6()
         {
-            var xs = GetXs().ToAsyncEnumerable();
+            var ex = new Exception("Bang!");
+            var xs = GetXs(ex).ToAsyncEnumerable();
             var ys = xs.GroupBy(x => x);
 
             var e = ys.GetAsyncEnumerator();
 
-            AssertThrows(() => e.MoveNextAsync().Wait(WaitTimeoutMs), (Exception ex_) => ((AggregateException)ex_).Flatten().InnerExceptions.Single().Message == "Bang!");
-
-            //Assert.True(e.MoveNext().Result);
-            //var g1 = e.Current;
-            //Assert.Equal(g1.Key, 42);
-            //var g1e = g1.GetEnumerator();
-            //await HasNextAsync(g1e, 42);
-            //AssertThrows<Exception>(() => g1e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single().Message == "Bang!");
-
-
+            AssertThrowsAsync(e.MoveNextAsync(), ex);
         }
 
-        private static IEnumerable<int> GetXs()
+        private static IEnumerable<int> GetXs(Exception ex)
         {
             yield return 42;
             yield return 43;
-            throw new Exception("Bang!");
+            throw ex;
         }
 
         [Fact]
@@ -251,13 +228,13 @@ namespace Tests
 
             AssertThrowsAsync(e.MoveNextAsync(), ex);
 
-            //Assert.True(e.MoveNext().Result);
+            //Assert.True(await e.MoveNext());
             //var g1 = e.Current;
             //Assert.Equal(g1.Key, 1);
             //var g1e = g1.GetEnumerator();
             //await HasNextAsync(g1e, 1);
 
-            //Assert.True(e.MoveNext().Result);
+            //Assert.True(await e.MoveNext());
             //var g2 = e.Current;
             //Assert.Equal(g2.Key, 2);
             //var g2e = g2.GetEnumerator();
@@ -276,7 +253,7 @@ namespace Tests
 
             var e = ys.GetAsyncEnumerator();
 
-            Assert.True(e.MoveNextAsync().Result);
+            Assert.True(await e.MoveNextAsync());
             var g1 = e.Current;
             Assert.Equal(0, g1.Key);
             var g1e = g1.GetAsyncEnumerator();
@@ -286,7 +263,7 @@ namespace Tests
             await HasNextAsync(g1e, 'j');
             await NoNextAsync(g1e);
 
-            Assert.True(e.MoveNextAsync().Result);
+            Assert.True(await e.MoveNextAsync());
             var g2 = e.Current;
             Assert.Equal(1, g2.Key);
             var g2e = g2.GetAsyncEnumerator();
@@ -295,7 +272,7 @@ namespace Tests
             await HasNextAsync(g2e, 'h');
             await NoNextAsync(g2e);
 
-            Assert.True(e.MoveNextAsync().Result);
+            Assert.True(await e.MoveNextAsync());
             var g3 = e.Current;
             Assert.Equal(2, g3.Key);
             var g3e = g3.GetAsyncEnumerator();
@@ -341,7 +318,7 @@ namespace Tests
 
             var e = ys.GetAsyncEnumerator();
 
-            Assert.True(e.MoveNextAsync().Result);
+            Assert.True(await e.MoveNextAsync());
             var g1 = e.Current;
             Assert.Equal(0, g1.Key);
             var g1e = g1.GetAsyncEnumerator();
@@ -351,7 +328,7 @@ namespace Tests
             await HasNextAsync(g1e, 9);
             await NoNextAsync(g1e);
 
-            Assert.True(e.MoveNextAsync().Result);
+            Assert.True(await e.MoveNextAsync());
             var g2 = e.Current;
             Assert.Equal(1, g2.Key);
             var g2e = g2.GetAsyncEnumerator();
@@ -360,7 +337,7 @@ namespace Tests
             await HasNextAsync(g2e, 7);
             await NoNextAsync(g2e);
 
-            Assert.True(e.MoveNextAsync().Result);
+            Assert.True(await e.MoveNextAsync());
             var g3 = e.Current;
             Assert.Equal(2, g3.Key);
             var g3e = g3.GetAsyncEnumerator();
@@ -380,7 +357,7 @@ namespace Tests
 
             var e = ys.GetAsyncEnumerator();
 
-            Assert.True(e.MoveNextAsync().Result);
+            Assert.True(await e.MoveNextAsync());
             var g1 = e.Current;
             Assert.Equal(0, g1.Key);
             var g1e = g1.GetAsyncEnumerator();
@@ -390,7 +367,7 @@ namespace Tests
             await HasNextAsync(g1e, 'j');
             await NoNextAsync(g1e);
 
-            Assert.True(e.MoveNextAsync().Result);
+            Assert.True(await e.MoveNextAsync());
             var g2 = e.Current;
             Assert.Equal(1, g2.Key);
             var g2e = g2.GetAsyncEnumerator();
@@ -399,7 +376,7 @@ namespace Tests
             await HasNextAsync(g2e, 'h');
             await NoNextAsync(g2e);
 
-            Assert.True(e.MoveNextAsync().Result);
+            Assert.True(await e.MoveNextAsync());
             var g3 = e.Current;
             Assert.Equal(2, g3.Key);
             var g3e = g3.GetAsyncEnumerator();
@@ -445,7 +422,7 @@ namespace Tests
 
             var e = ys.GetAsyncEnumerator();
 
-            Assert.True(e.MoveNextAsync().Result);
+            Assert.True(await e.MoveNextAsync());
             var g1 = e.Current;
             Assert.Equal(0, g1.Key);
             var g1e = g1.GetAsyncEnumerator();
@@ -456,7 +433,7 @@ namespace Tests
             await NoNextAsync(g1e);
             await g1e.DisposeAsync();
 
-            Assert.True(e.MoveNextAsync().Result);
+            Assert.True(await e.MoveNextAsync());
             var g2 = e.Current;
             Assert.Equal(1, g2.Key);
             var g2e = g2.GetAsyncEnumerator();
@@ -466,7 +443,7 @@ namespace Tests
             await NoNextAsync(g2e);
             await g2e.DisposeAsync();
 
-            Assert.True(e.MoveNextAsync().Result);
+            Assert.True(await e.MoveNextAsync());
             var g3 = e.Current;
             Assert.Equal(2, g3.Key);
             var g3e = g3.GetAsyncEnumerator();
@@ -490,7 +467,7 @@ namespace Tests
             var e = ys.GetAsyncEnumerator();
             await e.DisposeAsync();
 
-            Assert.False(e.MoveNextAsync().Result);
+            Assert.False(await e.MoveNextAsync());
         }
 
         [Fact]
@@ -501,7 +478,7 @@ namespace Tests
 
             var e = ys.GetAsyncEnumerator();
 
-            Assert.True(e.MoveNextAsync().Result);
+            Assert.True(await e.MoveNextAsync());
             var g1 = e.Current;
             Assert.Equal(0, g1.Key);
             var g1e = g1.GetAsyncEnumerator();
@@ -515,7 +492,7 @@ namespace Tests
             await NoNextAsync(g1e);
             await g1e.DisposeAsync();
 
-            Assert.False(e.MoveNextAsync().Result);
+            Assert.False(await e.MoveNextAsync());
         }
 
         [Fact]

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

@@ -29,35 +29,35 @@ namespace Tests
         public void Last1()
         {
             var res = AsyncEnumerable.Empty<int>().Last();
-            AssertThrows<Exception>(() => res.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
+            AssertThrowsAsync<InvalidOperationException>(res);
         }
 
         [Fact]
         public void Last2()
         {
             var res = AsyncEnumerable.Empty<int>().Last(x => true);
-            AssertThrows<Exception>(() => res.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
+            AssertThrowsAsync<InvalidOperationException>(res);
         }
 
         [Fact]
         public void Last3()
         {
             var res = Return42.Last(x => x % 2 != 0);
-            AssertThrows<Exception>(() => res.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
+            AssertThrowsAsync<InvalidOperationException>(res);
         }
 
         [Fact]
-        public void Last4()
+        public async Task Last4Async()
         {
             var res = Return42.Last();
-            Assert.Equal(42, res.Result);
+            Assert.Equal(42, await res);
         }
 
         [Fact]
-        public void Last5()
+        public async Task Last5Async()
         {
             var res = Return42.Last(x => x % 2 == 0);
-            Assert.Equal(42, res.Result);
+            Assert.Equal(42, await res);
         }
 
         [Fact]
@@ -77,17 +77,17 @@ namespace Tests
         }
 
         [Fact]
-        public void Last8()
+        public async Task Last8Async()
         {
             var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().Last();
-            Assert.Equal(90, res.Result);
+            Assert.Equal(90, await res);
         }
 
         [Fact]
-        public void Last9()
+        public async Task Last9Async()
         {
             var res = new[] { 42, 23, 45, 90 }.ToAsyncEnumerable().Last(x => x % 2 != 0);
-            Assert.Equal(45, res.Result);
+            Assert.Equal(45, await res);
         }
     }
 }

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

@@ -26,38 +26,38 @@ namespace Tests
         }
 
         [Fact]
-        public void LastOrDefault1()
+        public async Task LastOrDefault1Async()
         {
             var res = AsyncEnumerable.Empty<int>().LastOrDefault();
-            Assert.Equal(0, res.Result);
+            Assert.Equal(0, await res);
         }
 
         [Fact]
-        public void LastOrDefault2()
+        public async Task LastOrDefault2Async()
         {
             var res = AsyncEnumerable.Empty<int>().LastOrDefault(x => true);
-            Assert.Equal(0, res.Result);
+            Assert.Equal(0, await res);
         }
 
         [Fact]
-        public void LastOrDefault3()
+        public async Task LastOrDefault3Async()
         {
             var res = Return42.LastOrDefault(x => x % 2 != 0);
-            Assert.Equal(0, res.Result);
+            Assert.Equal(0, await res);
         }
 
         [Fact]
-        public void LastOrDefault4()
+        public async Task LastOrDefault4Async()
         {
             var res = Return42.LastOrDefault();
-            Assert.Equal(42, res.Result);
+            Assert.Equal(42, await res);
         }
 
         [Fact]
-        public void LastOrDefault5()
+        public async Task LastOrDefault5Async()
         {
             var res = Return42.LastOrDefault(x => x % 2 == 0);
-            Assert.Equal(42, res.Result);
+            Assert.Equal(42, await res);
         }
 
         [Fact]
@@ -77,24 +77,24 @@ namespace Tests
         }
 
         [Fact]
-        public void LastOrDefault8()
+        public async Task LastOrDefault8Async()
         {
             var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().LastOrDefault();
-            Assert.Equal(90, res.Result);
+            Assert.Equal(90, await res);
         }
 
         [Fact]
-        public void LastOrDefault9()
+        public async Task LastOrDefault9Async()
         {
             var res = new[] { 42, 23, 45, 90 }.ToAsyncEnumerable().LastOrDefault(x => x % 2 != 0);
-            Assert.Equal(45, res.Result);
+            Assert.Equal(45, await res);
         }
 
         [Fact]
-        public void LastOrDefault10()
+        public async Task LastOrDefault10Async()
         {
             var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().LastOrDefault(x => x < 10);
-            Assert.Equal(0, res.Result);
+            Assert.Equal(0, await res);
         }
     }
 }

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

@@ -92,102 +92,102 @@ namespace Tests
         }
 
         [Fact]
-        public void Max1()
+        public async Task Max1Async()
         {
             var xs = new[] { 2, 7, 3 };
             var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Max(), ys.Max().Result);
-            Assert.Equal(xs.Max(), ys.Max(x => x).Result);
+            Assert.Equal(xs.Max(), await ys.Max());
+            Assert.Equal(xs.Max(), await ys.Max(x => x));
         }
 
         [Fact]
-        public void Max2()
+        public async Task Max2Async()
         {
             var xs = new[] { 2, default(int?), 3, 1 };
             var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Max(), ys.Max().Result);
-            Assert.Equal(xs.Max(), ys.Max(x => x).Result);
+            Assert.Equal(xs.Max(), await ys.Max());
+            Assert.Equal(xs.Max(), await ys.Max(x => x));
         }
 
         [Fact]
-        public void Max3()
+        public async Task Max3Async()
         {
             var xs = new[] { 2L, 7L, 3L };
             var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Max(), ys.Max().Result);
-            Assert.Equal(xs.Max(), ys.Max(x => x).Result);
+            Assert.Equal(xs.Max(), await ys.Max());
+            Assert.Equal(xs.Max(), await ys.Max(x => x));
         }
 
         [Fact]
-        public void Max4()
+        public async Task Max4Async()
         {
             var xs = new[] { 2L, default(long?), 3L, 1L };
             var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Max(), ys.Max().Result);
-            Assert.Equal(xs.Max(), ys.Max(x => x).Result);
+            Assert.Equal(xs.Max(), await ys.Max());
+            Assert.Equal(xs.Max(), await ys.Max(x => x));
         }
 
         [Fact]
-        public void Max5()
+        public async Task Max5Async()
         {
             var xs = new[] { 2.0, 7.0, 3.0 };
             var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Max(), ys.Max().Result);
-            Assert.Equal(xs.Max(), ys.Max(x => x).Result);
+            Assert.Equal(xs.Max(), await ys.Max());
+            Assert.Equal(xs.Max(), await ys.Max(x => x));
         }
 
         [Fact]
-        public void Max6()
+        public async Task Max6Async()
         {
             var xs = new[] { 2.0, default(double?), 3.0, 1.0 };
             var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Max(), ys.Max().Result);
-            Assert.Equal(xs.Max(), ys.Max(x => x).Result);
+            Assert.Equal(xs.Max(), await ys.Max());
+            Assert.Equal(xs.Max(), await ys.Max(x => x));
         }
 
         [Fact]
-        public void Max7()
+        public async Task Max7Async()
         {
             var xs = new[] { 2.0f, 7.0f, 3.0f };
             var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Max(), ys.Max().Result);
-            Assert.Equal(xs.Max(), ys.Max(x => x).Result);
+            Assert.Equal(xs.Max(), await ys.Max());
+            Assert.Equal(xs.Max(), await ys.Max(x => x));
         }
 
         [Fact]
-        public void Max8()
+        public async Task Max8Async()
         {
             var xs = new[] { 2.0f, default(float?), 3.0f, 1.0f };
             var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Max(), ys.Max().Result);
-            Assert.Equal(xs.Max(), ys.Max(x => x).Result);
+            Assert.Equal(xs.Max(), await ys.Max());
+            Assert.Equal(xs.Max(), await ys.Max(x => x));
         }
 
         [Fact]
-        public void Max9()
+        public async Task Max9Async()
         {
             var xs = new[] { 2.0m, 7.0m, 3.0m };
             var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Max(), ys.Max().Result);
-            Assert.Equal(xs.Max(), ys.Max(x => x).Result);
+            Assert.Equal(xs.Max(), await ys.Max());
+            Assert.Equal(xs.Max(), await ys.Max(x => x));
         }
 
         [Fact]
-        public void Max10()
+        public async Task Max10Async()
         {
             var xs = new[] { 2.0m, default(decimal?), 3.0m, 1.0m };
             var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Max(), ys.Max().Result);
-            Assert.Equal(xs.Max(), ys.Max(x => x).Result);
+            Assert.Equal(xs.Max(), await ys.Max());
+            Assert.Equal(xs.Max(), await ys.Max(x => x));
         }
 
         [Fact]
-        public void Max11()
+        public async Task Max11Async()
         {
             var xs = new[] { DateTime.Now.AddDays(1), DateTime.Now.Subtract(TimeSpan.FromDays(1)), DateTime.Now.AddDays(2), DateTime.Now };
             var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Max(), ys.Max().Result);
-            Assert.Equal(xs.Max(), ys.Max(x => x).Result);
+            Assert.Equal(xs.Max(), await ys.Max());
+            Assert.Equal(xs.Max(), await ys.Max(x => x));
         }
     }
 }

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

@@ -92,102 +92,102 @@ namespace Tests
         }
 
         [Fact]
-        public void Min1()
+        public async Task Min1Async()
         {
             var xs = new[] { 2, 1, 3 };
             var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Min(), ys.Min().Result);
-            Assert.Equal(xs.Min(), ys.Min(x => x).Result);
+            Assert.Equal(xs.Min(), await ys.Min());
+            Assert.Equal(xs.Min(), await ys.Min(x => x));
         }
 
         [Fact]
-        public void Min2()
+        public async Task Min2Async()
         {
             var xs = new[] { 2, default(int?), 3 };
             var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Min(), ys.Min().Result);
-            Assert.Equal(xs.Min(), ys.Min(x => x).Result);
+            Assert.Equal(xs.Min(), await ys.Min());
+            Assert.Equal(xs.Min(), await ys.Min(x => x));
         }
 
         [Fact]
-        public void Min3()
+        public async Task Min3Async()
         {
             var xs = new[] { 2L, 1L, 3L };
             var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Min(), ys.Min().Result);
-            Assert.Equal(xs.Min(), ys.Min(x => x).Result);
+            Assert.Equal(xs.Min(), await ys.Min());
+            Assert.Equal(xs.Min(), await ys.Min(x => x));
         }
 
         [Fact]
-        public void Min4()
+        public async Task Min4Async()
         {
             var xs = new[] { 2L, default(long?), 3L };
             var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Min(), ys.Min().Result);
-            Assert.Equal(xs.Min(), ys.Min(x => x).Result);
+            Assert.Equal(xs.Min(), await ys.Min());
+            Assert.Equal(xs.Min(), await ys.Min(x => x));
         }
 
         [Fact]
-        public void Min5()
+        public async Task Min5Async()
         {
             var xs = new[] { 2.0, 1.0, 3.0 };
             var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Min(), ys.Min().Result);
-            Assert.Equal(xs.Min(), ys.Min(x => x).Result);
+            Assert.Equal(xs.Min(), await ys.Min());
+            Assert.Equal(xs.Min(), await ys.Min(x => x));
         }
 
         [Fact]
-        public void Min6()
+        public async Task Min6Async()
         {
             var xs = new[] { 2.0, default(double?), 3.0 };
             var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Min(), ys.Min().Result);
-            Assert.Equal(xs.Min(), ys.Min(x => x).Result);
+            Assert.Equal(xs.Min(), await ys.Min());
+            Assert.Equal(xs.Min(), await ys.Min(x => x));
         }
 
         [Fact]
-        public void Min7()
+        public async Task Min7Async()
         {
             var xs = new[] { 2.0f, 1.0f, 3.0f };
             var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Min(), ys.Min().Result);
-            Assert.Equal(xs.Min(), ys.Min(x => x).Result);
+            Assert.Equal(xs.Min(), await ys.Min());
+            Assert.Equal(xs.Min(), await ys.Min(x => x));
         }
 
         [Fact]
-        public void Min8()
+        public async Task Min8Async()
         {
             var xs = new[] { 2.0f, default(float?), 3.0f };
             var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Min(), ys.Min().Result);
-            Assert.Equal(xs.Min(), ys.Min(x => x).Result);
+            Assert.Equal(xs.Min(), await ys.Min());
+            Assert.Equal(xs.Min(), await ys.Min(x => x));
         }
 
         [Fact]
-        public void Min9()
+        public async Task Min9Async()
         {
             var xs = new[] { 2.0m, 1.0m, 3.0m };
             var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Min(), ys.Min().Result);
-            Assert.Equal(xs.Min(), ys.Min(x => x).Result);
+            Assert.Equal(xs.Min(), await ys.Min());
+            Assert.Equal(xs.Min(), await ys.Min(x => x));
         }
 
         [Fact]
-        public void Min10()
+        public async Task Min10Async()
         {
             var xs = new[] { 2.0m, default(decimal?), 3.0m };
             var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Min(), ys.Min().Result);
-            Assert.Equal(xs.Min(), ys.Min(x => x).Result);
+            Assert.Equal(xs.Min(), await ys.Min());
+            Assert.Equal(xs.Min(), await ys.Min(x => x));
         }
 
         [Fact]
-        public void Min11()
+        public async Task Min11Async()
         {
             var xs = new[] { DateTime.Now.AddDays(1), DateTime.Now.Subtract(TimeSpan.FromDays(1)), DateTime.Now.AddDays(2), DateTime.Now };
             var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Min(), ys.Min().Result);
-            Assert.Equal(xs.Min(), ys.Min(x => x).Result);
+            Assert.Equal(xs.Min(), await ys.Min());
+            Assert.Equal(xs.Min(), await ys.Min(x => x));
         }
     }
 }

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

@@ -54,7 +54,7 @@ namespace Tests
             var ys = xs.Select(x => 1 / x);
 
             var e = ys.GetAsyncEnumerator();
-            AssertThrows(() => e.MoveNextAsync().Wait(WaitTimeoutMs), (Exception ex_) => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is DivideByZeroException);
+            AssertThrowsAsync<DivideByZeroException>(e.MoveNextAsync().AsTask());
         }
 
         [Fact]
@@ -64,7 +64,7 @@ namespace Tests
             var ys = xs.Select((x, i) => 1 / i);
 
             var e = ys.GetAsyncEnumerator();
-            AssertThrows(() => e.MoveNextAsync().Wait(WaitTimeoutMs), (Exception ex_) => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is DivideByZeroException);
+            AssertThrowsAsync<DivideByZeroException>(e.MoveNextAsync().AsTask());
         }
 
         [Fact]

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

@@ -30,46 +30,46 @@ namespace Tests
         }
 
         [Fact]
-        public void SequenceEqual1()
+        public async Task SequenceEqual1Async()
         {
             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
             var res = xs.SequenceEqual(xs);
-            Assert.True(res.Result);
+            Assert.True(await res);
         }
 
         [Fact]
-        public void SequenceEqual2()
+        public async Task SequenceEqual2Async()
         {
             var xs = AsyncEnumerable.Empty<int>();
             var res = xs.SequenceEqual(xs);
-            Assert.True(res.Result);
+            Assert.True(await res);
         }
 
         [Fact]
-        public void SequenceEqual3()
+        public async Task SequenceEqual3Async()
         {
             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
             var ys = new[] { 1, 3, 2 }.ToAsyncEnumerable();
             var res = xs.SequenceEqual(ys);
-            Assert.False(res.Result);
+            Assert.False(await res);
         }
 
         [Fact]
-        public void SequenceEqual4()
+        public async Task SequenceEqual4Async()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
             var ys = new[] { 1, 2, 3 }.ToAsyncEnumerable();
             var res = xs.SequenceEqual(ys);
-            Assert.False(res.Result);
+            Assert.False(await res);
         }
 
         [Fact]
-        public void SequenceEqual5()
+        public async Task SequenceEqual5Async()
         {
             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
             var ys = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
             var res = xs.SequenceEqual(ys);
-            Assert.False(res.Result);
+            Assert.False(await res);
         }
 
         [Fact]
@@ -95,46 +95,46 @@ namespace Tests
         }
 
         [Fact]
-        public void SequenceEqual8()
+        public async Task SequenceEqual8Async()
         {
             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
             var res = xs.SequenceEqual(xs, new Eq());
-            Assert.True(res.Result);
+            Assert.True(await res);
         }
 
         [Fact]
-        public void SequenceEqual9()
+        public async Task SequenceEqual9Async()
         {
             var xs = AsyncEnumerable.Empty<int>();
             var res = xs.SequenceEqual(xs, new Eq());
-            Assert.True(res.Result);
+            Assert.True(await res);
         }
 
         [Fact]
-        public void SequenceEqual10()
+        public async Task SequenceEqual10Async()
         {
             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
             var ys = new[] { 1, 3, 2 }.ToAsyncEnumerable();
             var res = xs.SequenceEqual(ys, new Eq());
-            Assert.False(res.Result);
+            Assert.False(await res);
         }
 
         [Fact]
-        public void SequenceEqual11()
+        public async Task SequenceEqual11Async()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
             var ys = new[] { 1, 2, 3 }.ToAsyncEnumerable();
             var res = xs.SequenceEqual(ys, new Eq());
-            Assert.False(res.Result);
+            Assert.False(await res);
         }
 
         [Fact]
-        public void SequenceEqual12()
+        public async Task SequenceEqual12Async()
         {
             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
             var ys = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
             var res = xs.SequenceEqual(ys, new Eq());
-            Assert.False(res.Result);
+            Assert.False(await res);
         }
 
         [Fact]
@@ -160,12 +160,12 @@ namespace Tests
         }
 
         [Fact]
-        public void SequenceEqual15()
+        public async Task SequenceEqual15Async()
         {
             var xs = new[] { 1, 2, -3, 4 }.ToAsyncEnumerable();
             var ys = new[] { 1, -2, 3, 4 }.ToAsyncEnumerable();
             var res = xs.SequenceEqual(ys, new Eq());
-            Assert.True(res.Result);
+            Assert.True(await res);
         }
 
         [Fact]
@@ -174,7 +174,7 @@ namespace Tests
             var xs = new[] { 1, 2, -3, 4 }.ToAsyncEnumerable();
             var ys = new[] { 1, -2, 3, 4 }.ToAsyncEnumerable();
             var res = xs.SequenceEqual(ys, new EqEx());
-            AssertThrows<Exception>(() => res.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is NotImplementedException);
+            AssertThrowsAsync<NotImplementedException>(res);
         }
 
         private sealed class EqEx : IEqualityComparer<int>

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

@@ -29,35 +29,35 @@ namespace Tests
         public void Single1()
         {
             var res = AsyncEnumerable.Empty<int>().Single();
-            AssertThrows<Exception>(() => res.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
+            AssertThrowsAsync<InvalidOperationException>(res);
         }
 
         [Fact]
         public void Single2()
         {
             var res = AsyncEnumerable.Empty<int>().Single(x => true);
-            AssertThrows<Exception>(() => res.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
+            AssertThrowsAsync<InvalidOperationException>(res);
         }
 
         [Fact]
         public void Single3()
         {
             var res = Return42.Single(x => x % 2 != 0);
-            AssertThrows<Exception>(() => res.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
+            AssertThrowsAsync<InvalidOperationException>(res);
         }
 
         [Fact]
-        public void Single4()
+        public async Task Single4Async()
         {
             var res = Return42.Single();
-            Assert.Equal(42, res.Result);
+            Assert.Equal(42, await res);
         }
 
         [Fact]
-        public void Single5()
+        public async Task Single5Async()
         {
             var res = Return42.Single(x => x % 2 == 0);
-            Assert.Equal(42, res.Result);
+            Assert.Equal(42, await res);
         }
 
         [Fact]
@@ -80,28 +80,28 @@ namespace Tests
         public void Single8()
         {
             var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().Single();
-            AssertThrows<Exception>(() => res.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
+            AssertThrowsAsync<InvalidOperationException>(res);
         }
 
         [Fact]
-        public void Single9()
+        public async Task Single9Async()
         {
             var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().Single(x => x % 2 != 0);
-            Assert.Equal(45, res.Result);
+            Assert.Equal(45, await res);
         }
 
         [Fact]
         public void Single10()
         {
             var res = new[] { 42, 23, 45, 90 }.ToAsyncEnumerable().Single(x => x % 2 != 0);
-            AssertThrows<Exception>(() => res.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
+            AssertThrowsAsync<InvalidOperationException>(res);
         }
 
         [Fact]
         public void Single11()
         {
             var res = new int[0].ToAsyncEnumerable().Single();
-            AssertThrows<Exception>(() => res.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
+            AssertThrowsAsync<InvalidOperationException>(res);
         }
     }
 }

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

@@ -26,38 +26,38 @@ namespace Tests
         }
 
         [Fact]
-        public void SingleOrDefault1()
+        public async Task SingleOrDefault1Async()
         {
             var res = AsyncEnumerable.Empty<int>().SingleOrDefault();
-            Assert.Equal(0, res.Result);
+            Assert.Equal(0, await res);
         }
 
         [Fact]
-        public void SingleOrDefault2()
+        public async Task SingleOrDefault2Async()
         {
             var res = AsyncEnumerable.Empty<int>().SingleOrDefault(x => true);
-            Assert.Equal(0, res.Result);
+            Assert.Equal(0, await res);
         }
 
         [Fact]
-        public void SingleOrDefault3()
+        public async Task SingleOrDefault3Async()
         {
             var res = Return42.SingleOrDefault(x => x % 2 != 0);
-            Assert.Equal(0, res.Result);
+            Assert.Equal(0, await res);
         }
 
         [Fact]
-        public void SingleOrDefault4()
+        public async Task SingleOrDefault4Async()
         {
             var res = Return42.SingleOrDefault();
-            Assert.Equal(42, res.Result);
+            Assert.Equal(42, await res);
         }
 
         [Fact]
-        public void SingleOrDefault5()
+        public async Task SingleOrDefault5Async()
         {
             var res = Return42.SingleOrDefault(x => x % 2 == 0);
-            Assert.Equal(42, res.Result);
+            Assert.Equal(42, await res);
         }
 
         [Fact]
@@ -80,35 +80,35 @@ namespace Tests
         public void SingleOrDefault8()
         {
             var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().SingleOrDefault();
-            AssertThrows<Exception>(() => res.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
+            AssertThrowsAsync<InvalidOperationException>(res);
         }
 
         [Fact]
-        public void SingleOrDefault9()
+        public async Task SingleOrDefault9Async()
         {
             var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().SingleOrDefault(x => x % 2 != 0);
-            Assert.Equal(45, res.Result);
+            Assert.Equal(45, await res);
         }
 
         [Fact]
-        public void SingleOrDefault10()
+        public async Task SingleOrDefault10Async()
         {
             var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().SingleOrDefault(x => x < 10);
-            Assert.Equal(0, res.Result);
+            Assert.Equal(0, await res);
         }
 
         [Fact]
         public void SingleOrDefault11()
         {
             var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().SingleOrDefault(x => true);
-            AssertThrows<Exception>(() => res.Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
+            AssertThrowsAsync<InvalidOperationException>(res);
         }
 
         [Fact]
-        public void SingleOrDefault12()
+        public async Task SingleOrDefault12Async()
         {
             var res = new int[0].ToAsyncEnumerable().SingleOrDefault();
-            Assert.Equal(0, res.Result);
+            Assert.Equal(0, await res);
         }
     }
 }

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

@@ -84,93 +84,93 @@ namespace Tests
         }
 
         [Fact]
-        public void Sum1()
+        public async Task Sum1Async()
         {
             var xs = new[] { 1, 2, 3 };
             var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Sum(), ys.Sum().Result);
-            Assert.Equal(xs.Sum(), ys.Sum(x => x).Result);
+            Assert.Equal(xs.Sum(), await ys.Sum());
+            Assert.Equal(xs.Sum(), await ys.Sum(x => x));
         }
 
         [Fact]
-        public void Sum2()
+        public async Task Sum2Async()
         {
             var xs = new[] { 1, default(int?), 3 };
             var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Sum(), ys.Sum().Result);
-            Assert.Equal(xs.Sum(), ys.Sum(x => x).Result);
+            Assert.Equal(xs.Sum(), await ys.Sum());
+            Assert.Equal(xs.Sum(), await ys.Sum(x => x));
         }
 
         [Fact]
-        public void Sum3()
+        public async Task Sum3Async()
         {
             var xs = new[] { 1L, 2L, 3L };
             var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Sum(), ys.Sum().Result);
-            Assert.Equal(xs.Sum(), ys.Sum(x => x).Result);
+            Assert.Equal(xs.Sum(), await ys.Sum());
+            Assert.Equal(xs.Sum(), await ys.Sum(x => x));
         }
 
         [Fact]
-        public void Sum4()
+        public async Task Sum4Async()
         {
             var xs = new[] { 1L, default(long?), 3L };
             var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Sum(), ys.Sum().Result);
-            Assert.Equal(xs.Sum(), ys.Sum(x => x).Result);
+            Assert.Equal(xs.Sum(), await ys.Sum());
+            Assert.Equal(xs.Sum(), await ys.Sum(x => x));
         }
 
         [Fact]
-        public void Sum5()
+        public async Task Sum5Async()
         {
             var xs = new[] { 1.0, 2.0, 3.0 };
             var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Sum(), ys.Sum().Result);
-            Assert.Equal(xs.Sum(), ys.Sum(x => x).Result);
+            Assert.Equal(xs.Sum(), await ys.Sum());
+            Assert.Equal(xs.Sum(), await ys.Sum(x => x));
         }
 
         [Fact]
-        public void Sum6()
+        public async Task Sum6Async()
         {
             var xs = new[] { 1.0, default(double?), 3.0 };
             var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Sum(), ys.Sum().Result);
-            Assert.Equal(xs.Sum(), ys.Sum(x => x).Result);
+            Assert.Equal(xs.Sum(), await ys.Sum());
+            Assert.Equal(xs.Sum(), await ys.Sum(x => x));
         }
 
         [Fact]
-        public void Sum7()
+        public async Task Sum7Async()
         {
             var xs = new[] { 1.0f, 2.0f, 3.0f };
             var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Sum(), ys.Sum().Result);
-            Assert.Equal(xs.Sum(), ys.Sum(x => x).Result);
+            Assert.Equal(xs.Sum(), await ys.Sum());
+            Assert.Equal(xs.Sum(), await ys.Sum(x => x));
         }
 
         [Fact]
-        public void Sum8()
+        public async Task Sum8Async()
         {
             var xs = new[] { 1.0f, default(float?), 3.0f };
             var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Sum(), ys.Sum().Result);
-            Assert.Equal(xs.Sum(), ys.Sum(x => x).Result);
+            Assert.Equal(xs.Sum(), await ys.Sum());
+            Assert.Equal(xs.Sum(), await ys.Sum(x => x));
         }
 
         [Fact]
-        public void Sum9()
+        public async Task Sum9Async()
         {
             var xs = new[] { 1.0m, 2.0m, 3.0m };
             var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Sum(), ys.Sum().Result);
-            Assert.Equal(xs.Sum(), ys.Sum(x => x).Result);
+            Assert.Equal(xs.Sum(), await ys.Sum());
+            Assert.Equal(xs.Sum(), await ys.Sum(x => x));
         }
 
         [Fact]
-        public void Sum10()
+        public async Task Sum10Async()
         {
             var xs = new[] { 1.0m, default(decimal?), 3.0m };
             var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Sum(), ys.Sum().Result);
-            Assert.Equal(xs.Sum(), ys.Sum(x => x).Result);
+            Assert.Equal(xs.Sum(), await ys.Sum());
+            Assert.Equal(xs.Sum(), await ys.Sum(x => x));
         }
     }
 }

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

@@ -23,11 +23,7 @@ namespace Tests
             var xs = Throw<int>(ex);
 
             var e = xs.GetAsyncEnumerator();
-            AssertThrows(() => e.MoveNextAsync().Wait(WaitTimeoutMs), (Exception ex_) => ((AggregateException)ex_).InnerExceptions.Single() == ex);
-        }
-
-        private void Nop(object o)
-        {
+            AssertThrowsAsync(e.MoveNextAsync(), ex);
         }
     }
 }

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

@@ -21,19 +21,19 @@ namespace Tests
         }
 
         [Fact]
-        public void ToArray1()
+        public async Task ToArray1()
         {
             var xs = new[] { 42, 25, 39 };
             var res = xs.ToAsyncEnumerable().ToArray();
-            Assert.True(res.Result.SequenceEqual(xs));
+            Assert.True((await res).SequenceEqual(xs));
         }
 
         [Fact]
-        public void ToArray2()
+        public async Task ToArray2()
         {
             var xs = AsyncEnumerable.Empty<int>();
             var res = xs.ToArray();
-            Assert.True(res.Result.Length == 0);
+            Assert.True((await res).Length == 0);
         }
 
         [Fact]

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

@@ -39,7 +39,7 @@ namespace Tests
             var xs = ToAsyncEnumerable_Sequence(ex).ToAsyncEnumerable();
             var e = xs.GetAsyncEnumerator();
             await HasNextAsync(e, 42);
-            AssertThrows(() => e.MoveNextAsync().Wait(WaitTimeoutMs), (Exception ex_) => ((AggregateException)ex_).InnerExceptions.Single() == ex);
+            AssertThrowsAsync(e.MoveNextAsync(), ex);
         }
 
         private IEnumerable<int> ToAsyncEnumerable_Sequence(Exception e)
@@ -94,7 +94,7 @@ namespace Tests
 
             Assert.True(subscribed);
 
-            AssertThrows(() => e.MoveNextAsync().Wait(WaitTimeoutMs), (Exception ex_) => ((AggregateException)ex_).InnerExceptions.Single() == ex);
+            AssertThrowsAsync(e.MoveNextAsync(), ex);
         }
 
         [Fact]
@@ -223,16 +223,16 @@ namespace Tests
         }
 
         [Fact]
-        public void ToAsyncEnumerable_With_Completed_Task()
+        public async Task ToAsyncEnumerable_With_Completed_TaskAsync()
         {
             var task = Task.Factory.StartNew(() => 36);
 
             var xs = task.ToAsyncEnumerable();
             var e = xs.GetAsyncEnumerator();
 
-            Assert.True(e.MoveNextAsync().Result);
+            Assert.True(await e.MoveNextAsync());
             Assert.Equal(36, e.Current);
-            Assert.False(e.MoveNextAsync().Result);
+            Assert.False(await e.MoveNextAsync());
         }
 
         [Fact]
@@ -245,7 +245,7 @@ namespace Tests
             var xs = tcs.Task.ToAsyncEnumerable();
             var e = xs.GetAsyncEnumerator();
 
-            AssertThrows(() => e.MoveNextAsync().Wait(WaitTimeoutMs), (Exception ex_) => ((AggregateException)ex_).InnerExceptions.Single() == ex);
+            AssertThrowsAsync(e.MoveNextAsync(), ex);
         }
 
         [Fact]
@@ -257,7 +257,7 @@ namespace Tests
             var xs = tcs.Task.ToAsyncEnumerable();
             var e = xs.GetAsyncEnumerator();
 
-            AssertThrows(() => e.MoveNextAsync().Wait(WaitTimeoutMs), (Exception ex_) => ((AggregateException)ex_).InnerExceptions.Single() is TaskCanceledException);
+            AssertThrowsAsync<TaskCanceledException>(e.MoveNextAsync().AsTask());
         }
 
         private sealed class MyObservable<T> : IObservable<T>

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

@@ -46,10 +46,10 @@ namespace Tests
         }
 
         [Fact]
-        public void ToDictionary1()
+        public async Task ToDictionary1Async()
         {
             var xs = new[] { 1, 4 }.ToAsyncEnumerable();
-            var res = xs.ToDictionary(x => x % 2).Result;
+            var res = await xs.ToDictionary(x => x % 2);
             Assert.True(res[0] == 4);
             Assert.True(res[1] == 1);
         }
@@ -58,14 +58,14 @@ namespace Tests
         public void ToDictionary2()
         {
             var xs = new[] { 1, 4, 2 }.ToAsyncEnumerable();
-            AssertThrows<Exception>(() => xs.ToDictionary(x => x % 2).Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is ArgumentException);
+            AssertThrowsAsync<ArgumentException>(xs.ToDictionary(x => x % 2));
         }
 
         [Fact]
-        public void ToDictionary3()
+        public async Task ToDictionary3Async()
         {
             var xs = new[] { 1, 4 }.ToAsyncEnumerable();
-            var res = xs.ToDictionary(x => x % 2, x => x + 1).Result;
+            var res = await xs.ToDictionary(x => x % 2, x => x + 1);
             Assert.True(res[0] == 5);
             Assert.True(res[1] == 2);
         }
@@ -74,14 +74,14 @@ namespace Tests
         public void ToDictionary4()
         {
             var xs = new[] { 1, 4, 2 }.ToAsyncEnumerable();
-            AssertThrows<Exception>(() => xs.ToDictionary(x => x % 2, x => x + 1).Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is ArgumentException);
+            AssertThrowsAsync<ArgumentException>(xs.ToDictionary(x => x % 2, x => x + 1));
         }
 
         [Fact]
-        public void ToDictionary5()
+        public async Task ToDictionary5Async()
         {
             var xs = new[] { 1, 4 }.ToAsyncEnumerable();
-            var res = xs.ToDictionary(x => x % 2, new Eq()).Result;
+            var res = await xs.ToDictionary(x => x % 2, new Eq());
             Assert.True(res[0] == 4);
             Assert.True(res[1] == 1);
         }
@@ -90,14 +90,14 @@ namespace Tests
         public void ToDictionary6()
         {
             var xs = new[] { 1, 4, 2 }.ToAsyncEnumerable();
-            AssertThrows<Exception>(() => xs.ToDictionary(x => x % 2, new Eq()).Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is ArgumentException);
+            AssertThrowsAsync<ArgumentException>(xs.ToDictionary(x => x % 2, new Eq()));
         }
 
         [Fact]
-        public void ToDictionary7()
+        public async Task ToDictionary7Async()
         {
             var xs = new[] { 1, 4 }.ToAsyncEnumerable();
-            var res = xs.ToDictionary(x => x % 2, x => x, new Eq()).Result;
+            var res = await xs.ToDictionary(x => x % 2, x => x, new Eq());
             Assert.True(res[0] == 4);
             Assert.True(res[1] == 1);
         }

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

@@ -23,11 +23,11 @@ namespace Tests
         }
 
         [Fact]
-        public void ToHashSet1()
+        public async Task ToHashSet1()
         {
             var xs = new[] { 1, 2, 1, 2, 3, 4, 1, 2, 3, 4 };
             var res = xs.ToAsyncEnumerable().ToHashSet();
-            Assert.True(res.Result.OrderBy(x => x).SequenceEqual(new[] { 1, 2, 3, 4 }));
+            Assert.True((await res).OrderBy(x => x).SequenceEqual(new[] { 1, 2, 3, 4 }));
         }
     }
 }

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

@@ -21,19 +21,19 @@ namespace Tests
         }
 
         [Fact]
-        public void ToList1()
+        public async Task ToList1()
         {
             var xs = new[] { 42, 25, 39 };
             var res = xs.ToAsyncEnumerable().ToList();
-            Assert.True(res.Result.SequenceEqual(xs));
+            Assert.True((await res).SequenceEqual(xs));
         }
 
         [Fact]
-        public void ToList2()
+        public async Task ToList2()
         {
             var xs = AsyncEnumerable.Empty<int>();
             var res = xs.ToList();
-            Assert.True(res.Result.Count == 0);
+            Assert.True((await res).Count == 0);
         }
 
         [Fact]

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

@@ -47,10 +47,10 @@ namespace Tests
         }
 
         [Fact]
-        public void ToLookup1()
+        public async Task ToLookup1Async()
         {
             var xs = new[] { 1, 4 }.ToAsyncEnumerable();
-            var res = xs.ToLookup(x => x % 2).Result;
+            var res = await xs.ToLookup(x => x % 2);
             Assert.True(res.Contains(0));
             Assert.True(res.Contains(1));
             Assert.Contains(4, res[0]);
@@ -59,10 +59,10 @@ namespace Tests
         }
 
         [Fact]
-        public void ToLookup2()
+        public async Task ToLookup2Async()
         {
             var xs = new[] { 1, 4, 2 }.ToAsyncEnumerable();
-            var res = xs.ToLookup(x => x % 2).Result;
+            var res = await xs.ToLookup(x => x % 2);
             Assert.True(res.Contains(0));
             Assert.True(res.Contains(1));
             Assert.Contains(4, res[0]);
@@ -72,10 +72,10 @@ namespace Tests
         }
 
         [Fact]
-        public void ToLookup3()
+        public async Task ToLookup3Async()
         {
             var xs = new[] { 1, 4 }.ToAsyncEnumerable();
-            var res = xs.ToLookup(x => x % 2, x => x + 1).Result;
+            var res = await xs.ToLookup(x => x % 2, x => x + 1);
             Assert.True(res.Contains(0));
             Assert.True(res.Contains(1));
             Assert.Contains(5, res[0]);
@@ -84,10 +84,10 @@ namespace Tests
         }
 
         [Fact]
-        public void ToLookup4()
+        public async Task ToLookup4Async()
         {
             var xs = new[] { 1, 4, 2 }.ToAsyncEnumerable();
-            var res = xs.ToLookup(x => x % 2, x => x + 1).Result;
+            var res = await xs.ToLookup(x => x % 2, x => x + 1);
             Assert.True(res.Contains(0));
             Assert.True(res.Contains(1));
             Assert.Contains(5, res[0]);
@@ -97,10 +97,10 @@ namespace Tests
         }
 
         [Fact]
-        public void ToLookup5()
+        public async Task ToLookup5Async()
         {
             var xs = new[] { 1, 4 }.ToAsyncEnumerable();
-            var res = xs.ToLookup(x => x % 2, new Eq()).Result;
+            var res = await xs.ToLookup(x => x % 2, new Eq());
             Assert.True(res.Contains(0));
             Assert.True(res.Contains(1));
             Assert.Contains(4, res[0]);
@@ -109,10 +109,10 @@ namespace Tests
         }
 
         [Fact]
-        public void ToLookup6()
+        public async Task ToLookup6Async()
         {
             var xs = new[] { 1, 4, 2 }.ToAsyncEnumerable();
-            var res = xs.ToLookup(x => x % 2, new Eq()).Result;
+            var res = await xs.ToLookup(x => x % 2, new Eq());
             Assert.True(res.Contains(0));
             Assert.True(res.Contains(1));
             Assert.Contains(4, res[0]);
@@ -122,19 +122,19 @@ namespace Tests
         }
 
         [Fact]
-        public void ToLookup7()
+        public async Task ToLookup7Async()
         {
             var xs = new[] { 1, 4, 2 }.ToAsyncEnumerable();
-            var res = xs.ToLookup(x => x % 2).Result;
+            var res = await xs.ToLookup(x => x % 2);
             foreach (var g in res)
                 Assert.True(g.Key == 0 || g.Key == 1);
         }
 
         [Fact]
-        public void ToLookup8()
+        public async Task ToLookup8Async()
         {
             var xs = new[] { 1, 4, 2 }.ToAsyncEnumerable();
-            var res = xs.ToLookup(x => x % 2).Result;
+            var res = await xs.ToLookup(x => x % 2);
 #pragma warning disable IDE0007 // Use implicit type
             foreach (IGrouping<int, int> g in (IEnumerable)res)
                 Assert.True(g.Key == 0 || g.Key == 1);
@@ -142,10 +142,10 @@ namespace Tests
         }
 
         [Fact]
-        public void ToLookup9()
+        public async Task ToLookup9Async()
         {
             var xs = new[] { 1, 4, 2 }.ToAsyncEnumerable();
-            var res = xs.ToLookup(x => x % 2, x => x, new Eq()).Result;
+            var res = await xs.ToLookup(x => x % 2, x => x, new Eq());
             Assert.True(res.Contains(0));
             Assert.True(res.Contains(1));
             Assert.Contains(4, res[0]);