Skip code coverage.

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

@@ -17,18 +17,20 @@ namespace Tests
             Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.Skip<int>(default, 5));
         }
 
-        //[Fact]
-        //public void Skip0()
-        //{
-        //    var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
-        //    var ys = xs.Skip(-2);
+        [Fact]
+        public async Task Skip_Simple_SkipSome()
+        {
+            var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().Where(x => true);
+            var ys = xs.Skip(2);
 
-        //    var e = ys.GetEnumerator();
-        //    await NoNextAsync(e);
-        //}
+            var e = ys.GetAsyncEnumerator();
+            await HasNextAsync(e, 3);
+            await HasNextAsync(e, 4);
+            await NoNextAsync(e);
+        }
 
         [Fact]
-        public async Task Skip1()
+        public async Task Skip_Simple_SkipSome_IList()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
             var ys = xs.Skip(2);
@@ -40,7 +42,17 @@ namespace Tests
         }
 
         [Fact]
-        public async Task Skip2()
+        public async Task Skip_Simple_SkipAll()
+        {
+            var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().Where(x => true);
+            var ys = xs.Skip(10);
+
+            var e = ys.GetAsyncEnumerator();
+            await NoNextAsync(e);
+        }
+
+        [Fact]
+        public async Task Skip_Simple_SkipAll_IList()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
             var ys = xs.Skip(10);
@@ -50,7 +62,21 @@ namespace Tests
         }
 
         [Fact]
-        public async Task Skip3()
+        public async Task Skip_Simple_SkipNone()
+        {
+            var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().Where(x => true);
+            var ys = xs.Skip(0);
+
+            var e = ys.GetAsyncEnumerator();
+            await HasNextAsync(e, 1);
+            await HasNextAsync(e, 2);
+            await HasNextAsync(e, 3);
+            await HasNextAsync(e, 4);
+            await NoNextAsync(e);
+        }
+
+        [Fact]
+        public async Task Skip_Simple_SkipNone_IList()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
             var ys = xs.Skip(0);
@@ -64,7 +90,7 @@ namespace Tests
         }
 
         [Fact]
-        public async Task Skip4Async()
+        public async Task Skip_Throws_Source()
         {
             var ex = new Exception("Bang");
             var xs = Throw<int>(ex);
@@ -75,12 +101,102 @@ namespace Tests
         }
 
         [Fact]
-        public async Task Skip5()
+        public async Task Skip_SequenceIdentity()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
             var ys = xs.Skip(2);
 
             await SequenceIdentity(ys);
         }
+
+        [Fact]
+        public async Task Skip_IAsyncPartition_NonEmpty_Skip()
+        {
+            var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().Where(x => true);
+            var ys = xs.Skip(2);
+
+            Assert.Equal(2, await ys.CountAsync());
+
+            Assert.Equal(3, await ys.FirstAsync());
+            Assert.Equal(4, await ys.LastAsync());
+
+            Assert.Equal(3, await ys.ElementAtAsync(0));
+            Assert.Equal(4, await ys.ElementAtAsync(1));
+
+            Assert.Equal(new[] { 3, 4 }, await ys.ToArrayAsync());
+            Assert.Equal(new[] { 3, 4 }, await ys.ToListAsync());
+        }
+
+        [Fact]
+        public async Task Skip_IAsyncPartition_NonEmpty_SkipSkip()
+        {
+            var xs = new[] { -2, -1, 0, 1, 2, 3, 4 }.ToAsyncEnumerable().Where(x => true);
+            var ys = xs.Skip(2).Skip(3);
+
+            Assert.Equal(2, await ys.CountAsync());
+
+            Assert.Equal(3, await ys.FirstAsync());
+            Assert.Equal(4, await ys.LastAsync());
+
+            Assert.Equal(3, await ys.ElementAtAsync(0));
+            Assert.Equal(4, await ys.ElementAtAsync(1));
+
+            Assert.Equal(new[] { 3, 4 }, await ys.ToArrayAsync());
+            Assert.Equal(new[] { 3, 4 }, await ys.ToListAsync());
+        }
+
+        [Fact]
+        public async Task Skip_IAsyncPartition_NonEmpty_SkipTake()
+        {
+            var xs = new[] { 2, 3, 4, 5 }.ToAsyncEnumerable().Where(x => true);
+            var ys = xs.Skip(1).Take(2);
+
+            Assert.Equal(2, await ys.CountAsync());
+
+            Assert.Equal(3, await ys.FirstAsync());
+            Assert.Equal(4, await ys.LastAsync());
+
+            Assert.Equal(3, await ys.ElementAtAsync(0));
+            Assert.Equal(4, await ys.ElementAtAsync(1));
+
+            Assert.Equal(new[] { 3, 4 }, await ys.ToArrayAsync());
+            Assert.Equal(new[] { 3, 4 }, await ys.ToListAsync());
+        }
+
+        [Fact]
+        public async Task Skip_IAsyncPartition_Empty_Skip()
+        {
+            var xs = new int[0].ToAsyncEnumerable().Where(x => true);
+            var ys = xs.Skip(2);
+
+            Assert.Equal(0, await ys.CountAsync());
+
+            await AssertThrowsAsync<InvalidOperationException>(ys.FirstAsync().AsTask());
+            await AssertThrowsAsync<InvalidOperationException>(ys.LastAsync().AsTask());
+
+            await AssertThrowsAsync<ArgumentOutOfRangeException>(ys.ElementAtAsync(0).AsTask());
+            await AssertThrowsAsync<ArgumentOutOfRangeException>(ys.ElementAtAsync(1).AsTask());
+
+            Assert.Empty(await ys.ToArrayAsync());
+            Assert.Empty(await ys.ToListAsync());
+        }
+
+        [Fact]
+        public async Task Skip_IAsyncPartition_Empty_SkipSkip()
+        {
+            var xs = new[] { 1, 2 }.ToAsyncEnumerable().Where(x => true);
+            var ys = xs.Skip(2);
+
+            Assert.Equal(0, await ys.CountAsync());
+
+            await AssertThrowsAsync<InvalidOperationException>(ys.FirstAsync().AsTask());
+            await AssertThrowsAsync<InvalidOperationException>(ys.LastAsync().AsTask());
+
+            await AssertThrowsAsync<ArgumentOutOfRangeException>(ys.ElementAtAsync(0).AsTask());
+            await AssertThrowsAsync<ArgumentOutOfRangeException>(ys.ElementAtAsync(1).AsTask());
+
+            Assert.Empty(await ys.ToArrayAsync());
+            Assert.Empty(await ys.ToListAsync());
+        }
     }
 }