Add more tests for Select optimization for IList.

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

@@ -254,6 +254,33 @@ namespace Tests
             await SequenceIdentity(ys);
         }
 
+        [Fact]
+        public async Task Select_Sync_IList_Count()
+        {
+            var xs = ToAsyncEnumerableIList(new[] { 1, 2, 3, 4, 5 });
+            var ys = xs.Select(x => x * 2);
+
+            Assert.Equal(5, await ys.CountAsync());
+        }
+
+        [Fact]
+        public async Task Select_Sync_IList_ToList()
+        {
+            var xs = ToAsyncEnumerableIList(new[] { 1, 2, 3, 4, 5 });
+            var ys = xs.Select(x => x * 2);
+
+            Assert.Equal(new[] { 2, 4, 6, 8, 10 }, await ys.ToListAsync());
+        }
+
+        [Fact]
+        public async Task Select_Sync_IList_ToArray()
+        {
+            var xs = ToAsyncEnumerableIList(new[] { 1, 2, 3, 4, 5 });
+            var ys = xs.Select(x => x * 2);
+
+            Assert.Equal(new[] { 2, 4, 6, 8, 10 }, await ys.ToArrayAsync());
+        }
+
         [Fact]
         public void Select_Async_Null()
         {
@@ -494,6 +521,33 @@ namespace Tests
             await SequenceIdentity(ys);
         }
 
+        [Fact]
+        public async Task Select_Async_IList_Count()
+        {
+            var xs = ToAsyncEnumerableIList(new[] { 1, 2, 3, 4, 5 });
+            var ys = xs.Select(x => new ValueTask<int>(x * 2));
+
+            Assert.Equal(5, await ys.CountAsync());
+        }
+
+        [Fact]
+        public async Task Select_Async_IList_ToList()
+        {
+            var xs = ToAsyncEnumerableIList(new[] { 1, 2, 3, 4, 5 });
+            var ys = xs.Select(x => new ValueTask<int>(x * 2));
+
+            Assert.Equal(new[] { 2, 4, 6, 8, 10 }, await ys.ToListAsync());
+        }
+
+        [Fact]
+        public async Task Select_Async_IList_ToArray()
+        {
+            var xs = ToAsyncEnumerableIList(new[] { 1, 2, 3, 4, 5 });
+            var ys = xs.Select(x => new ValueTask<int>(x * 2));
+
+            Assert.Equal(new[] { 2, 4, 6, 8, 10 }, await ys.ToArrayAsync());
+        }
+
 #if !NO_DEEP_CANCELLATION
 
         // REVIEW: These overloads are problematic for type inference. E.g. xs.Select((x, ct) => ...) is ambiguous.
@@ -738,6 +792,33 @@ namespace Tests
             await SequenceIdentity(ys);
         }
 
+        [Fact]
+        public async Task Select_Async_Cancel_IList_Count()
+        {
+            var xs = ToAsyncEnumerableIList(new[] { 1, 2, 3, 4, 5 });
+            var ys = xs.Select((int x, CancellationToken ct) => new ValueTask<int>(x * 2));
+
+            Assert.Equal(5, await ys.CountAsync());
+        }
+
+        [Fact]
+        public async Task Select_Async_Cancel_IList_ToList()
+        {
+            var xs = ToAsyncEnumerableIList(new[] { 1, 2, 3, 4, 5 });
+            var ys = xs.Select((int x, CancellationToken ct) => new ValueTask<int>(x * 2));
+
+            Assert.Equal(new[] { 2, 4, 6, 8, 10 }, await ys.ToListAsync());
+        }
+
+        [Fact]
+        public async Task Select_Async_Cancel_IList_ToArray()
+        {
+            var xs = ToAsyncEnumerableIList(new[] { 1, 2, 3, 4, 5 });
+            var ys = xs.Select((int x, CancellationToken ct) => new ValueTask<int>(x * 2));
+
+            Assert.Equal(new[] { 2, 4, 6, 8, 10 }, await ys.ToArrayAsync());
+        }
+
 #endif
 
         private static IAsyncEnumerable<int> ToAsyncEnumerable(int[] xs) => new MyIterator(xs);