Add more tests

Ix.NET/Source/Tests/AsyncTests.Creation.cs

@@ -14,6 +14,27 @@ namespace Tests
 {
     public partial class AsyncTests
     {
+
+        [Fact]
+        public void Create_Null()
+        {
+            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.CreateEnumerable<int>(null));
+            AssertThrows<ArgumentNullException>(() => AsyncEnumerable.CreateEnumerator<int>(null, () => 3, () => {}));
+       
+        }
+
+        [Fact]
+        public void Create_Iterator_Throws()
+        {
+     
+           var iter = AsyncEnumerable.CreateEnumerator<int>(c => Task.FromResult(true), () => 3, () => { });
+
+            var enu = (IAsyncEnumerable<int>)iter;
+
+            AssertThrows<NotSupportedException>(() => enu.GetEnumerator());
+        }
+
+
         [Fact]
         public void Return()
         {
@@ -32,6 +53,13 @@ namespace Tests
             e.Dispose();
         }
 
+        [Fact]
+        public async Task Empty_Null()
+        {
+           await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.IsEmpty<int>(null));
+           await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.IsEmpty<int>(null, CancellationToken.None));
+        }
+
         [Fact]
         public void Empty1()
         {
@@ -231,6 +259,14 @@ namespace Tests
             AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).InnerExceptions.Single() == ex);
         }
 
+        [Fact]
+        public async Task Generate5()
+        {
+            var xs = AsyncEnumerable.Generate(0, x => x < 5, x => x + 1, x => x * x);
+
+            await SequenceIdentity(xs);
+        }
+
         [Fact]
         public void Using_Null()
         {
@@ -398,6 +434,24 @@ namespace Tests
             Assert.True(await disposed.Task);
         }
 
+        [Fact]
+        public async Task Using7()
+        {
+            var i = 0;
+            var d = 0;
+
+            var xs = AsyncEnumerable.Using(
+                () =>
+                {
+                    i++;
+                    return new MyD(() => { d++; });
+                },
+                _ => AsyncEnumerable.Return(42)
+            );
+
+            await SequenceIdentity(xs);
+        }
+
         class MyD : IDisposable
         {
             private readonly Action _dispose;

Ix.NET/Source/Tests/AsyncTests.Exceptions.cs

@@ -284,6 +284,20 @@ namespace Tests
             await SequenceIdentity(res);
         }
 
+        [Fact]
+        public async Task Catch14()
+        {
+            var err = false;
+            var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
+            var ys = new[] { 4, 5, 6 }.ToAsyncEnumerable();
+
+            var res = xs.Catch<int, Exception>(ex_ => { err = true; return ys; });
+
+            await SequenceIdentity(res);
+
+            Assert.False(err);
+        }
+
         [Fact]
         public void Finally_Null()
         {
@@ -398,6 +412,17 @@ namespace Tests
         }
 
         [Fact]
+        public async Task Finally7()
+        {
+            var i = 0;
+            var xs = new[] { 1, 2 }.ToAsyncEnumerable().Finally(() => { i++; });
+
+            await SequenceIdentity(xs);
+            Assert.Equal(2, i);
+        }
+    
+
+    [Fact]
         public void OnErrorResumeNext_Null()
         {
             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.OnErrorResumeNext<int>(default(IAsyncEnumerable<int>), AsyncEnumerable.Return(42)));
@@ -517,6 +542,17 @@ namespace Tests
             NoNext(e);
         }
 
+        [Fact]
+        public async Task OnErrorResumeNext13()
+        {
+            var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
+            var ys = new[] { 4, 5, 6 }.ToAsyncEnumerable();
+
+            var res = AsyncEnumerable.OnErrorResumeNext(xs, ys);
+
+            await SequenceIdentity(res);
+        }
+
         [Fact]
         public void Retry_Null()
         {

Ix.NET/Source/Tests/AsyncTests.Multiple.cs

@@ -297,6 +297,16 @@ namespace Tests
             AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
+        [Fact]
+        public async Task Zip7()
+        {
+            var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
+            var ys = new[] { 4, 5, 6 }.ToAsyncEnumerable();
+            var res = xs.Zip(ys, (x, y) => x * y);
+
+            await SequenceIdentity(res);
+        }
+
         [Fact]
         public void Union_Null()
         {
@@ -377,6 +387,17 @@ namespace Tests
             NoNext(e);
         }
 
+        [Fact]
+        public async Task Intersect3()
+        {
+            var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
+            var ys = new[] { 3, 5, 1, 4 }.ToAsyncEnumerable();
+            var res = xs.Intersect(ys);
+
+            await SequenceIdentity(res);
+        }
+
+
         [Fact]
         public void Except_Null()
         {
@@ -412,6 +433,16 @@ namespace Tests
             NoNext(e);
         }
 
+        [Fact]
+        public async Task Except3()
+        {
+            var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
+            var ys = new[] { 3, 5, 1, 4 }.ToAsyncEnumerable();
+            var res = xs.Except(ys);
+
+            await SequenceIdentity(res);
+        }
+
         [Fact]
         public async Task SequenceEqual_Null()
         {
@@ -848,6 +879,18 @@ namespace Tests
             AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
+        [Fact]
+        public async Task Join10()
+        {
+            var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable();
+            var ys = new[] { 3, 6, 4 }.ToAsyncEnumerable();
+
+            var res = xs.Join(ys, x => x % 3, y => y % 3, (x, y) => x + y);
+
+            await SequenceIdentity(res);
+        }
+
+
         [Fact]
         public void SelectManyMultiple_Null()
         {

Ix.NET/Source/Tests/AsyncTests.Single.cs

@@ -115,6 +115,25 @@ namespace Tests
             HasNext(e, 'f');
         }
 
+        [Fact]
+        public async Task Select7()
+        {
+            var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable();
+            var ys = xs.Select(x => (char)('a' + x));
+
+            await SequenceIdentity(ys);
+        }
+
+        [Fact]
+        public async Task Select8()
+        {
+            var xs = new[] { 8, 5, 7 }.ToAsyncEnumerable();
+            var ys = xs.Select((x, i) => (char)('a' + i));
+
+            await SequenceIdentity(ys);
+        }
+
+
         [Fact]
         public void SelectWhere1()
         {
@@ -165,6 +184,27 @@ namespace Tests
             NoNext(e);
         }
 
+        [Fact]
+        public void WhereSelect3()
+        {
+            var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable();
+            var ys = xs.Where(i => i % 2 == 0).Select(i => i + 2).Select(i => i + 2);
+
+            var e = ys.GetEnumerator();
+            HasNext(e, 4);
+            HasNext(e, 6);
+            NoNext(e);
+        }
+
+        [Fact]
+        public async Task WhereSelect4()
+        {
+            var xs = new CancellationTestAsyncEnumerable().Take(5);
+            var ys = xs.Where(i => i % 2 == 0).Select(i => i + 2);
+
+            await SequenceIdentity(ys);
+        }
+
         [Fact]
         public void Where_Null()
         {
@@ -253,6 +293,37 @@ namespace Tests
             AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
+
+        [Fact]
+        public void Where7()
+        {
+            var xs = new[] { 8, 5, 7, 4, 6, 9, 2, 1, 0 }.ToAsyncEnumerable();
+            var ys = xs.Where(x => x % 2 == 0).Where(x => x > 5);
+            var e = ys.GetEnumerator();
+            HasNext(e, 8);
+            HasNext(e, 6);
+            NoNext(e);
+        }
+
+        [Fact]
+        public async Task Where8()
+        {
+            var xs = new[] { 8, 5, 7, 4, 6, 9, 2, 1, 0 }.ToAsyncEnumerable();
+            var ys = xs.Where(x => x % 2 == 0);
+            
+            await SequenceIdentity(ys);
+        }
+
+        [Fact]
+        public async Task Where9()
+        {
+            var xs = new[] { 8, 5, 7, 4, 6, 9, 2, 1, 0 }.ToAsyncEnumerable();
+            var ys = xs.Where((x, i) => i % 2 == 0);
+
+            await SequenceIdentity(ys);
+        }
+
+
         [Fact]
         public void SelectMany_Null()
         {
@@ -474,6 +545,42 @@ namespace Tests
             AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
+        [Fact]
+        public async Task SelectMany13()
+        {
+            var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
+            var ys = xs.SelectMany(x => Enumerable.Range(0, x).ToAsyncEnumerable());
+
+            await SequenceIdentity(ys);
+        }
+
+        [Fact]
+        public async Task SelectMany14()
+        {
+            var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
+            var ys = xs.SelectMany((x, i) => Enumerable.Range(i + 5, x).ToAsyncEnumerable());
+
+            await SequenceIdentity(ys);
+        }
+
+        [Fact]
+        public async Task SelectMany15()
+        {
+            var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
+            var ys = xs.SelectMany(x => Enumerable.Range(3, x).ToAsyncEnumerable(), (x, y) => x * y);
+
+            await SequenceIdentity(ys);
+        }
+
+        [Fact]
+        public async Task SelectMany16()
+        {
+            var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
+            var ys = xs.SelectMany((x, i) => Enumerable.Range(i + 3, x).ToAsyncEnumerable(), (x, y) => x * y);
+
+            await SequenceIdentity(ys);
+        }
+
         [Fact]
         public void OfType_Null()
         {
@@ -672,6 +779,18 @@ namespace Tests
             Assert.Same(exa, ex);
         }
 
+        [Fact]
+        public async Task Do7()
+        {
+            var sum = 0;
+            var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
+            var ys = xs.Do(x => sum += x);
+
+            await SequenceIdentity(ys);
+
+            Assert.Equal(20, sum);
+        }
+
         [Fact]
         public async Task ForEachAsync_Null()
         {
@@ -875,6 +994,15 @@ namespace Tests
             AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
+        [Fact]
+        public async Task Take5()
+        {
+            var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
+            var ys = xs.Take(2);
+
+            await SequenceIdentity(ys);
+        }
+
         [Fact]
         public void TakeWhile_Null()
         {
@@ -990,6 +1118,16 @@ namespace Tests
             AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), 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 void Skip_Null()
         {
@@ -1053,6 +1191,15 @@ namespace Tests
             AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
+        [Fact]
+        public async Task Skip5()
+        {
+            var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
+            var ys = xs.Skip(2);
+
+            await SequenceIdentity(ys);
+        }
+
         [Fact]
         public void SkipWhile_Null()
         {
@@ -1171,6 +1318,24 @@ namespace Tests
             AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), 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 DefaultIfEmpty_Null()
         {
@@ -2821,6 +2986,14 @@ namespace Tests
             AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
+        [Fact]
+        public async Task IgnoreElements5()
+        {
+            var xs = AsyncEnumerable.Range(0, 10).IgnoreElements();
+
+            await SequenceIdentity(xs);
+        }
+
         [Fact]
         public void StartWith_Null()
         {
@@ -3126,6 +3299,14 @@ namespace Tests
             await SequenceIdentity(xs);
         }
 
+        [Fact]
+        public async Task Scan6()
+        {
+            var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable().Scan((x, y) => x + y);
+
+            await SequenceIdentity(xs);
+        }
+
         [Fact]
         public void DistinctKey_Null()
         {