SequenceEqualAsync code coverage.

bartdesmet · bartdesmet · commit 29803648e6a8 · 2019-02-19T22:44:20.000-08:00
diff --git a/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/SequenceEqual.cs b/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/SequenceEqual.cs
@@ -14,7 +14,7 @@ namespace Tests
     public class SequenceEqual : AsyncEnumerableTests
     {
         [Fact]
-        public async Task SequenceEqual_Null()
+        public async Task SequenceEqualAsync_Null()
         {
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SequenceEqualAsync(default, Return42).AsTask());
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SequenceEqualAsync(Return42, default).AsTask());
@@ -30,23 +30,40 @@ public async Task SequenceEqual_Null()
         }
 
         [Fact]
-        public async Task SequenceEqual1Async()
+        public async Task SequenceEqualAsync_Same()
+        {
+            var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable().Select(x => x);
+            var res = xs.SequenceEqualAsync(xs);
+            Assert.True(await res);
+        }
+
+        [Fact]
+        public async Task SequenceEqualAsync_Same_IList()
         {
             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
             var res = xs.SequenceEqualAsync(xs);
             Assert.True(await res);
         }
 
         [Fact]
-        public async Task SequenceEqual2Async()
+        public async Task SequenceEqualAsync_Same_Empty()
         {
             var xs = AsyncEnumerable.Empty<int>();
             var res = xs.SequenceEqualAsync(xs);
             Assert.True(await res);
         }
 
         [Fact]
-        public async Task SequenceEqual3Async()
+        public async Task SequenceEqualAsync_NotSame()
+        {
+            var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable().Select(x => x);
+            var ys = new[] { 1, 3, 2 }.ToAsyncEnumerable().Select(x => x);
+            var res = xs.SequenceEqualAsync(ys);
+            Assert.False(await res);
+        }
+
+        [Fact]
+        public async Task SequenceEqualAsync_NotSame_IList()
         {
             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
             var ys = new[] { 1, 3, 2 }.ToAsyncEnumerable();
@@ -55,7 +72,7 @@ public async Task SequenceEqual3Async()
         }
 
         [Fact]
-        public async Task SequenceEqual4Async()
+        public async Task SequenceEqualAsync_NotSame_DifferentLength()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
             var ys = new[] { 1, 2, 3 }.ToAsyncEnumerable();
@@ -64,16 +81,16 @@ public async Task SequenceEqual4Async()
         }
 
         [Fact]
-        public async Task SequenceEqual5Async()
+        public async Task SequenceEqualAsync_NotSame_DifferentLength_IList()
         {
-            var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
-            var ys = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
+            var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable().Select(x => x);
+            var ys = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().Select(x => x);
             var res = xs.SequenceEqualAsync(ys);
             Assert.False(await res);
         }
 
         [Fact]
-        public async Task SequenceEqual6Async()
+        public async Task SequenceEqualAsync_Throws_Second()
         {
             var ex = new Exception("Bang!");
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
@@ -84,7 +101,7 @@ public async Task SequenceEqual6Async()
         }
 
         [Fact]
-        public async Task SequenceEqual7Async()
+        public async Task SequenceEqualAsync_Throws_First()
         {
             var ex = new Exception("Bang!");
             var xs = Throw<int>(ex);
@@ -95,23 +112,41 @@ public async Task SequenceEqual7Async()
         }
 
         [Fact]
-        public async Task SequenceEqual8Async()
+        public async Task SequenceEqualAsync_Comparer_Empty()
         {
-            var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
+            var xs = AsyncEnumerable.Empty<int>();
             var res = xs.SequenceEqualAsync(xs, new Eq());
             Assert.True(await res);
         }
 
         [Fact]
-        public async Task SequenceEqual9Async()
+        public async Task SequenceEqualAsync_Comparer_Same1()
         {
-            var xs = AsyncEnumerable.Empty<int>();
+            var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
             var res = xs.SequenceEqualAsync(xs, new Eq());
             Assert.True(await res);
         }
 
         [Fact]
-        public async Task SequenceEqual10Async()
+        public async Task SequenceEqualAsync_Comparer_Same2()
+        {
+            var xs = new[] { 1, 2, -3, 4 }.ToAsyncEnumerable().Select(x => x);
+            var ys = new[] { 1, -2, 3, 4 }.ToAsyncEnumerable().Select(x => x);
+            var res = xs.SequenceEqualAsync(ys, new Eq());
+            Assert.True(await res);
+        }
+
+        [Fact]
+        public async Task SequenceEqualAsync_Comparer_NotSame()
+        {
+            var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable().Select(x => x);
+            var ys = new[] { 1, 3, 2 }.ToAsyncEnumerable().Select(x => x);
+            var res = xs.SequenceEqualAsync(ys, new Eq());
+            Assert.False(await res);
+        }
+
+        [Fact]
+        public async Task SequenceEqualAsync_Comparer_NotSame_IList()
         {
             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
             var ys = new[] { 1, 3, 2 }.ToAsyncEnumerable();
@@ -120,16 +155,16 @@ public async Task SequenceEqual10Async()
         }
 
         [Fact]
-        public async Task SequenceEqual11Async()
+        public async Task SequenceEqualAsync_Comparer_NotSame_DifferentLength()
         {
-            var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
-            var ys = new[] { 1, 2, 3 }.ToAsyncEnumerable();
+            var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().Select(x => x);
+            var ys = new[] { 1, 2, 3 }.ToAsyncEnumerable().Select(x => x);
             var res = xs.SequenceEqualAsync(ys, new Eq());
             Assert.False(await res);
         }
 
         [Fact]
-        public async Task SequenceEqual12Async()
+        public async Task SequenceEqualAsync_Comparer_NotSame_DifferentLength_IList()
         {
             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
             var ys = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
@@ -138,7 +173,7 @@ public async Task SequenceEqual12Async()
         }
 
         [Fact]
-        public async Task SequenceEqual13Async()
+        public async Task SequenceEqualAsync_Comparer_Throws_Second()
         {
             var ex = new Exception("Bang!");
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
@@ -149,7 +184,7 @@ public async Task SequenceEqual13Async()
         }
 
         [Fact]
-        public async Task SequenceEqual14Async()
+        public async Task SequenceEqualAsync_Comparer_Throws_First()
         {
             var ex = new Exception("Bang!");
             var xs = Throw<int>(ex);
@@ -160,7 +195,7 @@ public async Task SequenceEqual14Async()
         }
 
         [Fact]
-        public async Task SequenceEqual15Async()
+        public async Task SequenceEqualAsync_Comparer_Same_IList()
         {
             var xs = new[] { 1, 2, -3, 4 }.ToAsyncEnumerable();
             var ys = new[] { 1, -2, 3, 4 }.ToAsyncEnumerable();
@@ -169,15 +204,15 @@ public async Task SequenceEqual15Async()
         }
 
         [Fact]
-        public async Task SequenceEqual16Async()
+        public async Task SequenceEqualAsync_Comparer_Throws_Equals_IList()
         {
             var xs = new[] { 1, 2, -3, 4 }.ToAsyncEnumerable();
-            var ys = new[] { 1, -2, 3, 4 }.ToAsyncEnumerable(); // NB: Implements IList<T>, resulting in optimized code path.
+            var ys = new[] { 1, -2, 3, 4 }.ToAsyncEnumerable();
             await Assert.ThrowsAsync<NotImplementedException>(() => xs.SequenceEqualAsync(ys, new EqEx()).AsTask());
         }
 
         [Fact]
-        public async Task SequenceEqual17Async()
+        public async Task SequenceEqualAsync_Comparer_Throws_Equals()
         {
             var xs = new[] { 1, 2, -3, 4 }.Select(x => x * 2).ToAsyncEnumerable();
             var ys = new[] { 1, -2, 3, 4 }.Select(x => x * 2).ToAsyncEnumerable();
@@ -194,7 +229,7 @@ public bool Equals(int x, int y)
 
             public int GetHashCode(int obj)
             {
-                throw new NotImplementedException();
+                throw new NotSupportedException();
             }
         }
 

Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@ namespace Tests`
`14`	`14`	`public class SequenceEqual : AsyncEnumerableTests`
`15`	`15`	`{`
`16`	`16`	`[Fact]`
`17`		`- public async Task SequenceEqual_Null()`
	`17`	`+ public async Task SequenceEqualAsync_Null()`
`18`	`18`	`{`
`19`	`19`	`await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SequenceEqualAsync(default, Return42).AsTask());`
`20`	`20`	`await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SequenceEqualAsync(Return42, default).AsTask());`
`@@ -30,23 +30,40 @@ public async Task SequenceEqual_Null()`
`30`	`30`	`}`
`31`	`31`
`32`	`32`	`[Fact]`
`33`		`- public async Task SequenceEqual1Async()`
	`33`	`+ public async Task SequenceEqualAsync_Same()`
	`34`	`+ {`
	`35`	`+ var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable().Select(x => x);`
	`36`	`+ var res = xs.SequenceEqualAsync(xs);`
	`37`	`+ Assert.True(await res);`
	`38`	`+ }`
	`39`	`+`
	`40`	`+ [Fact]`
	`41`	`+ public async Task SequenceEqualAsync_Same_IList()`
`34`	`42`	`{`
`35`	`43`	`var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();`
`36`	`44`	`var res = xs.SequenceEqualAsync(xs);`
`37`	`45`	`Assert.True(await res);`
`38`	`46`	`}`
`39`	`47`
`40`	`48`	`[Fact]`
`41`		`- public async Task SequenceEqual2Async()`
	`49`	`+ public async Task SequenceEqualAsync_Same_Empty()`
`42`	`50`	`{`
`43`	`51`	`var xs = AsyncEnumerable.Empty<int>();`
`44`	`52`	`var res = xs.SequenceEqualAsync(xs);`
`45`	`53`	`Assert.True(await res);`
`46`	`54`	`}`
`47`	`55`
`48`	`56`	`[Fact]`
`49`		`- public async Task SequenceEqual3Async()`
	`57`	`+ public async Task SequenceEqualAsync_NotSame()`
	`58`	`+ {`
	`59`	`+ var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable().Select(x => x);`
	`60`	`+ var ys = new[] { 1, 3, 2 }.ToAsyncEnumerable().Select(x => x);`
	`61`	`+ var res = xs.SequenceEqualAsync(ys);`
	`62`	`+ Assert.False(await res);`
	`63`	`+ }`
	`64`	`+`
	`65`	`+ [Fact]`
	`66`	`+ public async Task SequenceEqualAsync_NotSame_IList()`
`50`	`67`	`{`
`51`	`68`	`var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();`
`52`	`69`	`var ys = new[] { 1, 3, 2 }.ToAsyncEnumerable();`
`@@ -55,7 +72,7 @@ public async Task SequenceEqual3Async()`
`55`	`72`	`}`
`56`	`73`
`57`	`74`	`[Fact]`
`58`		`- public async Task SequenceEqual4Async()`
	`75`	`+ public async Task SequenceEqualAsync_NotSame_DifferentLength()`
`59`	`76`	`{`
`60`	`77`	`var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();`
`61`	`78`	`var ys = new[] { 1, 2, 3 }.ToAsyncEnumerable();`
`@@ -64,16 +81,16 @@ public async Task SequenceEqual4Async()`
`64`	`81`	`}`
`65`	`82`
`66`	`83`	`[Fact]`
`67`		`- public async Task SequenceEqual5Async()`
	`84`	`+ public async Task SequenceEqualAsync_NotSame_DifferentLength_IList()`
`68`	`85`	`{`
`69`		`- var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();`
`70`		`- var ys = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();`
	`86`	`+ var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable().Select(x => x);`
	`87`	`+ var ys = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().Select(x => x);`
`71`	`88`	`var res = xs.SequenceEqualAsync(ys);`
`72`	`89`	`Assert.False(await res);`
`73`	`90`	`}`
`74`	`91`
`75`	`92`	`[Fact]`
`76`		`- public async Task SequenceEqual6Async()`
	`93`	`+ public async Task SequenceEqualAsync_Throws_Second()`
`77`	`94`	`{`
`78`	`95`	`var ex = new Exception("Bang!");`
`79`	`96`	`var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();`
`@@ -84,7 +101,7 @@ public async Task SequenceEqual6Async()`
`84`	`101`	`}`
`85`	`102`
`86`	`103`	`[Fact]`
`87`		`- public async Task SequenceEqual7Async()`
	`104`	`+ public async Task SequenceEqualAsync_Throws_First()`
`88`	`105`	`{`
`89`	`106`	`var ex = new Exception("Bang!");`
`90`	`107`	`var xs = Throw<int>(ex);`
`@@ -95,23 +112,41 @@ public async Task SequenceEqual7Async()`
`95`	`112`	`}`
`96`	`113`
`97`	`114`	`[Fact]`
`98`		`- public async Task SequenceEqual8Async()`
	`115`	`+ public async Task SequenceEqualAsync_Comparer_Empty()`
`99`	`116`	`{`
`100`		`- var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();`
	`117`	`+ var xs = AsyncEnumerable.Empty<int>();`
`101`	`118`	`var res = xs.SequenceEqualAsync(xs, new Eq());`
`102`	`119`	`Assert.True(await res);`
`103`	`120`	`}`
`104`	`121`
`105`	`122`	`[Fact]`
`106`		`- public async Task SequenceEqual9Async()`
	`123`	`+ public async Task SequenceEqualAsync_Comparer_Same1()`
`107`	`124`	`{`
`108`		`- var xs = AsyncEnumerable.Empty<int>();`
	`125`	`+ var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();`
`109`	`126`	`var res = xs.SequenceEqualAsync(xs, new Eq());`
`110`	`127`	`Assert.True(await res);`
`111`	`128`	`}`
`112`	`129`
`113`	`130`	`[Fact]`
`114`		`- public async Task SequenceEqual10Async()`
	`131`	`+ public async Task SequenceEqualAsync_Comparer_Same2()`
	`132`	`+ {`
	`133`	`+ var xs = new[] { 1, 2, -3, 4 }.ToAsyncEnumerable().Select(x => x);`
	`134`	`+ var ys = new[] { 1, -2, 3, 4 }.ToAsyncEnumerable().Select(x => x);`
	`135`	`+ var res = xs.SequenceEqualAsync(ys, new Eq());`
	`136`	`+ Assert.True(await res);`
	`137`	`+ }`
	`138`	`+`
	`139`	`+ [Fact]`
	`140`	`+ public async Task SequenceEqualAsync_Comparer_NotSame()`
	`141`	`+ {`
	`142`	`+ var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable().Select(x => x);`
	`143`	`+ var ys = new[] { 1, 3, 2 }.ToAsyncEnumerable().Select(x => x);`
	`144`	`+ var res = xs.SequenceEqualAsync(ys, new Eq());`
	`145`	`+ Assert.False(await res);`
	`146`	`+ }`
	`147`	`+`
	`148`	`+ [Fact]`
	`149`	`+ public async Task SequenceEqualAsync_Comparer_NotSame_IList()`
`115`	`150`	`{`
`116`	`151`	`var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();`
`117`	`152`	`var ys = new[] { 1, 3, 2 }.ToAsyncEnumerable();`
`@@ -120,16 +155,16 @@ public async Task SequenceEqual10Async()`
`120`	`155`	`}`
`121`	`156`
`122`	`157`	`[Fact]`
`123`		`- public async Task SequenceEqual11Async()`
	`158`	`+ public async Task SequenceEqualAsync_Comparer_NotSame_DifferentLength()`
`124`	`159`	`{`
`125`		`- var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();`
`126`		`- var ys = new[] { 1, 2, 3 }.ToAsyncEnumerable();`
	`160`	`+ var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().Select(x => x);`
	`161`	`+ var ys = new[] { 1, 2, 3 }.ToAsyncEnumerable().Select(x => x);`
`127`	`162`	`var res = xs.SequenceEqualAsync(ys, new Eq());`
`128`	`163`	`Assert.False(await res);`
`129`	`164`	`}`
`130`	`165`
`131`	`166`	`[Fact]`
`132`		`- public async Task SequenceEqual12Async()`
	`167`	`+ public async Task SequenceEqualAsync_Comparer_NotSame_DifferentLength_IList()`
`133`	`168`	`{`
`134`	`169`	`var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();`
`135`	`170`	`var ys = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();`
`@@ -138,7 +173,7 @@ public async Task SequenceEqual12Async()`
`138`	`173`	`}`
`139`	`174`
`140`	`175`	`[Fact]`
`141`		`- public async Task SequenceEqual13Async()`
	`176`	`+ public async Task SequenceEqualAsync_Comparer_Throws_Second()`
`142`	`177`	`{`
`143`	`178`	`var ex = new Exception("Bang!");`
`144`	`179`	`var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();`
`@@ -149,7 +184,7 @@ public async Task SequenceEqual13Async()`
`149`	`184`	`}`
`150`	`185`
`151`	`186`	`[Fact]`
`152`		`- public async Task SequenceEqual14Async()`
	`187`	`+ public async Task SequenceEqualAsync_Comparer_Throws_First()`
`153`	`188`	`{`
`154`	`189`	`var ex = new Exception("Bang!");`
`155`	`190`	`var xs = Throw<int>(ex);`
`@@ -160,7 +195,7 @@ public async Task SequenceEqual14Async()`
`160`	`195`	`}`
`161`	`196`
`162`	`197`	`[Fact]`
`163`		`- public async Task SequenceEqual15Async()`
	`198`	`+ public async Task SequenceEqualAsync_Comparer_Same_IList()`
`164`	`199`	`{`
`165`	`200`	`var xs = new[] { 1, 2, -3, 4 }.ToAsyncEnumerable();`
`166`	`201`	`var ys = new[] { 1, -2, 3, 4 }.ToAsyncEnumerable();`
`@@ -169,15 +204,15 @@ public async Task SequenceEqual15Async()`
`169`	`204`	`}`
`170`	`205`
`171`	`206`	`[Fact]`
`172`		`- public async Task SequenceEqual16Async()`
	`207`	`+ public async Task SequenceEqualAsync_Comparer_Throws_Equals_IList()`
`173`	`208`	`{`
`174`	`209`	`var xs = new[] { 1, 2, -3, 4 }.ToAsyncEnumerable();`
`175`		`- var ys = new[] { 1, -2, 3, 4 }.ToAsyncEnumerable(); // NB: Implements IList<T>, resulting in optimized code path.`
	`210`	`+ var ys = new[] { 1, -2, 3, 4 }.ToAsyncEnumerable();`
`176`	`211`	`await Assert.ThrowsAsync<NotImplementedException>(() => xs.SequenceEqualAsync(ys, new EqEx()).AsTask());`
`177`	`212`	`}`
`178`	`213`
`179`	`214`	`[Fact]`
`180`		`- public async Task SequenceEqual17Async()`
	`215`	`+ public async Task SequenceEqualAsync_Comparer_Throws_Equals()`
`181`	`216`	`{`
`182`	`217`	`var xs = new[] { 1, 2, -3, 4 }.Select(x => x * 2).ToAsyncEnumerable();`
`183`	`218`	`var ys = new[] { 1, -2, 3, 4 }.Select(x => x * 2).ToAsyncEnumerable();`
`@@ -194,7 +229,7 @@ public bool Equals(int x, int y)`
`194`	`229`
`195`	`230`	`public int GetHashCode(int obj)`
`196`	`231`	`{`
`197`		`- throw new NotImplementedException();`
	`232`	`+ throw new NotSupportedException();`
`198`	`233`	`}`
`199`	`234`	`}`
`200`	`235`