Make tests for for DiffUtilities.Match easier to understand

Author: jcansdale

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

@@ -185,38 +185,41 @@ public void InvalidDiffLineChangeChar(string line, string expectMessage)
 
         public class TheMatchMethod
         {
+            /// <param name="diffLines">Target diff chunk with header (with '.' as line separator)</param>
+            /// <param name="matchLines">Diff lines to match (with '.' as line separator)</param>
+            /// <param name="expectedDiffLineNumber">The DiffLineNumber that the last line of matchLines falls on</param>
             [Theory]
-            [InlineData(" 1", " 1", 0)]
-            [InlineData(" 1. 2", " 2", 1)]
-            [InlineData(" 1. 1", " 1", 1)] // match the later line
+            [InlineData(" 1", " 1", 1)]
+            [InlineData(" 1. 2", " 2", 2)]
+            [InlineData(" 1. 1", " 1", 2)] // match the later line
             [InlineData("+x", "-x", -1)]
             [InlineData("", " x", -1)]
             [InlineData(" x", "", -1)]
 
-            [InlineData(" 1. 2.", " 1. 2.", 1)] // matched full context
+            [InlineData(" 1. 2.", " 1. 2.", 2)] // matched full context
             [InlineData(" 1. 2.", " 3. 2.", -1)] // didn't match full context
-            [InlineData(" 2.", " 1. 2.", 0)] // match if we run out of context lines
+            [InlineData(" 2.", " 1. 2.", 1)] // match if we run out of context lines
 
             // Tests for https://github.com/github/VisualStudio/issues/1149
             // Matching algorithm got confused when there was a partial match.
-            [InlineData("+a.+x.+x.", "+a.+x.", 1)]
-            [InlineData("+a.+x.+x.", "+a.+x.+x.", 2)]
-            [InlineData("+a.+x.+x.+b.+x.+x.", "+a.+x.", 1)]
-            [InlineData("+a.+x.+x.+b.+x.+x.", "+b.+x.", 4)]
+            [InlineData("+a.+x.+x.", "+a.+x.", 2)]
+            [InlineData("+a.+x.+x.", "+a.+x.+x.", 3)]
+            [InlineData("+a.+x.+x.+b.+x.+x.", "+a.+x.", 2)]
+            [InlineData("+a.+x.+x.+b.+x.+x.", "+b.+x.", 5)]
             [InlineData("+a.+b.+x", "+a.+x.", -1)] // backtrack when there is a failed match
-            public void MatchLine(string lines1, string lines2, int skip /* -1 for no match */)
+            public void MatchLine(string diffLines, string matchLines, int expectedDiffLineNumber /* -1 for no match */)
             {
                 var header = "@@ -1 +1 @@";
-                lines1 = lines1.Replace(".", "\r\n");
-                lines2 = lines2.Replace(".", "\r\n");
-                var chunks1 = DiffUtilities.ParseFragment(header + "\n" + lines1).ToList();
-                var chunks2 = DiffUtilities.ParseFragment(header + "\n" + lines2).ToList();
-                var expectLine = (skip != -1) ? chunks1.First().Lines[skip] : null;
+                diffLines = diffLines.Replace(".", "\r\n");
+                matchLines = matchLines.Replace(".", "\r\n");
+                var chunks1 = DiffUtilities.ParseFragment(header + "\n" + diffLines).ToList();
+                var chunks2 = DiffUtilities.ParseFragment(header + "\n" + matchLines).ToList();
                 var targetLines = chunks2.First().Lines.Reverse().ToList();
 
                 var line = DiffUtilities.Match(chunks1, targetLines);
 
-                Assert.Equal(expectLine, line);
+                var diffLineNumber = (line != null) ? line.DiffLineNumber : -1;
+                Assert.Equal(expectedDiffLineNumber, diffLineNumber);
             }
 
             [Fact]