Add NUnit.Analyzers, addressing warnings

MoreLinq.Test/AssertCountTest.cs

@@ -112,7 +112,7 @@ public void AssertCountWithCollectionIsLazy()
         public void AssertCountWithMatchingCollectionCount()
         {
             var xs = new[] { 123, 456, 789 };
-            Assert.AreSame(xs, xs.AssertCount(3));
+            Assert.That(xs, Is.SameAs(xs.AssertCount(3)));
         }
 
         [TestCase(3, 2, "Sequence contains too many elements when exactly 2 were expected.")]
@@ -122,7 +122,7 @@ public void AssertCountWithMismatchingCollectionCount(int sourceCount, int count
             var xs = new int[sourceCount];
             using var enumerator = xs.AssertCount(count).GetEnumerator();
             var e = Assert.Throws<SequenceException>(() => enumerator.MoveNext());
-            Assert.AreEqual(e.Message, message);
+            Assert.That(e.Message, Is.EqualTo(message));
         }
 
         [Test]

MoreLinq.Test/AssertTest.cs

@@ -57,7 +57,7 @@ public void AssertSequenceWithInvalidElementsAndCustomError()
             var e =
                 Assert.Throws<ValueException>(() =>
                     new[] { 2, 4, 6, 7, 8, 9 }.Assert(n => n % 2 == 0, n => new ValueException(n)).Consume());
-            Assert.AreEqual(7, e.Value);
+            Assert.That(e.Value, Is.EqualTo(7));
         }
 
         class ValueException : Exception

MoreLinq.Test/CartesianTest.cs

@@ -88,7 +88,7 @@ public void TestCartesianProductCount()
 
             var result = sequenceA.Cartesian(sequenceB, (a, b) => a + b);
 
-            Assert.AreEqual(expectedCount, result.Count() );
+            Assert.That(result.Count(), Is.EqualTo(expectedCount));
         }
 
         /// <summary>
@@ -111,7 +111,7 @@ public void TestCartesianProductCount_Multidimensional()
             var result = sequenceA.Cartesian(sequenceB, sequenceC, sequenceD, (a, b, c, d) => a + b + c + d);
 
             const int expectedCount = countA * countB * countC * countD;
-            Assert.AreEqual(expectedCount, result.Count());
+            Assert.That(result.Count(), Is.EqualTo(expectedCount));
         }
 
         /// <summary>
@@ -139,7 +139,7 @@ public void TestCartesianProductCombinations()
                             .ToArray();
 
             // verify that the expected number of results is correct
-            Assert.AreEqual(sequenceA.Count() * sequenceB.Count(), result.Count());
+            Assert.That(result.Count(), Is.EqualTo(sequenceA.Count() * sequenceB.Count()));
 
             // ensure that all "cells" were visited by the cartesian product
             foreach (var coord in result)
@@ -160,9 +160,9 @@ public void TestEmptyCartesianEvaluation()
             var resultB = Enumerable.Empty<int>().Cartesian(sequence, (a, b) => new { A = a, B = b });
             var resultC = Enumerable.Empty<int>().Cartesian(Enumerable.Empty<int>(), (a, b) => new { A = a, B = b });
 
-            Assert.AreEqual(0, resultA.Count());
-            Assert.AreEqual(0, resultB.Count());
-            Assert.AreEqual(0, resultC.Count());
+            Assert.That(resultA.Count(), Is.Zero);
+            Assert.That(resultB.Count(), Is.Zero);
+            Assert.That(resultC.Count(), Is.Zero);
         }
     }
 }

MoreLinq.Test/CompareCountTest.cs

@@ -57,8 +57,8 @@ public void CompareCountWithCollectionAndSequence(int collectionCount,
 
             using var seq = Enumerable.Range(0, sequenceCount).AsTestingSequence();
 
-            Assert.AreEqual(expectedCompareCount, collection.CompareCount(seq));
-            Assert.AreEqual(expectedMoveNextCallCount, seq.MoveNextCallCount);
+            Assert.That(collection.CompareCount(seq), Is.EqualTo(expectedCompareCount));
+            Assert.That(seq.MoveNextCallCount, Is.EqualTo(expectedMoveNextCallCount));
         }
 
         [TestCase(0, 0,  0, 1)]
@@ -74,8 +74,8 @@ public void CompareCountWithSequenceAndCollection(int sequenceCount,
 
             using var seq = Enumerable.Range(0, sequenceCount).AsTestingSequence();
 
-            Assert.AreEqual(expectedCompareCount, seq.CompareCount(collection));
-            Assert.AreEqual(expectedMoveNextCallCount, seq.MoveNextCallCount);
+            Assert.That(seq.CompareCount(collection), Is.EqualTo(expectedCompareCount));
+            Assert.That(seq.MoveNextCallCount, Is.EqualTo(expectedMoveNextCallCount));
         }
 
         [TestCase(0, 0,  0, 1)]
@@ -90,9 +90,9 @@ public void CompareCountWithSequenceAndSequence(int sequenceCount1,
             using var seq1 = Enumerable.Range(0, sequenceCount1).AsTestingSequence();
             using var seq2 = Enumerable.Range(0, sequenceCount2).AsTestingSequence();
 
-            Assert.AreEqual(expectedCompareCount, seq1.CompareCount(seq2));
-            Assert.AreEqual(expectedMoveNextCallCount, seq1.MoveNextCallCount);
-            Assert.AreEqual(expectedMoveNextCallCount, seq2.MoveNextCallCount);
+            Assert.That(seq1.CompareCount(seq2), Is.EqualTo(expectedCompareCount));
+            Assert.That(seq1.MoveNextCallCount, Is.EqualTo(expectedMoveNextCallCount));
+            Assert.That(seq2.MoveNextCallCount, Is.EqualTo(expectedMoveNextCallCount));
         }
 
         [Test]
@@ -101,7 +101,7 @@ public void CompareCountDisposesSequenceEnumerators()
             using var seq1 = TestingSequence.Of<int>();
             using var seq2 = TestingSequence.Of<int>();
 
-            Assert.AreEqual(0, seq1.CompareCount(seq2));
+            Assert.That(seq1.CompareCount(seq2), Is.Zero);
         }
 
         [Test]
@@ -111,7 +111,7 @@ public void CompareCountDisposesFirstEnumerator()
 
             using var seq = TestingSequence.Of<int>();
 
-            Assert.AreEqual(0, seq.CompareCount(collection));
+            Assert.That(seq.CompareCount(collection), Is.Zero);
         }
 
         [Test]
@@ -121,7 +121,7 @@ public void CompareCountDisposesSecondEnumerator()
 
             using var seq = TestingSequence.Of<int>();
 
-            Assert.AreEqual(0, collection.CompareCount(seq));
+            Assert.That(collection.CompareCount(seq), Is.Zero);
         }
 
         [Test]
@@ -135,8 +135,8 @@ public void CompareCountDoesNotIterateUnnecessaryElements()
 
             var seq2 = Enumerable.Range(1, 3);
 
-            Assert.AreEqual( 1, seq1.CompareCount(seq2));
-            Assert.AreEqual(-1, seq2.CompareCount(seq1));
+            Assert.That(seq1.CompareCount(seq2), Is.EqualTo( 1));
+            Assert.That(seq2.CompareCount(seq1), Is.EqualTo(-1));
         }
 
         enum SequenceKind

MoreLinq.Test/ConsumeTest.cs

@@ -28,7 +28,7 @@ public void ConsumeReallyConsumes()
             var counter = 0;
             var sequence = Enumerable.Range(0, 10).Pipe(_ => counter++);
             sequence.Consume();
-            Assert.AreEqual(10, counter);
+            Assert.That(counter, Is.EqualTo(10));
         }
     }
 }

MoreLinq.Test/FallbackIfEmptyTest.cs

@@ -42,12 +42,12 @@ public void FallbackIfEmptyPreservesSourceCollectionIfPossible(SourceKind source
         {
             var source = new[] { 1 }.ToSourceKind(sourceKind);
             // ReSharper disable PossibleMultipleEnumeration
-            Assert.AreSame(source.FallbackIfEmpty(12), source);
-            Assert.AreSame(source.FallbackIfEmpty(12, 23), source);
-            Assert.AreSame(source.FallbackIfEmpty(12, 23, 34), source);
-            Assert.AreSame(source.FallbackIfEmpty(12, 23, 34, 45), source);
-            Assert.AreSame(source.FallbackIfEmpty(12, 23, 34, 45, 56), source);
-            Assert.AreSame(source.FallbackIfEmpty(12, 23, 34, 45, 56, 67), source);
+            Assert.That(source.FallbackIfEmpty(12), Is.SameAs(source));
+            Assert.That(source.FallbackIfEmpty(12, 23), Is.SameAs(source));
+            Assert.That(source.FallbackIfEmpty(12, 23, 34), Is.SameAs(source));
+            Assert.That(source.FallbackIfEmpty(12, 23, 34, 45), Is.SameAs(source));
+            Assert.That(source.FallbackIfEmpty(12, 23, 34, 45, 56), Is.SameAs(source));
+            Assert.That(source.FallbackIfEmpty(12, 23, 34, 45, 56, 67), Is.SameAs(source));
             // ReSharper restore PossibleMultipleEnumeration
         }
 
@@ -57,8 +57,8 @@ public void FallbackIfEmptyPreservesFallbackCollectionIfPossible(SourceKind sour
         {
             var source = new int[0].ToSourceKind(sourceKind);
             var fallback = new[] { 1 };
-            Assert.AreSame(source.FallbackIfEmpty(fallback), fallback);
-            Assert.AreSame(source.FallbackIfEmpty(fallback.AsEnumerable()), fallback);
+            Assert.That(source.FallbackIfEmpty(fallback), Is.SameAs(fallback));
+            Assert.That(source.FallbackIfEmpty(fallback.AsEnumerable()), Is.SameAs(fallback));
         }
 
         [Test]

MoreLinq.Test/FullGroupJoinTest.cs

@@ -48,7 +48,7 @@ public void FullGroupJoinsResults(OverloadCase overloadCase)
 
             var result = FullGroupJoin(overloadCase, listA, listB, x => x).ToDictionary(a => a.Key);
 
-            Assert.AreEqual(3, result.Keys.Count);
+            Assert.That(result.Keys.Count, Is.EqualTo(3));
 
             Assert.IsEmpty(result[1].Second);
             result[1].First.AssertSequenceEqual(1);
@@ -69,13 +69,13 @@ public void FullGroupJoinsEmptyLeft(OverloadCase overloadCase)
 
             var result = FullGroupJoin(overloadCase, listA, listB, x => x).ToDictionary(a => a.Key);
 
-            Assert.AreEqual(2, result.Keys.Count);
+            Assert.That(result.Keys.Count, Is.EqualTo(2));
 
             Assert.IsEmpty(result[2].First);
-            Assert.AreEqual(2, result[2].Second.Single());
+            Assert.That(result[2].Second.Single(), Is.EqualTo(2));
 
             Assert.IsEmpty(result[3].First);
-            Assert.AreEqual(3, result[3].Second.Single());
+            Assert.That(result[3].Second.Single(), Is.EqualTo(3));
         }
 
         [TestCase(CustomResult)]
@@ -87,12 +87,12 @@ public void FullGroupJoinsEmptyRight(OverloadCase overloadCase)
 
             var result = FullGroupJoin(overloadCase, listA, listB, x => x).ToDictionary(a => a.Key);
 
-            Assert.AreEqual(2, result.Keys.Count);
+            Assert.That(result.Keys.Count, Is.EqualTo(2));
 
-            Assert.AreEqual(2, result[2].First.Single());
+            Assert.That(result[2].First.Single(), Is.EqualTo(2));
             Assert.IsEmpty(result[2].Second);
 
-            Assert.AreEqual(3, result[3].First.Single());
+            Assert.That(result[3].First.Single(), Is.EqualTo(3));
             Assert.IsEmpty(result[3].Second);
         }
 

MoreLinq.Test/GroupAdjacentTest.cs

@@ -235,7 +235,7 @@ static void AssertResult<TElement>(SequenceReader<TElement> reader, TElement ele
         {
             var result = reader.Read();
             Assert.That(result, Is.Not.Null);
-            Assert.AreEqual(element, result);
+            Assert.That(result, Is.EqualTo(element));
         }
     }
 }

MoreLinq.Test/LagTest.cs

@@ -69,7 +69,7 @@ public void TestLagExplicitDefaultValue()
             var sequence = Enumerable.Range(1, count);
             var result = sequence.Lag(lagBy, lagDefault, (_, lagVal) => lagVal);
 
-            Assert.AreEqual(count, result.Count());
+            Assert.That(result.Count(), Is.EqualTo(count));
             Assert.That(result.Take(lagBy), Is.EqualTo(Enumerable.Repeat(lagDefault, lagBy)));
         }
 
@@ -84,7 +84,7 @@ public void TestLagImplicitDefaultValue()
             var sequence = Enumerable.Range(1, count);
             var result = sequence.Lag(lagBy, (_, lagVal) => lagVal);
 
-            Assert.AreEqual(count, result.Count());
+            Assert.That(result.Count(), Is.EqualTo(count));
             Assert.That(result.Take(lagBy), Is.EqualTo(Enumerable.Repeat(default(int), lagBy)));
         }
 
@@ -99,7 +99,7 @@ public void TestLagOffsetGreaterThanSequenceLength()
             var sequence = Enumerable.Range(1, count);
             var result = sequence.Lag(count + 1, (a, _) => a);
 
-            Assert.AreEqual(count, result.Count());
+            Assert.That(result.Count(), Is.EqualTo(count));
             Assert.That(result, Is.EqualTo(sequence));
         }
 
@@ -114,7 +114,7 @@ public void TestLagPassesCorrectLagValueOffsetBy1()
             var sequence = Enumerable.Range(1, count);
             var result = sequence.Lag(1, (a, b) => new { A = a, B = b });
 
-            Assert.AreEqual(count, result.Count());
+            Assert.That(result.Count(), Is.EqualTo(count));
             Assert.IsTrue(result.All(x => x.B == (x.A - 1)));
         }
 
@@ -129,7 +129,7 @@ public void TestLagPassesCorrectLagValuesOffsetBy2()
             var sequence = Enumerable.Range(1, count);
             var result = sequence.Lag(2, (a, b) => new { A = a, B = b });
 
-            Assert.AreEqual(count, result.Count());
+            Assert.That(result.Count(), Is.EqualTo(count));
             Assert.IsTrue(result.Skip(2).All(x => x.B == (x.A - 2)));
             Assert.IsTrue(result.Take(2).All(x => (x.A - x.B) == x.A));
         }

MoreLinq.Test/LeadTest.cs

@@ -69,7 +69,7 @@ public void TestLeadExplicitDefaultValue()
             var sequence = Enumerable.Range(1, count);
             var result = sequence.Lead(leadBy, leadDefault, (_, leadVal) => leadVal);
 
-            Assert.AreEqual(count, result.Count());
+            Assert.That(result.Count(), Is.EqualTo(count));
             Assert.That(result.Skip(count - leadBy), Is.EqualTo(Enumerable.Repeat(leadDefault, leadBy)));
         }
 
@@ -84,7 +84,7 @@ public void TestLeadImplicitDefaultValue()
             var sequence = Enumerable.Range(1, count);
             var result = sequence.Lead(leadBy, (_, leadVal) => leadVal);
 
-            Assert.AreEqual(count, result.Count());
+            Assert.That(result.Count(), Is.EqualTo(count));
             Assert.That(result.Skip(count - leadBy), Is.EqualTo(Enumerable.Repeat(default(int), leadBy)));
         }
 
@@ -100,7 +100,7 @@ public void TestLeadOffsetGreaterThanSequenceLength()
             var sequence = Enumerable.Range(1, count);
             var result = sequence.Lead(count + 1, leadDefault, (val, leadVal) => new { A = val, B = leadVal });
 
-            Assert.AreEqual(count, result.Count());
+            Assert.That(result.Count(), Is.EqualTo(count));
             Assert.That(result, Is.EqualTo(sequence.Select(x => new { A = x, B = leadDefault })));
         }
 
@@ -115,7 +115,7 @@ public void TestLeadPassesCorrectValueOffsetBy1()
             var sequence = Enumerable.Range(1, count);
             var result = sequence.Lead(1, count + 1, (val, leadVal) => new { A = val, B = leadVal });
 
-            Assert.AreEqual(count, result.Count());
+            Assert.That(result.Count(), Is.EqualTo(count));
             Assert.IsTrue(result.All(x => x.B == (x.A + 1)));
         }
 
@@ -131,7 +131,7 @@ public void TestLeadPassesCorrectValueOffsetBy2()
             var sequence = Enumerable.Range(1, count);
             var result = sequence.Lead(2, leadDefault, (val, leadVal) => new { A = val, B = leadVal });
 
-            Assert.AreEqual(count, result.Count());
+            Assert.That(result.Count(), Is.EqualTo(count));
             Assert.IsTrue(result.Take(count - 2).All(x => x.B == (x.A + 2)));
             Assert.IsTrue(result.Skip(count - 2).All(x => x.B == leadDefault && x.A is count or count - 1));
         }

MoreLinq.Test/MaxByTest.cs

@@ -34,15 +34,15 @@ public void MaxByIsLazy()
         [Test]
         public void MaxByReturnsMaxima()
         {
-            Assert.AreEqual(new[] { "hello", "world" },
-                            SampleData.Strings.MaxBy(x => x.Length));
+            Assert.That(SampleData.Strings.MaxBy(x => x.Length),
+                        Is.EqualTo(new[] { "hello", "world" }));
         }
 
         [Test]
         public void MaxByNullComparer()
         {
-            Assert.AreEqual(SampleData.Strings.MaxBy(x => x.Length),
-                            SampleData.Strings.MaxBy(x => x.Length, null));
+            Assert.That(SampleData.Strings.MaxBy(x => x.Length, null),
+                        Is.EqualTo(SampleData.Strings.MaxBy(x => x.Length)));
         }
 
         [Test]
@@ -54,13 +54,13 @@ public void MaxByEmptySequence()
         [Test]
         public void MaxByWithNaturalComparer()
         {
-            Assert.AreEqual(new[] { "az" }, SampleData.Strings.MaxBy(x => x[1]));
+            Assert.That(SampleData.Strings.MaxBy(x => x[1]), Is.EqualTo(new[] { "az" }));
         }
 
         [Test]
         public void MaxByWithComparer()
         {
-            Assert.AreEqual(new[] { "aa" }, SampleData.Strings.MaxBy(x => x[1], Comparable<char>.DescendingOrderComparer));
+            Assert.That(SampleData.Strings.MaxBy(x => x[1], Comparable<char>.DescendingOrderComparer), Is.EqualTo(new[] { "aa" }));
         }
 
         public class First

MoreLinq.Test/MinByTest.cs

@@ -34,15 +34,15 @@ public void MinByIsLazy()
         [Test]
         public void MinByReturnsMinima()
         {
-            Assert.AreEqual(new[] { "ax", "aa", "ab", "ay", "az" },
-                            SampleData.Strings.MinBy(x => x.Length));
+            Assert.That(SampleData.Strings.MinBy(x => x.Length),
+                        Is.EqualTo(new[] { "ax", "aa", "ab", "ay", "az" }));
         }
 
         [Test]
         public void MinByNullComparer()
         {
-            Assert.AreEqual(SampleData.Strings.MinBy(x => x.Length),
-                            SampleData.Strings.MinBy(x => x.Length, null));
+            Assert.That(SampleData.Strings.MinBy(x => x.Length, null),
+                        Is.EqualTo(SampleData.Strings.MinBy(x => x.Length)));
         }
 
         [Test]
@@ -54,13 +54,13 @@ public void MinByEmptySequence()
         [Test]
         public void MinByWithNaturalComparer()
         {
-            Assert.AreEqual(new[] { "aa" }, SampleData.Strings.MinBy(x => x[1]));
+            Assert.That(SampleData.Strings.MinBy(x => x[1]), Is.EqualTo(new[] { "aa" }));
         }
 
         [Test]
         public void MinByWithComparer()
         {
-            Assert.AreEqual(new[] { "az" }, SampleData.Strings.MinBy(x => x[1], Comparable<char>.DescendingOrderComparer));
+            Assert.That(SampleData.Strings.MinBy(x => x[1], Comparable<char>.DescendingOrderComparer), Is.EqualTo(new[] { "az" }));
         }
 
         public class First