DRY follow-ups: collapse * early-returns, EscapeForDisplay delegates to EscapeChar, extract test helpers

- WildcardMatchAnalyzer: collapse two identical early-exit paths in ExtractWildcardMatches
  into one combined condition (nextPatternPos >= Length || nextLiteralIndex == -1);
  compute FindNextLiteralMatch once before the guard.
- WildcardMatchAnalyzer: EscapeForDisplay now iterates chars and delegates to EscapeChar
  via StringBuilder, eliminating three chained .Replace calls.
- EnhancedErrorMessageTests: extract GetMismatchMessage() helper used by three tests.
- WildcardMatchAnalyzerTests: extract GetDiff() helper used by two GenerateDetailedDiff tests.

Author: BenjaminMichaelis

IntelliTect.TestTools.Console.Tests/EnhancedErrorMessageTests.cs

@@ -6,78 +6,56 @@ namespace IntelliTect.TestTools.Console.Tests;
 [TestClass]
 public class EnhancedErrorMessageTests
 {
+    /// <summary>
+    /// Runs <paramref name="consoleAction"/> via <see cref="ConsoleAssert.ExpectLike"/>, asserts it
+    /// throws <see cref="ConsoleAssertException"/>, and returns the exception message.
+    /// </summary>
+    private static string GetMismatchMessage(string expected, Action consoleAction)
+    {
+        var ex = Assert.ThrowsExactly<ConsoleAssertException>(
+            () => ConsoleAssert.ExpectLike(expected, consoleAction));
+        return ex.Message;
+    }
+
     [TestMethod]
     public void ExpectLike_WildcardMismatch_ShowsDetailedDiff()
     {
-        // Arrange - pattern with wildcards that will NOT match
-        string expected = "PING *(::1) 56 data bytes\n64 bytes from *";
-
-        // Act & Assert - ConsoleAssert throws ConsoleAssertException on mismatch
-        ConsoleAssertException exception = Assert.ThrowsExactly<ConsoleAssertException>(() =>
-        {
-            ConsoleAssert.ExpectLike(expected, () =>
-            {
-                System.Console.Write("PING localhost(::1) WRONG data bytes\n64 bytes from localhost");
-            });
-        });
+        string errorMessage = GetMismatchMessage(
+            "PING *(::1) 56 data bytes\n64 bytes from *",
+            () => System.Console.Write("PING localhost(::1) WRONG data bytes\n64 bytes from localhost"));
 
-        // Assert - Check that the error message contains the enhanced output
-        string errorMessage = exception.Message;
-
-        // Should contain the line-by-line comparison header
         StringAssert.Contains(errorMessage, "Line-by-line comparison");
-
-        // Should contain status indicators
-        StringAssert.Contains(errorMessage, "❌");  // Lines don't match
+        StringAssert.Contains(errorMessage, "❌");
     }
 
     [TestMethod]
     public void ExpectLike_ExtraLines_IdentifiedAsSuch()
     {
-        // Arrange - pattern expecting one line, but getting two
-        string expected = "Line 1";
-
-        // Act & Assert
-        ConsoleAssertException exception = Assert.ThrowsExactly<ConsoleAssertException>(() =>
-        {
-            ConsoleAssert.ExpectLike(expected, () =>
+        string errorMessage = GetMismatchMessage(
+            "Line 1",
+            () =>
             {
                 System.Console.WriteLine("Line 1");
                 System.Console.WriteLine("Line 2");
             });
-        });
 
-        // Assert
-        string errorMessage = exception.Message;
-        // With line-by-line comparison, we should see the extra line marked
         StringAssert.Contains(errorMessage, "Line 2: ❌");
         StringAssert.Contains(errorMessage, "Unexpected extra line");
     }
 
     [TestMethod]
     public void ExpectLike_MissingLines_IdentifiedAsSuch()
     {
-        // Arrange - pattern with wildcards expecting more lines
-        string expected = "Line 1\nLine *";
-
-        // Act & Assert
-        ConsoleAssertException exception = Assert.ThrowsExactly<ConsoleAssertException>(() =>
-        {
-            ConsoleAssert.ExpectLike(expected, () =>
-            {
-                System.Console.WriteLine("Line 1");
-            });
-        });
+        string errorMessage = GetMismatchMessage(
+            "Line 1\nLine *",
+            () => System.Console.WriteLine("Line 1"));
 
-        // Assert
-        string errorMessage = exception.Message;
         StringAssert.Contains(errorMessage, "Missing line");
     }
 
     [TestMethod]
     public void ExpectLike_SuccessfulWildcardMatch_DoesNotThrow()
     {
-        // Verify the feature doesn't break the happy path
         ConsoleAssert.ExpectLike("Hello * world", () =>
         {
             System.Console.Write("Hello beautiful world");

IntelliTect.TestTools.Console.Tests/WildcardMatchAnalyzerTests.cs

@@ -6,6 +6,18 @@ namespace IntelliTect.TestTools.Console.Tests;
 [TestClass]
 public class WildcardMatchAnalyzerTests
 {
+    /// <summary>
+    /// Calls <see cref="WildcardMatchAnalyzer.AnalyzeMatch"/> then
+    /// <see cref="WildcardMatchAnalyzer.GenerateDetailedDiff"/> and asserts the result is non-empty.
+    /// </summary>
+    private static string GetDiff(string expected, string actual)
+    {
+        var results = WildcardMatchAnalyzer.AnalyzeMatch(expected, actual);
+        string diff = WildcardMatchAnalyzer.GenerateDetailedDiff(results);
+        Assert.IsFalse(string.IsNullOrEmpty(diff));
+        return diff;
+    }
+
     [TestMethod]
     public void AnalyzeMatch_SingleLineMatch_IdentifiesWildcardMatches()
     {
@@ -96,37 +108,19 @@ public void AnalyzeMatch_MissingLinesInActual_MarkedAsMissing()
     [TestMethod]
     public void GenerateDetailedDiff_CreatesReadableOutput()
     {
-        // Arrange
-        string expected = "Hello * world\nLine *";
-        string actual = "Hello beautiful world\nLine 2";
-
-        var results = WildcardMatchAnalyzer.AnalyzeMatch(expected, actual);
-
-        // Act
-        string diff = WildcardMatchAnalyzer.GenerateDetailedDiff(results);
+        string diff = GetDiff("Hello * world\nLine *", "Hello beautiful world\nLine 2");
 
-        // Assert
-        Assert.IsFalse(string.IsNullOrEmpty(diff));
         StringAssert.Contains(diff, "Line-by-line comparison");
-        StringAssert.Contains(diff, "✅"); // Should contain success markers
+        StringAssert.Contains(diff, "✅");
         StringAssert.Contains(diff, "Wildcard matches");
     }
 
     [TestMethod]
     public void GenerateDetailedDiff_WithMismatch_ShowsFailure()
     {
-        // Arrange
-        string expected = "Expected text";
-        string actual = "Actual text";
-
-        var results = WildcardMatchAnalyzer.AnalyzeMatch(expected, actual);
+        string diff = GetDiff("Expected text", "Actual text");
 
-        // Act
-        string diff = WildcardMatchAnalyzer.GenerateDetailedDiff(results);
-
-        // Assert
-        Assert.IsFalse(string.IsNullOrEmpty(diff));
-        StringAssert.Contains(diff, "❌"); // Should contain failure marker
+        StringAssert.Contains(diff, "❌");
     }
 
     [TestMethod]

IntelliTect.TestTools.Console/WildcardMatchAnalyzer.cs

@@ -210,24 +210,15 @@ private static void ExtractWildcardMatches(string pattern, string text, List<Wil
                     nextPatternPos++;
                 }
 
-                if (nextPatternPos >= pattern.Length)
-                {
-                    // '*' at the end matches everything remaining
-                    wildcardMatches.Add(new WildcardMatch
-                    {
-                        Pattern = "*",
-                        MatchedText = text.Substring(textPos)
-                    });
-                    return;
-                }
+                // Find where the next literal prefix of the remaining pattern appears in the text.
+                // If '*' is at the end of the pattern, skip the search entirely.
+                string remainingPattern = nextPatternPos < pattern.Length ? pattern.Substring(nextPatternPos) : null;
+                int nextLiteralIndex = remainingPattern != null ? FindNextLiteralMatch(text, textPos, remainingPattern) : -1;
 
-                // Find where the next literal prefix of the remaining pattern appears in the text
-                string remainingPattern = pattern.Substring(nextPatternPos);
-                int nextLiteralIndex = FindNextLiteralMatch(text, textPos, remainingPattern);
-
-                if (nextLiteralIndex == -1)
+                if (nextPatternPos >= pattern.Length || nextLiteralIndex == -1)
                 {
-                    // Could not find a match for the remaining pattern — '*' consumed the rest
+                    // '*' at the end of pattern, or remaining pattern has no literal anchor —
+                    // consume everything remaining in the text.
                     wildcardMatches.Add(new WildcardMatch
                     {
                         Pattern = "*",
@@ -384,10 +375,10 @@ private static string EscapeForDisplay(string text)
         if (text == null) return "<null>";
         if (text == string.Empty) return "<empty>";
 
-        return text
-            .Replace("\r", "\\r")
-            .Replace("\n", "\\n")
-            .Replace("\t", "\\t");
+        var sb = new StringBuilder(text.Length);
+        foreach (char c in text)
+            sb.Append(EscapeChar(c));
+        return sb.ToString();
     }
 
     /// <summary>