Moving SkipWhile and TakeWhile tests.

Ix.NET/Source/System.Interactive.Async.Tests/AsyncTests.Single.cs

@@ -11,7 +11,6 @@ using Xunit;
 
 namespace Tests
 {
-
     public partial class AsyncTests
     {
         [Fact]
@@ -549,276 +548,6 @@ namespace Tests
             AssertThrows<Exception>(() => xs.ForEachAsync((x, i) => { throw ex; }).Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
-        [Fact]
-        public void TakeWhile_Null()
-        {
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.TakeWhile<int>(null, x => true));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.TakeWhile<int>(null, (x, i) => true));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.TakeWhile<int>(AsyncEnumerable.Return(42), default(Func<int, bool>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.TakeWhile<int>(AsyncEnumerable.Return(42), default(Func<int, int, bool>)));
-        }
-
-        [Fact]
-        public void TakeWhile1()
-        {
-            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);
-        }
-
-        [Fact]
-        public void TakeWhile2()
-        {
-            var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
-            var ys = xs.TakeWhile(x => false);
-
-            var e = ys.GetAsyncEnumerator();
-            NoNext(e);
-        }
-
-        [Fact]
-        public void TakeWhile3()
-        {
-            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);
-        }
-
-        [Fact]
-        public void TakeWhile4()
-        {
-            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);
-        }
-
-        [Fact]
-        public void TakeWhile5()
-        {
-            var ex = new Exception("Bang");
-            var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
-            var ys = xs.TakeWhile(new Func<int, bool>(x => { throw ex; }));
-
-            var e = ys.GetAsyncEnumerator();
-            AssertThrows(() => e.MoveNextAsync().Wait(WaitTimeoutMs), (Exception ex_) => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
-        }
-
-        [Fact]
-        public void TakeWhile6()
-        {
-            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);
-        }
-
-        [Fact]
-        public void TakeWhile7()
-        {
-            var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
-            var ys = xs.TakeWhile((x, i) => false);
-
-            var e = ys.GetAsyncEnumerator();
-            NoNext(e);
-        }
-
-        [Fact]
-        public void TakeWhile8()
-        {
-            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);
-        }
-
-        [Fact]
-        public void TakeWhile9()
-        {
-            var ex = new Exception("Bang");
-            var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
-            var ys = xs.TakeWhile(new Func<int, int, bool>((x, i) => { throw ex; }));
-
-            var e = ys.GetAsyncEnumerator();
-            AssertThrows(() => e.MoveNextAsync().Wait(WaitTimeoutMs), (Exception ex_) => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
-        }
-
-
-        [Fact]
-        public async Task TakeWhile10()
-        {
-            var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
-            var ys = xs.TakeWhile(x => x < 3);
-
-            await SequenceIdentity(ys);
-        }
-
-        [Fact]
-        public async Task TakeWhile11()
-        {
-            var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
-            var ys = xs.TakeWhile((x, i) => i < 2);
-
-            await SequenceIdentity(ys);
-        }
-
-        [Fact]
-        public void SkipWhile_Null()
-        {
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SkipWhile<int>(null, x => true));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SkipWhile<int>(null, (x, i) => true));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SkipWhile<int>(AsyncEnumerable.Return(42), default(Func<int, bool>)));
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SkipWhile<int>(AsyncEnumerable.Return(42), default(Func<int, int, bool>)));
-        }
-
-        [Fact]
-        public void SkipWhile1()
-        {
-            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);
-        }
-
-        [Fact]
-        public void SkipWhile2()
-        {
-            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);
-        }
-
-        [Fact]
-        public void SkipWhile3()
-        {
-            var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
-            var ys = xs.SkipWhile(x => true);
-
-            var e = ys.GetAsyncEnumerator();
-            NoNext(e);
-        }
-
-        [Fact]
-        public void SkipWhile4()
-        {
-            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);
-        }
-
-        [Fact]
-        public void SkipWhile5()
-        {
-            var ex = new Exception("Bang");
-            var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
-            var ys = xs.SkipWhile(new Func<int, bool>(x => { throw ex; }));
-
-            var e = ys.GetAsyncEnumerator();
-            AssertThrows(() => e.MoveNextAsync().Wait(WaitTimeoutMs), (Exception ex_) => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
-        }
-
-        [Fact]
-        public void SkipWhile6()
-        {
-            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);
-        }
-
-        [Fact]
-        public void SkipWhile7()
-        {
-            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);
-        }
-
-        [Fact]
-        public void SkipWhile8()
-        {
-            var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
-            var ys = xs.SkipWhile((x, i) => true);
-
-            var e = ys.GetAsyncEnumerator();
-            NoNext(e);
-        }
-
-        [Fact]
-        public void SkipWhile9()
-        {
-            var ex = new Exception("Bang");
-            var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
-            var ys = xs.SkipWhile(new Func<int, int, bool>((x, i) => { throw ex; }));
-
-            var e = ys.GetAsyncEnumerator();
-            AssertThrows(() => e.MoveNextAsync().Wait(WaitTimeoutMs), (Exception ex_) => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
-        }
-
-        [Fact]
-        public async Task SkipWhile10()
-        {
-            var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
-            var ys = xs.SkipWhile(x => x < 3);
-
-            await SequenceIdentity(ys);
-        }
-
-        [Fact]
-        public async Task SkipWhile11()
-        {
-            var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
-            var ys = xs.SkipWhile((x, i) => false);
-
-            await SequenceIdentity(ys);
-        }
-
         [Fact]
         public void Distinct_Null()
         {
@@ -2653,118 +2382,5 @@ namespace Tests
             HasNext(e, 4);
             NoNext(e);
         }
-
-        [Fact]
-        public void TakeLast_Null()
-        {
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.TakeLast(default(IAsyncEnumerable<int>), 5));
-        }
-
-        [Fact]
-        public void TakeLast0()
-        {
-            var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().TakeLast(-2);
-
-            var e = xs.GetAsyncEnumerator();
-            NoNext(e);
-        }
-
-        [Fact]
-        public void TakeLast1()
-        {
-            var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().TakeLast(2);
-
-            var e = xs.GetAsyncEnumerator();
-            HasNext(e, 3);
-            HasNext(e, 4);
-            NoNext(e);
-        }
-
-        [Fact]
-        public void 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);
-        }
-
-        [Fact]
-        public async Task TakeLast3()
-        {
-            var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().TakeLast(2);
-
-            await SequenceIdentity(xs);
-        }
-
-        [Fact]
-        public void TakeLast_BugFix_TakeLast_Zero_TakesForever()
-        {
-            var isSet = false;
-            new int[] { 1, 2, 3, 4 }.ToAsyncEnumerable()
-                .TakeLast(0)
-                .ForEachAsync(_ => { isSet = true; })
-                .Wait(WaitTimeoutMs);
-
-            Assert.False(isSet);
-
-            var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().TakeLast(0);
-
-            var e = xs.GetAsyncEnumerator();
-
-            NoNext(e);
-        }
-
-        [Fact]
-        public void SkipLast_Null()
-        {
-            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SkipLast(default(IAsyncEnumerable<int>), 5));
-        }
-
-        [Fact]
-        public void SkipLast1()
-        {
-            var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().SkipLast(2);
-
-            var e = xs.GetAsyncEnumerator();
-            HasNext(e, 1);
-            HasNext(e, 2);
-            NoNext(e);
-        }
-
-        [Fact]
-        public void SkipLast2()
-        {
-            var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().SkipLast(5);
-
-            var e = xs.GetAsyncEnumerator();
-            NoNext(e);
-        }
-
-        [Fact]
-        public async Task SkipLast3()
-        {
-            var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().SkipLast(2);
-
-            await SequenceIdentity(xs);
-        }
-
-        [Fact]
-        public void SkipLast4()
-        {
-            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);
-        }
     }
 }

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

@@ -0,0 +1,63 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// 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.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace Tests
+{
+    public class SkipLast : AsyncEnumerableTests
+    {
+        [Fact]
+        public void SkipLast_Null()
+        {
+            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SkipLast(default(IAsyncEnumerable<int>), 5));
+        }
+
+        [Fact]
+        public void SkipLast1()
+        {
+            var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().SkipLast(2);
+
+            var e = xs.GetAsyncEnumerator();
+            HasNext(e, 1);
+            HasNext(e, 2);
+            NoNext(e);
+        }
+
+        [Fact]
+        public void SkipLast2()
+        {
+            var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().SkipLast(5);
+
+            var e = xs.GetAsyncEnumerator();
+            NoNext(e);
+        }
+
+        [Fact]
+        public async Task SkipLast3()
+        {
+            var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().SkipLast(2);
+
+            await SequenceIdentity(xs);
+        }
+
+        [Fact]
+        public void SkipLast4()
+        {
+            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);
+        }
+    }
+}

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

@@ -0,0 +1,150 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// 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
+{
+    public class SkipWhile : AsyncEnumerableTests
+    {
+        [Fact]
+        public void SkipWhile_Null()
+        {
+            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SkipWhile<int>(null, x => true));
+            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SkipWhile<int>(null, (x, i) => true));
+            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SkipWhile<int>(AsyncEnumerable.Return(42), default(Func<int, bool>)));
+            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SkipWhile<int>(AsyncEnumerable.Return(42), default(Func<int, int, bool>)));
+        }
+
+        [Fact]
+        public void SkipWhile1()
+        {
+            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);
+        }
+
+        [Fact]
+        public void SkipWhile2()
+        {
+            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);
+        }
+
+        [Fact]
+        public void SkipWhile3()
+        {
+            var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
+            var ys = xs.SkipWhile(x => true);
+
+            var e = ys.GetAsyncEnumerator();
+            NoNext(e);
+        }
+
+        [Fact]
+        public void SkipWhile4()
+        {
+            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);
+        }
+
+        [Fact]
+        public void SkipWhile5()
+        {
+            var ex = new Exception("Bang");
+            var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
+            var ys = xs.SkipWhile(new Func<int, bool>(x => { throw ex; }));
+
+            var e = ys.GetAsyncEnumerator();
+            AssertThrows(() => e.MoveNextAsync().Wait(WaitTimeoutMs), (Exception ex_) => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+        }
+
+        [Fact]
+        public void SkipWhile6()
+        {
+            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);
+        }
+
+        [Fact]
+        public void SkipWhile7()
+        {
+            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);
+        }
+
+        [Fact]
+        public void SkipWhile8()
+        {
+            var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
+            var ys = xs.SkipWhile((x, i) => true);
+
+            var e = ys.GetAsyncEnumerator();
+            NoNext(e);
+        }
+
+        [Fact]
+        public void SkipWhile9()
+        {
+            var ex = new Exception("Bang");
+            var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
+            var ys = xs.SkipWhile(new Func<int, int, bool>((x, i) => { throw ex; }));
+
+            var e = ys.GetAsyncEnumerator();
+            AssertThrows(() => e.MoveNextAsync().Wait(WaitTimeoutMs), (Exception ex_) => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+        }
+
+        [Fact]
+        public async Task SkipWhile10()
+        {
+            var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
+            var ys = xs.SkipWhile(x => x < 3);
+
+            await SequenceIdentity(ys);
+        }
+
+        [Fact]
+        public async Task SkipWhile11()
+        {
+            var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
+            var ys = xs.SkipWhile((x, i) => false);
+
+            await SequenceIdentity(ys);
+        }
+    }
+}

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

@@ -0,0 +1,80 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// 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.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace Tests
+{
+    public class TakeLast : AsyncEnumerableTests
+    {
+        [Fact]
+        public void TakeLast_Null()
+        {
+            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.TakeLast(default(IAsyncEnumerable<int>), 5));
+        }
+
+        [Fact]
+        public void TakeLast0()
+        {
+            var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().TakeLast(-2);
+
+            var e = xs.GetAsyncEnumerator();
+            NoNext(e);
+        }
+
+        [Fact]
+        public void TakeLast1()
+        {
+            var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().TakeLast(2);
+
+            var e = xs.GetAsyncEnumerator();
+            HasNext(e, 3);
+            HasNext(e, 4);
+            NoNext(e);
+        }
+
+        [Fact]
+        public void 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);
+        }
+
+        [Fact]
+        public async Task TakeLast3()
+        {
+            var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().TakeLast(2);
+
+            await SequenceIdentity(xs);
+        }
+
+        [Fact]
+        public void TakeLast_BugFix_TakeLast_Zero_TakesForever()
+        {
+            var isSet = false;
+            new int[] { 1, 2, 3, 4 }.ToAsyncEnumerable()
+                .TakeLast(0)
+                .ForEachAsync(_ => { isSet = true; })
+                .Wait(WaitTimeoutMs);
+
+            Assert.False(isSet);
+
+            var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().TakeLast(0);
+
+            var e = xs.GetAsyncEnumerator();
+
+            NoNext(e);
+        }
+    }
+}

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

@@ -0,0 +1,148 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// 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
+{
+    public class TakeWhile : AsyncEnumerableTests
+    {
+        [Fact]
+        public void TakeWhile_Null()
+        {
+            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.TakeWhile<int>(null, x => true));
+            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.TakeWhile<int>(null, (x, i) => true));
+            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.TakeWhile<int>(AsyncEnumerable.Return(42), default(Func<int, bool>)));
+            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.TakeWhile<int>(AsyncEnumerable.Return(42), default(Func<int, int, bool>)));
+        }
+
+        [Fact]
+        public void TakeWhile1()
+        {
+            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);
+        }
+
+        [Fact]
+        public void TakeWhile2()
+        {
+            var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
+            var ys = xs.TakeWhile(x => false);
+
+            var e = ys.GetAsyncEnumerator();
+            NoNext(e);
+        }
+
+        [Fact]
+        public void TakeWhile3()
+        {
+            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);
+        }
+
+        [Fact]
+        public void TakeWhile4()
+        {
+            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);
+        }
+
+        [Fact]
+        public void TakeWhile5()
+        {
+            var ex = new Exception("Bang");
+            var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
+            var ys = xs.TakeWhile(new Func<int, bool>(x => { throw ex; }));
+
+            var e = ys.GetAsyncEnumerator();
+            AssertThrows(() => e.MoveNextAsync().Wait(WaitTimeoutMs), (Exception ex_) => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+        }
+
+        [Fact]
+        public void TakeWhile6()
+        {
+            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);
+        }
+
+        [Fact]
+        public void TakeWhile7()
+        {
+            var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
+            var ys = xs.TakeWhile((x, i) => false);
+
+            var e = ys.GetAsyncEnumerator();
+            NoNext(e);
+        }
+
+        [Fact]
+        public void TakeWhile8()
+        {
+            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);
+        }
+
+        [Fact]
+        public void TakeWhile9()
+        {
+            var ex = new Exception("Bang");
+            var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
+            var ys = xs.TakeWhile(new Func<int, int, bool>((x, i) => { throw ex; }));
+
+            var e = ys.GetAsyncEnumerator();
+            AssertThrows(() => e.MoveNextAsync().Wait(WaitTimeoutMs), (Exception ex_) => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
+        }
+
+
+        [Fact]
+        public async Task TakeWhile10()
+        {
+            var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
+            var ys = xs.TakeWhile(x => x < 3);
+
+            await SequenceIdentity(ys);
+        }
+
+        [Fact]
+        public async Task TakeWhile11()
+        {
+            var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
+            var ys = xs.TakeWhile((x, i) => i < 2);
+
+            await SequenceIdentity(ys);
+        }
+    }
+}