Update assertions to use constraint-based model

Author: Meaghan Lewis

test/GitHub.InlineReviews.UnitTests/Models/DiffUtilitiesTests.cs

@@ -49,8 +49,8 @@ public void HeaderOnly_OldAndNewLineNumbers(string header, int expectOldLineNumb
                 var chunks = DiffUtilities.ParseFragment(header);
                 var chunk = chunks.First();
 
-                Assert.AreEqual(expectOldLineNumber, chunk.OldLineNumber);
-                Assert.AreEqual(expectNewLineNumber, chunk.NewLineNumber);
+                Assert.That(expectOldLineNumber, Is.EqualTo(chunk.OldLineNumber));
+                Assert.That(expectNewLineNumber, Is.EqualTo(chunk.NewLineNumber));
             }
 
             [Test]
@@ -77,7 +77,7 @@ public void NoNewLineNotAtEndOfChunk_CheckLineCount()
 
                 var chunk = DiffUtilities.ParseFragment(header).First();
 
-                Assert.AreEqual(2, chunk.Lines.Count());
+                Assert.That(2, Is.EqualTo(chunk.Lines.Count()));
             }
 
             [Test]
@@ -92,7 +92,7 @@ public void NoNewLineNotAtEndOfChunk_CheckDiffLineNumber()
                 var chunk = DiffUtilities.ParseFragment(header).First();
 
                 var line = chunk.Lines.Last();
-                Assert.AreEqual(3, line.DiffLineNumber);
+                Assert.That(3, Is.EqualTo(line.DiffLineNumber));
             }
 
 			[TestCase("+foo\n+bar\n", "+foo", "+bar")]
@@ -106,8 +106,8 @@ public void FirstChunk_CheckLineContent(string diffLines, string contentLine0, s
 
                 var chunk = DiffUtilities.ParseFragment(diff).First();
 
-                Assert.AreEqual(contentLine0, chunk.Lines[0].Content);
-                Assert.AreEqual(contentLine1, chunk.Lines[1].Content);
+                Assert.That(contentLine0, Is.EqualTo(chunk.Lines[0].Content));
+                Assert.That(contentLine1, Is.EqualTo(chunk.Lines[1].Content));
             }
 
 			[TestCase("+foo\n+bar\n", 1, 2)]
@@ -120,8 +120,8 @@ public void FirstChunk_CheckNewLineNumber(string diffLines, int lineNumber0, int
 
                 var chunk = DiffUtilities.ParseFragment(diff).First();
 
-                Assert.AreEqual(lineNumber0, chunk.Lines[0].NewLineNumber);
-                Assert.AreEqual(lineNumber1, chunk.Lines[1].NewLineNumber);
+                Assert.That(lineNumber0, Is.EqualTo(chunk.Lines[0].NewLineNumber));
+                Assert.That(lineNumber1, Is.EqualTo(chunk.Lines[1].NewLineNumber));
             }
 
 			[TestCase("-foo\n-bar\n", 1, 2)]
@@ -134,8 +134,8 @@ public void FirstChunk_CheckOldLineNumber(string diffLines, int lineNumber0, int
 
                 var chunk = DiffUtilities.ParseFragment(diff).First();
 
-                Assert.AreEqual(lineNumber0, chunk.Lines[0].OldLineNumber);
-                Assert.AreEqual(lineNumber1, chunk.Lines[1].OldLineNumber);
+                Assert.That(lineNumber0, Is.EqualTo(chunk.Lines[0].OldLineNumber));
+                Assert.That(lineNumber1, Is.EqualTo(chunk.Lines[1].OldLineNumber));
             }
 
             [Test]
@@ -146,7 +146,7 @@ public void FirstChunk_CheckDiffLineZeroBased()
 
                 var chunk = DiffUtilities.ParseFragment(header).First();
 
-                Assert.AreEqual(expectDiffLine, chunk.DiffLine);
+                Assert.That(expectDiffLine, Is.EqualTo(chunk.DiffLine));
             }
 
 			[TestCase(1, 2)]
@@ -156,8 +156,8 @@ public void FirstChunk_CheckLineNumbers(int oldLineNumber, int newLineNumber)
 
                 var chunk = DiffUtilities.ParseFragment(header).First();
 
-                Assert.AreEqual(oldLineNumber, chunk.OldLineNumber);
-                Assert.AreEqual(newLineNumber, chunk.NewLineNumber);
+                Assert.That(oldLineNumber, Is.EqualTo(chunk.OldLineNumber));
+                Assert.That(newLineNumber, Is.EqualTo(chunk.NewLineNumber));
             }
 
 			[TestCase(1, 2, " 1", 1, 2)]
@@ -170,8 +170,8 @@ public void FirstLine_CheckLineNumbers(int oldLineNumber, int newLineNumber, str
                 var chunk = DiffUtilities.ParseFragment(header).First();
                 var diffLine = chunk.Lines.First();
 
-                Assert.AreEqual(expectOldLineNumber, diffLine.OldLineNumber);
-                Assert.AreEqual(expectNewLineNumber, diffLine.NewLineNumber);
+                Assert.That(expectOldLineNumber, Is.EqualTo(diffLine.OldLineNumber));
+                Assert.That(expectNewLineNumber, Is.EqualTo(diffLine.NewLineNumber));
             }
 
 			[TestCase(" 1", 0, 1)]
@@ -184,7 +184,7 @@ public void SkipNLines_CheckDiffLineNumber(string lines, int skip, int expectDif
                 var result = DiffUtilities.ParseFragment(fragment);
 
                 var firstLine = result.First().Lines.Skip(skip).First();
-                Assert.AreEqual(expectDiffLineNumber, firstLine.DiffLineNumber);
+                Assert.That(expectDiffLineNumber, Is.EqualTo(firstLine.DiffLineNumber));
             }
 
 			[TestCase(" FIRST")]
@@ -198,7 +198,7 @@ public void FirstLine_CheckToString(string line)
 
                 var str = firstLine.ToString();
 
-                Assert.AreEqual(line, str);
+                Assert.That(line, Is.EqualTo(str));
             }
 
 			[TestCase(" FIRST")]
@@ -211,7 +211,7 @@ public void FirstLine_CheckContent(string line)
                 var result = DiffUtilities.ParseFragment(fragment);
                 var firstLine = result.First().Lines.First();
 
-                Assert.AreEqual(line, firstLine.Content);
+                Assert.That(line, Is.EqualTo(firstLine.Content));
             }
 
 			[TestCase(" FIRST", DiffChangeType.None)]
@@ -224,7 +224,7 @@ public void FirstLine_CheckDiffChangeTypes(string line, DiffChangeType expectTyp
                 var result = DiffUtilities.ParseFragment(fragment);
 
                 var firstLine = result.First().Lines.First();
-                Assert.AreEqual(expectType, firstLine.Type);
+                Assert.That(expectType, Is.EqualTo(firstLine.Type));
             }
 
 			[TestCase("?FIRST", "Invalid diff line change char: '?'.")]
@@ -235,7 +235,7 @@ public void InvalidDiffLineChangeChar(string line, string expectMessage)
                 var result = DiffUtilities.ParseFragment(fragment);
                 var e = Assert.Throws<InvalidDataException>(() => result.First());
 
-                Assert.AreEqual(expectMessage, e.Message);
+                Assert.That(expectMessage, Is.EqualTo(e.Message));
             }
         }
 
@@ -274,7 +274,7 @@ public class TheMatchMethod
                 var line = DiffUtilities.Match(chunks1, targetLines);
 
                 var diffLineNumber = (line != null) ? line.DiffLineNumber : -1;
-                Assert.AreEqual(expectedDiffLineNumber, diffLineNumber);
+                Assert.That(expectedDiffLineNumber, Is.EqualTo(diffLineNumber));
             }
 
             [Test]
@@ -289,7 +289,7 @@ public void MatchSameLine()
 
                 var line = DiffUtilities.Match(chunks1, targetLines);
 
-                Assert.AreEqual(expectLine, line);
+                Assert.That(expectLine, Is.EqualTo(line));
             }
 
             [Test]
@@ -300,7 +300,7 @@ public void NoLineMatchesFromNoLines()
 
                 var line = DiffUtilities.Match(chunks, lines);
 
-                Assert.Null(line);
+                Assert.That(line, Is.Null);
             }
         }
 
@@ -325,7 +325,7 @@ public void ReadLines(string text, string[] expectLines)
                 foreach (var expectLine in expectLines)
                 {
                     var line = lineReader.ReadLine();
-                    Assert.AreEqual(expectLine, line);
+                    Assert.That(expectLine, Is.EqualTo(line));
                 }
             }
 
@@ -344,7 +344,7 @@ public void CountCarriageReturns(string text, int expectCount)
             {
                 var count = DiffUtilities.LineReader.CountCarriageReturns(text);
 
-                Assert.AreEqual(expectCount, count);
+                Assert.That(expectCount, Is.EqualTo(count));
             }
 
             [Test]

test/GitHub.InlineReviews.UnitTests/Services/DiffServiceTests.cs

@@ -20,38 +20,38 @@ public void ShouldParsePr960()
                 var target = new DiffService(Substitute.For<IGitClient>());
                 var result = DiffUtilities.ParseFragment(Resources.pr_960_diff).ToList();
 
-                Assert.AreEqual(4, result.Count);
+                Assert.That(4, Is.EqualTo(result.Count));
 
-                Assert.AreEqual(11, result[0].OldLineNumber);
-                Assert.AreEqual(11, result[0].NewLineNumber);
-                Assert.AreEqual(24, result[0].Lines.Count);
+                Assert.That(11, Is.EqualTo(result[0].OldLineNumber));
+                Assert.That(11, Is.EqualTo(result[0].NewLineNumber));
+                Assert.That(24, Is.EqualTo(result[0].Lines.Count));
 
-                Assert.AreEqual(61, result[1].OldLineNumber);
-                Assert.AreEqual(61, result[1].NewLineNumber);
-                Assert.AreEqual(21, result[1].Lines.Count);
+                Assert.That(61, Is.EqualTo(result[1].OldLineNumber));
+                Assert.That(61, Is.EqualTo(result[1].NewLineNumber));
+                Assert.That(21, Is.EqualTo(result[1].Lines.Count));
 
-                Assert.AreEqual(244, result[2].OldLineNumber);
-                Assert.AreEqual(247, result[2].NewLineNumber);
-                Assert.AreEqual(15, result[2].Lines.Count);
+                Assert.That(244, Is.EqualTo(result[2].OldLineNumber));
+                Assert.That(247, Is.EqualTo(result[2].NewLineNumber));
+                Assert.That(15, Is.EqualTo(result[2].Lines.Count));
 
-                Assert.AreEqual(268, result[3].OldLineNumber);
-                Assert.AreEqual(264, result[3].NewLineNumber);
-                Assert.AreEqual(15, result[3].Lines.Count);
+                Assert.That(268, Is.EqualTo(result[3].OldLineNumber));
+                Assert.That(264, Is.EqualTo(result[3].NewLineNumber));
+                Assert.That(15, Is.EqualTo(result[3].Lines.Count));
 
                 // -    public class UsageTracker : IUsageTracker
-                Assert.AreEqual(17, result[0].Lines[7].OldLineNumber);
-                Assert.AreEqual(-1, result[0].Lines[7].NewLineNumber);
-                Assert.AreEqual(8, result[0].Lines[7].DiffLineNumber);
+                Assert.That(17, Is.EqualTo(result[0].Lines[7].OldLineNumber));
+                Assert.That(-1, Is.EqualTo(result[0].Lines[7].NewLineNumber));
+                Assert.That(8, Is.EqualTo(result[0].Lines[7].DiffLineNumber));
 
                 // +    public sealed class UsageTracker : IUsageTracker, IDisposable
-                Assert.AreEqual(-1, result[0].Lines[8].OldLineNumber);
-                Assert.AreEqual(18, result[0].Lines[8].NewLineNumber);
-                Assert.AreEqual(9, result[0].Lines[8].DiffLineNumber);
+                Assert.That(-1, Is.EqualTo(result[0].Lines[8].OldLineNumber));
+                Assert.That(18, Is.EqualTo(result[0].Lines[8].NewLineNumber));
+                Assert.That(9, Is.EqualTo(result[0].Lines[8].DiffLineNumber));
 
                 //      IConnectionManager connectionManager;
-                Assert.AreEqual(26, result[0].Lines[17].OldLineNumber);
-                Assert.AreEqual(25, result[0].Lines[17].NewLineNumber);
-                Assert.AreEqual(18, result[0].Lines[17].DiffLineNumber);
+                Assert.That(26, Is.EqualTo(result[0].Lines[17].OldLineNumber));
+                Assert.That(25, Is.EqualTo(result[0].Lines[17].NewLineNumber));
+                Assert.That(18, Is.EqualTo(result[0].Lines[17].DiffLineNumber));
             }
         }
     }