Address code review feedback from Opus 4.6 and GPT 5.5: fix character comparison, improve error messages, add tests

Agent-Logs-Url: https://github.com/IntelliTect/TestTools.Console/sessions/943fe6ed-ccf1-44d1-84c7-c731a06c2830

Co-authored-by: BenjaminMichaelis <22186029+BenjaminMichaelis@users.noreply.github.com>

Author: Copilot

:GITHUB_ENV

@@ -0,0 +1 @@
+COPILOT_SETUP_COMPLETE=true

IntelliTect.TestTools.Console.Tests/WildcardMatchAnalyzerTests.cs

@@ -128,4 +128,63 @@ public void GenerateDetailedDiff_WithMismatch_ShowsFailure()
         Assert.IsFalse(string.IsNullOrEmpty(diff));
         StringAssert.Contains(diff, "❌"); // Should contain failure marker
     }
+
+    [TestMethod]
+    public void AnalyzeMatch_EmptyStrings_HandlesGracefully()
+    {
+        // Arrange & Act
+        var results = WildcardMatchAnalyzer.AnalyzeMatch("", "");
+
+        // Assert - Empty strings result in no lines to compare
+        Assert.AreEqual(0, results.Count);
+    }
+
+    [TestMethod]
+    public void AnalyzeMatch_QuestionMarkWildcard_TracksMatch()
+    {
+        // Arrange
+        string expected = "test?";
+        string actual = "test1";
+
+        // Act
+        var results = WildcardMatchAnalyzer.AnalyzeMatch(expected, actual);
+
+        // Assert
+        Assert.AreEqual(1, results.Count);
+        Assert.IsTrue(results[0].IsMatch);
+        Assert.AreEqual(1, results[0].WildcardMatches.Count);
+        Assert.AreEqual("?", results[0].WildcardMatches[0].Pattern);
+        Assert.AreEqual("1", results[0].WildcardMatches[0].MatchedText);
+    }
+
+    [TestMethod]
+    public void AnalyzeMatch_MultipleConsecutiveWildcards_HandlesCorrectly()
+    {
+        // Arrange
+        string expected = "a***b";
+        string actual = "aXXXb";
+
+        // Act
+        var results = WildcardMatchAnalyzer.AnalyzeMatch(expected, actual);
+
+        // Assert
+        Assert.AreEqual(1, results.Count);
+        Assert.IsTrue(results[0].IsMatch);
+    }
+
+    [TestMethod]
+    public void AnalyzeMatch_MixedLineEndings_HandlesCorrectly()
+    {
+        // Arrange
+        string expected = "Line 1\r\nLine 2";
+        string actual = "Line 1\nLine 2";
+
+        // Act
+        var results = WildcardMatchAnalyzer.AnalyzeMatch(expected, actual);
+
+        // Assert
+        Assert.AreEqual(2, results.Count);
+        Assert.IsTrue(results[0].IsMatch);
+        Assert.IsTrue(results[1].IsMatch);
+    }
 }

IntelliTect.TestTools.Console/ConsoleAssert.cs

@@ -585,15 +585,19 @@ private static string GetMessageText(string expectedOutput, string output, strin
         else
         {
             // Write the output that shows the difference.
-            for (int counter = 0; counter < Math.Min(expectedOutput.Length, output.Length); counter++)
+            // Skip character-by-character comparison for wildcard matching as it's not meaningful
+            if (!isWildcardMatching)
             {
-                if (expectedOutput[counter] != output[counter]) // TODO: The message is invalid when using wild cards.
+                for (int counter = 0; counter < Math.Min(expectedOutput.Length, output.Length); counter++)
                 {
-                    result += Environment.NewLine
-                        + $"Character {counter} did not match: "
-                        + $"'{CSharpStringEncode(expectedOutput[counter])}' != '{CSharpStringEncode(output[counter])})'";
-
-                    break;
+                    if (expectedOutput[counter] != output[counter])
+                    {
+                        result += Environment.NewLine
+                            + $"Character {counter} did not match: "
+                            + $"'{CSharpStringEncode(expectedOutput[counter])}' != '{CSharpStringEncode(output[counter])})'";
+
+                        break;
+                    }
                 }
             }
         }
@@ -606,13 +610,17 @@ private static string GetMessageText(string expectedOutput, string output, strin
                 var matchResults = WildcardMatchAnalyzer.AnalyzeMatch(expectedOutput, output);
                 result += WildcardMatchAnalyzer.GenerateDetailedDiff(matchResults);
             }
-            catch (ArgumentException)
+            catch (ArgumentException ex)
             {
-                // Pattern analysis failed - skip detailed diff
+                // Pattern analysis failed - inform user but don't crash
+                result += Environment.NewLine + 
+                    $"⚠️  Note: Could not generate detailed wildcard analysis: {ex.Message}";
             }
-            catch (InvalidOperationException)
+            catch (InvalidOperationException ex)
             {
-                // Analysis encountered an unexpected state - skip detailed diff
+                // Analysis encountered an unexpected state - inform user but don't crash
+                result += Environment.NewLine + 
+                    $"⚠️  Note: Wildcard analysis encountered an error: {ex.Message}";
             }
         }
 

IntelliTect.TestTools.Console/WildcardMatchAnalyzer.cs

@@ -1,3 +1,5 @@
+using System.Text;
+
 namespace IntelliTect.TestTools.Console;
 
 /// <summary>
@@ -172,7 +174,17 @@ private static bool MatchLineWithWildcards(string pattern, string text, List<Wil
 
     /// <summary>
     /// Extracts what each wildcard in the pattern matched in the text.
-    /// This uses a greedy approach to match wildcards.
+    /// 
+    /// Algorithm:
+    /// 1. For '*': Greedily matches text until the next literal character in pattern
+    /// 2. For '?': Matches exactly one character
+    /// 3. For '[...]': Matches one character from the set
+    /// 
+    /// Note: This is a simplified extraction that uses a greedy approach and may not 
+    /// perfectly represent the actual backtracking behavior of WildcardPattern.IsMatch().
+    /// It's designed to give users helpful debugging information rather than to be a 
+    /// perfect replica of the matching engine. In complex patterns with multiple wildcards,
+    /// the actual match may differ from what this heuristic reports.
     /// </summary>
     private static void ExtractWildcardMatches(string pattern, string text, List<WildcardMatch> wildcardMatches)
     {