test: 100% coverage on EnumerableExtensions

oliverbooth · Mar 28, 2023 · 121c3a3 · 121c3a3
1 parent 9bb9c96
commit 121c3a3
Showing 1 changed file with 61 additions and 10 deletions.
diff --git a/X10D.Tests/src/Linq/EnumerableTests.cs b/X10D.Tests/src/Linq/EnumerableTests.cs
@@ -13,6 +13,11 @@ public void MinMax_ShouldReturnCorrectValues_UsingDefaultComparer()
         (int minimum, int maximum) = source.MinMax();
         Assert.AreEqual(1, minimum);
         Assert.AreEqual(10, maximum);
+
+        source = Enumerable.Range(1, 10).ToArray();
+        (minimum, maximum) = source.MinMax();
+        Assert.AreEqual(1, minimum);
+        Assert.AreEqual(10, maximum);
     }
 
     [TestMethod]
@@ -22,6 +27,11 @@ public void MinMax_ShouldReturnCorrectSelectedValues_UsingDefaultComparer()
         (int minimum, int maximum) = source.MinMax(p => p.Age);
         Assert.AreEqual(1, minimum);
         Assert.AreEqual(10, maximum);
+
+        source = Enumerable.Range(1, 10).Select(i => new Person {Age = i}).ToArray();
+        (minimum, maximum) = source.MinMax(p => p.Age);
+        Assert.AreEqual(1, minimum);
+        Assert.AreEqual(10, maximum);
     }
 
     [TestMethod]
@@ -31,22 +41,30 @@ public void MinMax_ShouldReturnOppositeSelectedValues_UsingInverseComparer()
         (int minimum, int maximum) = source.MinMax(p => p.Age, new InverseComparer<int>());
         Assert.AreEqual(10, minimum);
         Assert.AreEqual(1, maximum);
+
+        source = Enumerable.Range(1, 10).Select(i => new Person {Age = i}).ToArray();
+        (minimum, maximum) = source.MinMax(p => p.Age, new InverseComparer<int>());
+        Assert.AreEqual(10, minimum);
+        Assert.AreEqual(1, maximum);
     }
 
     [TestMethod]
     public void MinMax_ShouldReturnOppositeValues_UsingInverseComparer()
     {
-        IEnumerable<int> source = Enumerable.Range(1, 10);
-        (int minimum, int maximum) = source.MinMax(new InverseComparer<int>());
+        (int minimum, int maximum) = Enumerable.Range(1, 10).MinMax(new InverseComparer<int>());
+        Assert.AreEqual(10, minimum);
+        Assert.AreEqual(1, maximum);
+
+        (minimum, maximum) = Enumerable.Range(1, 10).ToArray().MinMax(new InverseComparer<int>());
         Assert.AreEqual(10, minimum);
         Assert.AreEqual(1, maximum);
     }
 
     [TestMethod]
     public void MinMax_ShouldThrowArgumentNullException_GivenNullSelector()
     {
-        IEnumerable<int> source = Enumerable.Range(1, 10);
-        Assert.ThrowsException<ArgumentNullException>(() => source.MinMax((Func<int, int>?)null!));
+        Assert.ThrowsException<ArgumentNullException>(() => Enumerable.Range(1, 10).MinMax((Func<int, int>?)null!));
+        Assert.ThrowsException<ArgumentNullException>(() => Enumerable.Range(1, 10).ToArray().MinMax((Func<int, int>?)null!));
     }
 
     [TestMethod]
@@ -59,8 +77,13 @@ public void MinMax_ShouldThrowArgumentNullException_GivenNullSource()
     [TestMethod]
     public void MinMax_ShouldThrowInvalidOperationException_GivenEmptySource()
     {
-        IEnumerable<int> source = ArraySegment<int>.Empty;
-        Assert.ThrowsException<InvalidOperationException>(() => source.MinMax());
+        Assert.ThrowsException<InvalidOperationException>(() => Enumerable.Empty<int>().MinMax());
+        Assert.ThrowsException<InvalidOperationException>(() => Array.Empty<int>().MinMax());
+        Assert.ThrowsException<InvalidOperationException>(() => new List<int>().MinMax());
+
+        Assert.ThrowsException<InvalidOperationException>(() => Enumerable.Empty<int>().MinMax(i => i * 2));
+        Assert.ThrowsException<InvalidOperationException>(() => Array.Empty<int>().MinMax(i => i * 2));
+        Assert.ThrowsException<InvalidOperationException>(() => new List<int>().MinMax(i => i * 2));
     }
 
     [TestMethod]
@@ -70,6 +93,11 @@ public void MinMaxBy_ShouldReturnCorrectSelectedValues_UsingDefaultComparer()
         (Person minimum, Person maximum) = source.MinMaxBy(p => p.Age);
         Assert.AreEqual(1, minimum.Age);
         Assert.AreEqual(10, maximum.Age);
+
+        source = Enumerable.Range(1, 10).Select(i => new Person {Age = i}).ToArray();
+        (minimum, maximum) = source.MinMaxBy(p => p.Age);
+        Assert.AreEqual(1, minimum.Age);
+        Assert.AreEqual(10, maximum.Age);
     }
 
     [TestMethod]
@@ -79,13 +107,27 @@ public void MinMaxBy_ShouldReturnOppositeSelectedValues_UsingInverseComparer()
         (Person minimum, Person maximum) = source.MinMaxBy(p => p.Age, new InverseComparer<int>());
         Assert.AreEqual(10, minimum.Age);
         Assert.AreEqual(1, maximum.Age);
+
+        source = Enumerable.Range(1, 10).Select(i => new Person {Age = i}).ToArray();
+        (minimum, maximum) = source.MinMaxBy(p => p.Age, new InverseComparer<int>());
+        Assert.AreEqual(10, minimum.Age);
+        Assert.AreEqual(1, maximum.Age);
     }
 
     [TestMethod]
     public void MinMaxBy_ShouldThrowArgumentNullException_GivenNullSelector()
     {
-        IEnumerable<Person> source = Enumerable.Range(1, 10).Select(i => new Person {Age = i});
-        Assert.ThrowsException<ArgumentNullException>(() => source.MinMaxBy((Func<Person, int>?)null!));
+        Assert.ThrowsException<ArgumentNullException>(() =>
+        {
+            IEnumerable<Person> source = Enumerable.Range(1, 10).Select(i => new Person {Age = i});
+            return source.MinMaxBy((Func<Person, int>?)null!);
+        });
+
+        Assert.ThrowsException<ArgumentNullException>(() =>
+        {
+            Person[] source = Enumerable.Range(1, 10).Select(i => new Person {Age = i}).ToArray();
+            return source.MinMaxBy((Func<Person, int>?)null!);
+        });
     }
 
     [TestMethod]
@@ -98,8 +140,17 @@ public void MinMaxBy_ShouldThrowArgumentNullException_GivenNullSource()
     [TestMethod]
     public void MinMaxBy_ShouldThrowInvalidOperationException_GivenEmptySource()
     {
-        IEnumerable<Person> source = ArraySegment<Person>.Empty;
-        Assert.ThrowsException<InvalidOperationException>(() => source.MinMaxBy(p => p.Age));
+        Assert.ThrowsException<InvalidOperationException>(() =>
+        {
+            IEnumerable<Person> source = Enumerable.Empty<Person>();
+            return source.MinMaxBy(p => p.Age);
+        });
+
+        Assert.ThrowsException<InvalidOperationException>(() =>
+        {
+            Person[] source = Array.Empty<Person>();
+            return source.MinMaxBy(p => p.Age);
+        });
     }
 
     private struct InverseComparer<T> : IComparer<T> where T : IComparable<T>