Merge branch 'main' into dev/mr/addai2

Author: MarcoRossignoli

src/TestFramework/TestFramework/Assertions/Assert.AreEqual.cs

@@ -1483,14 +1483,23 @@ public static Tuple<string, string, int> CreateStringPreviews(string expected, s
         int shorterStringLength = shorterString.Length;
         int longerStringLength = longerString.Length;
 
-        // End marker will point to the end of the shorter string, but the end of the longer string will be replaced by ...
-        // make sure we don't point at the dots. To do this we need to make sure the strings are cut at the beginning, rather than preferring the maximum context shown.
-        bool markerPointsAtEllipsis = longerStringLength - shorterStringLength > ellipsisLength && shorterStringLength - diffIndex < ellipsisLength;
+        // End marker will point to the end of the shorter string, but the end of the longer string will be replaced by ... when it reaches the end of the preview.
+        // Make sure we don't point at the dots. To do this we need to make sure the strings are cut at the beginning, rather than preferring the maximum context shown.
+        //
+        // Marker needs to point where ellipsis would be when we shorten the longer string.
+        bool markerPointsAtTheEnd = shorterStringLength - diffIndex <= ellipsisLength;
+        // Strings need to have different lengths, for same length strings we don't add ellipsis.
+        bool stringsHaveDifferentLength = longerStringLength > shorterStringLength;
+        // Shorter string needs to be long enough to fill the preview window to the point where ellipsis shows up (last 3 chars).
+        bool shorterStringIsLongEnoughToFillPreviewWindow = shorterStringLength >= fullPreviewLength - ellipsisLength;
+        bool markerPointsAtEllipsis = markerPointsAtTheEnd && stringsHaveDifferentLength && shorterStringIsLongEnoughToFillPreviewWindow;
         int ellipsisSpaceOrZero = markerPointsAtEllipsis ? ellipsisLength + 2 : 0;
 
-        // Find the end of the string that we will show, either then end of the shorter string, or the end of the preview window.
+        // Find the end of the string that we will show, either the end of the shorter string, or the end of the preview window.
+        int endOfString = Math.Min(diffIndex + contextLength, shorterStringLength);
+
         // Then calculate the start of the preview from that. This makes sure that if diff is close end of the string we show as much as we can.
-        int start = Math.Min(diffIndex + contextLength, shorterStringLength) - fullPreviewLength + ellipsisSpaceOrZero;
+        int start = endOfString - fullPreviewLength + ellipsisSpaceOrZero;
 
         // If the string is shorter than the preview, start cutting from 0, otherwise start cutting from the calculated start.
         int cutStart = Math.Max(0, start);

test/UnitTests/TestFramework.UnitTests/Assertions/AssertTests.AreEqualTests.cs

@@ -1524,11 +1524,13 @@ public void CreateStringPreviews_DiffPointsToCorrectPlaceInNonShortenedString()
         int length = 1;
         int diffIndex = 0;
         string stringPreview = FormatStringPreview(StringPreviewHelper.CreateStringPreviews(DigitString(length, diffIndex), DigitString(length, diffIndex), diffIndex, preview));
-        stringPreview.Should().Be("""
+        StringPreviewsAreEqual(
+            """
             "X"
             "X"
             _^
-            """);
+            """,
+            stringPreview);
     }
 
     public void CreateStringPreviews_DiffPointsToCorrectPlaceInShortenedStringWithEndCut()
@@ -1537,11 +1539,12 @@ public void CreateStringPreviews_DiffPointsToCorrectPlaceInShortenedStringWithEn
         int length = preview + 10;
         int diffIndex = 0;
         string stringPreview = FormatStringPreview(StringPreviewHelper.CreateStringPreviews(DigitString(length, diffIndex), DigitString(length, diffIndex), diffIndex, preview));
-        stringPreview.Should().Be("""
+        StringPreviewsAreEqual(
+            """
             "X12345..."
             "X12345..."
             _^
-            """);
+            """, stringPreview);
     }
 
     public void CreateStringPreviews_DiffPointsToCorrectPlaceInShortenedStringWithStartCut()
@@ -1550,11 +1553,13 @@ public void CreateStringPreviews_DiffPointsToCorrectPlaceInShortenedStringWithSt
         int length = 10;
         int diffIndex = 9;
         string stringPreview = FormatStringPreview(StringPreviewHelper.CreateStringPreviews(DigitString(length, diffIndex), DigitString(length, diffIndex), diffIndex: diffIndex, preview));
-        stringPreview.Should().Be("""
+        StringPreviewsAreEqual(
+            """
             "...45678X"
             "...45678X"
             _________^
-            """);
+            """,
+            stringPreview);
     }
 
     public void CreateStringPreviews_ShowWholeStringWhenDifferenceIsAtTheEndAndJustOneStringDoesNotFit()
@@ -1563,11 +1568,13 @@ public void CreateStringPreviews_ShowWholeStringWhenDifferenceIsAtTheEndAndJustO
         int length = 50;
         int diffIndex = 16;
         string stringPreview = FormatStringPreview(StringPreviewHelper.CreateStringPreviews(DigitString(preview, diffIndex), DigitString(length, diffIndex), diffIndex: diffIndex, preview));
-        stringPreview.Should().Be("""
+        StringPreviewsAreEqual(
+            """
             "0123456789012345X7890"
             "0123456789012345X7..."
             _________________^
-            """);
+            """,
+            stringPreview);
     }
 
     public void CreateStringPreviews_MakeSureWeDontPointToEndEllipsis()
@@ -1578,11 +1585,44 @@ public void CreateStringPreviews_MakeSureWeDontPointToEndEllipsis()
         int diffIndex = 24;
 
         string stringPreview = FormatStringPreview(StringPreviewHelper.CreateStringPreviews(DigitString(preview, diffIndex), DigitString(length, diffIndex), diffIndex: diffIndex, preview));
-        stringPreview.Should().Be("""
+        StringPreviewsAreEqual(
+            """
             "...8901234567890123X"
             "...8901234567890123X56..."
             ____________________^
-            """);
+            """,
+            stringPreview);
+    }
+
+    public void CreateStringPreviews_MakeSureWeDontPointToEndEllipsis_WhenLongerStringOneCharLargerThanPreviewWindow()
+    {
+        // We will mask last 3 chars of the string, so we need to make sure that the diff index is not pointing to the end ellipsis.
+        int preview = 15;
+        int diffIndex = preview - 1;
+
+        string stringPreview = FormatStringPreview(StringPreviewHelper.CreateStringPreviews(DigitString(preview, diffIndex), DigitString(preview + 1, diffIndex), diffIndex: diffIndex, preview));
+        StringPreviewsAreEqual(
+            """
+            "...890123X"
+            "...890123X5"
+            __________^
+            """,
+            stringPreview);
+    }
+
+    public void CreateStringPreviews_MakeSureWeDontPointToEndEllipsis_WhenLongerStringIsBarelyLonger()
+    {
+        // We will mask last 3 chars of the string, so we need to make sure that the diff index is not pointing to the end ellipsis.
+        int preview = 25;
+
+        string stringPreview = FormatStringPreview(StringPreviewHelper.CreateStringPreviews("01234567890123456789012345678901234567890123X", "01234567890123456789012345678901234567890123X56", diffIndex: 44, preview));
+        StringPreviewsAreEqual(
+            """
+            "...8901234567890123X"
+            "...8901234567890123X56"
+            ____________________^
+            """,
+            stringPreview);
     }
 
     public void CreateStringPreviews_DiffPointsAfterLastCharacterWhenStringsAreAllTheSameCharactersUntilTheEndOfTheShorterOne()
@@ -1597,6 +1637,45 @@ public void CreateStringPreviews_DiffPointsAfterLastCharacterWhenStringsAreAllTh
             """);
     }
 
+    public void CreateStringPreviews_DiffNeverPointsAtEllipsis_Generated()
+    {
+        // Generate all combinations of string lengths and diff to see if in any of them we point to ellipsis.
+        StringBuilder s = new();
+        foreach (int a in Enumerable.Range(1, 20))
+        {
+            foreach (int e in Enumerable.Range(1, 20))
+            {
+                foreach (int d in Enumerable.Range(1, Math.Min(a, e)))
+                {
+                    string p = FormatStringPreview(StringPreviewHelper.CreateStringPreviews(DigitString(e, d), DigitString(a, d), diffIndex: d, 11));
+
+                    string[] lines = p.Split("\n");
+                    int diffIndicator = lines[2].IndexOf('^');
+                    bool line0PointsOnEllipsis = lines[0].Length > diffIndicator && lines[0][diffIndicator] == '.';
+                    bool line1PointsOnEllipsis = lines[1].Length > diffIndicator && lines[1][diffIndicator] == '.';
+
+                    if (line0PointsOnEllipsis || line1PointsOnEllipsis)
+                    {
+                        string text = $"""
+                            Failed for:
+                            Expected={e}, Actual={a}, DiffIndex={d}
+                            string result = FormatStringPreview(StringPreviewHelper.CreateStringPreviews(DigitString({e}, {d}), DigitString({a}, {d}), diffIndex: {d}, 11));
+                            {p}
+                            """;
+
+                        s.AppendLine(text);
+                        s.AppendLine();
+                    }
+                }
+            }
+        }
+
+        if (s.Length > 0)
+        {
+            throw new InvalidOperationException($"Some combinations pointed to ellipsis:\n{s}");
+        }
+    }
+
     private string FormatStringPreview(Tuple<string, string, int> tuple)
         => $"""
             "{tuple.Item1}"
@@ -1628,4 +1707,19 @@ private static string DigitString(int length, int diffIndex)
 
         return result.ToString();
     }
+
+    private void StringPreviewsAreEqual(string expected, string actual)
+    {
+        if (expected != actual)
+        {
+            throw new InvalidOperationException(
+                $"""
+                Actual:
+                {actual}
+
+                Expected:
+                {expected}
+                """);
+        }
+    }
 }