matchers: optimize message generation (#1567)

Author: MykolaGolubyev

webtau-cli/src/main/java/org/testingisdocumenting/webtau/cli/expectation/CliOutputContainHandler.java

@@ -59,12 +59,12 @@ public void analyzeNotContain(ContainAnalyzer containAnalyzer, ValuePath actualP
 
         indexedValues.forEach(indexedValue ->
                 containAnalyzer.reportMatch(this, actualPath.index(indexedValue.idx()),
-                        tokenizedMessage().matcher("equals").value(indexedValue.value())
+                        () -> tokenizedMessage().matcher("equals").value(indexedValue.value())
                 ));
     }
 
     /*
-    for output we want to be able to mark matched lines, and so want to treat output as a list of lines.
+    for output, we want to be able to mark matched lines, and so want to treat output as a list of lines.
     at the same time we want a substring match within a line.
     so we will automatically convert expected text to a quoted regexp and pass it down to contain analyzer.
      */

webtau-core/src/main/java/org/testingisdocumenting/webtau/data/datanode/DataNodeListAndValueContainHandler.java

@@ -77,7 +77,7 @@ public void analyzeNotContain(ContainAnalyzer containAnalyzer, ValuePath actualP
                 ValuePath indexedPath = actualPath.index(indexedValue.idx());
 
                 containAnalyzer.reportMatch(this, indexedPath,
-                        tokenizedMessage().error("equals").valueFirstLinesOnly(indexedValue.value()));
+                        () -> tokenizedMessage().error("equals").valueFirstLinesOnly(indexedValue.value()));
                 comparator.compareUsingEqualOnly(indexedPath, dataNodes.get(indexedValue.idx()), expected);
             });
         }

webtau-core/src/main/java/org/testingisdocumenting/webtau/expectation/TokenizedReportUtils.java

@@ -104,8 +104,8 @@ private static void appendToReport(TokenizedMessage report,
                 return;
             }
 
-            boolean useFullMessage = !message.getActualPath().equals(topLevelActualPath);
-            report.add(useFullMessage ? message.getFullMessage() : message.getMessage());
+            boolean useFullMessage = !message.actualPath().equals(topLevelActualPath);
+            report.add(useFullMessage ? message.buildFullMessage() : message.buildMessage());
 
             boolean isLast = messageIdx == messages.size() - 1;
             if (!isLast) {

webtau-core/src/main/java/org/testingisdocumenting/webtau/expectation/contain/ContainAnalyzer.java

@@ -29,6 +29,7 @@
 import org.testingisdocumenting.webtau.utils.TraceUtils;
 
 import java.util.*;
+import java.util.function.Supplier;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
@@ -85,12 +86,12 @@ public void reportMismatches(ContainHandler reporter, List<ValuePathMessage> val
         mismatchMessages.addAll(valuePathMessages);
     }
 
-    public void reportMismatch(ContainHandler reporter, ValuePath actualPath, TokenizedMessage mismatch) {
+    public void reportMismatch(ContainHandler reporter, ValuePath actualPath, Supplier<TokenizedMessage> mismatch) {
         reportMismatch(reporter, new ValuePathMessage(actualPath, mismatch));
     }
 
     public void reportMissing(ContainHandler reporter, ValuePath actualPath, Object value) {
-        missingMessages.add(new ValuePathMessage(actualPath, tokenizedMessage().value(value)));
+        missingMessages.add(new ValuePathMessage(actualPath, () -> tokenizedMessage().value(value)));
     }
 
     public void reportMissing(ContainHandler reporter, ValuePathMessage valuePathMessage) {
@@ -105,7 +106,7 @@ public void reportMismatchedValue(Object oneOfExpectedValues) {
         mismatchedExpectedValues.add(oneOfExpectedValues);
     }
 
-    public void reportMatch(ContainHandler reporter, ValuePath actualPath, TokenizedMessage mismatch) {
+    public void reportMatch(ContainHandler reporter, ValuePath actualPath, Supplier<TokenizedMessage> mismatch) {
         matchMessages.add(new ValuePathMessage(actualPath, mismatch));
     }
 
@@ -123,9 +124,9 @@ public Set<ValuePath> generateMismatchPaths() {
 
     public TokenizedMessage generateMatchReport() {
         return TokenizedMessage.join("\n", matchMessages.stream().map(message ->
-                message.getActualPath().equals(topLevelActualPath) ?
-                        message.getMessage() :
-                        message.getFullMessage()).collect(Collectors.toList()));
+                message.actualPath().equals(topLevelActualPath) ?
+                        message.buildMessage() :
+                        message.buildFullMessage()).collect(Collectors.toList()));
     }
 
     public TokenizedMessage generateMismatchReport() {
@@ -158,6 +159,14 @@ public boolean noMatches() {
         return matchMessages.isEmpty();
     }
 
+    public int numberMatchMessages() {
+        return matchMessages.size();
+    }
+
+    public int numberOfMismatchMessages() {
+        return mismatchMessages.size() + missingMessages.size() + mismatchedExpectedValues.size();
+    }
+
     public void registerConvertedActualByPath(Map<ValuePath, Object> convertedActualByPath) {
         this.convertedActualByPath.putAll(convertedActualByPath);
     }
@@ -192,17 +201,17 @@ private boolean contains(ValuePath actualPath, Object actual, Object expected, b
 
         Object convertedExpected = handler.convertedExpected(actual, expected);
 
-        int before = isNegative ? matchMessages.size() : (mismatchMessages.size() + missingMessages.size() + mismatchedExpectedValues.size());
+        int before = isNegative ? numberMatchMessages() : numberOfMismatchMessages();
         containsLogic.execute(handler, convertedActual, convertedExpected);
-        int after = isNegative ? matchMessages.size() : (mismatchMessages.size() + missingMessages.size() + mismatchedExpectedValues.size());
+        int after = isNegative ? numberMatchMessages() : numberOfMismatchMessages();
 
         return after == before;
     }
 
     private Set<ValuePath> extractActualPaths(List<ValuePathMessage> notEqualMessages) {
         return notEqualMessages
                 .stream()
-                .map(ValuePathMessage::getActualPath)
+                .map(ValuePathMessage::actualPath)
                 .collect(Collectors.toSet());
     }
 

webtau-core/src/main/java/org/testingisdocumenting/webtau/expectation/contain/ContainExactlyMatcher.java

@@ -63,9 +63,9 @@ public Stream<Object> expectedValues() {
 
     @Override
     public Set<ValuePath> mismatchedPaths() {
-        Set<ValuePath> potentialPaths = Stream.concat(missingMessages.stream().map(ValuePathMessage::getActualPath),
-                        Stream.concat(extraMessages.stream().map(ValuePathMessage::getActualPath),
-                                notEqualCandidateMessages.stream().map(ValuePathMessage::getActualPath)))
+        Set<ValuePath> potentialPaths = Stream.concat(missingMessages.stream().map(ValuePathMessage::actualPath),
+                        Stream.concat(extraMessages.stream().map(ValuePathMessage::actualPath),
+                                notEqualCandidateMessages.stream().map(ValuePathMessage::actualPath)))
                 .collect(Collectors.toSet());
         return potentialPaths.isEmpty() ?
                 actualCopy.stream().map(ValuePathWithValue::getPath).collect(Collectors.toSet()) :
@@ -208,7 +208,7 @@ private List<ValuePathMessage> extractPotentialNotEqualMessages() {
                         }
 
                         ValuePathMessage firstMessage = batch.get(0);
-                        return actualPaths.stream().anyMatch(path -> firstMessage.getActualPath().startsWith(path));
+                        return actualPaths.stream().anyMatch(path -> firstMessage.actualPath().startsWith(path));
                     })
                     .toList();
 

webtau-core/src/main/java/org/testingisdocumenting/webtau/expectation/contain/handlers/CombinedMismatchAndMissing.java

@@ -29,7 +29,7 @@ int size() {
 
     List<ValuePath> extractPaths() {
         return Stream.concat(
-                mismatchMessages.stream().map(ValuePathMessage::getActualPath),
-                missingMessage.stream().map(ValuePathMessage::getActualPath)).toList();
+                mismatchMessages.stream().map(ValuePathMessage::actualPath),
+                missingMessage.stream().map(ValuePathMessage::actualPath)).toList();
     }
 }

webtau-core/src/main/java/org/testingisdocumenting/webtau/expectation/contain/handlers/IterableAndSingleValueContainHandler.java

@@ -66,7 +66,8 @@ public void analyzeNotContain(ContainAnalyzer containAnalyzer, ValuePath actualP
         List<IndexedValue> indexedValues = analyzer.findContainingIndexedValues();
 
         if (!indexedValues.isEmpty()) {
-            analyzer.getComparator().getEqualMessages().forEach(message -> containAnalyzer.reportMatch(this, message.getActualPath(), message.getMessage()));
+            analyzer.getComparator().getEqualMessages().forEach(message ->
+                    containAnalyzer.reportMatch(this, message.actualPath(), message.messageFunc()));
         }
 
         containAnalyzer.registerConvertedActualByPath(analyzer.getComparator().getConvertedActualByPath());

webtau-core/src/main/java/org/testingisdocumenting/webtau/expectation/contain/handlers/IterableContainAnalyzer.java

@@ -49,6 +49,7 @@ public List<IndexedValue> findContainingIndexedValues() {
             Object actualValue = iterator.next();
             ValuePath indexedPath = actualPath.index(idx);
 
+            // shit is happening here for large numbers
             CompareToResult compareToResult = comparator.compareUsingEqualOnly(indexedPath, actualValue, expected);
             boolean isEqual = compareToResult.isEqual();
             if (isEqual) {

webtau-core/src/main/java/org/testingisdocumenting/webtau/expectation/contain/handlers/MapContainHandler.java

@@ -79,7 +79,7 @@ private void analyzeMapAndMapSingleExpectedEntry(ContainAnalyzer containAnalyzer
                 comparator.getMissingMessages().forEach(m -> containAnalyzer.reportMissing(this, m));
                 comparator.getNotEqualMessages().forEach(m -> containAnalyzer.reportMismatch(this, m));
             } else {
-                containAnalyzer.reportMatch(this, propertyPath, comparator.generateEqualMatchReport());
+                containAnalyzer.reportMatch(this, propertyPath, comparator::generateEqualMatchReport);
             }
         }
     }

webtau-core/src/main/java/org/testingisdocumenting/webtau/expectation/contain/handlers/NullContainHandler.java

@@ -31,11 +31,11 @@ public boolean handle(Object actual, Object expected) {
 
     @Override
     public void analyzeContain(ContainAnalyzer containAnalyzer, ValuePath actualPath, Object actual, Object expected) {
-        containAnalyzer.reportMismatch(this, actualPath, tokenizedMessage().valueFirstLinesOnly(actual).error("doesn't contain").valueFirstLinesOnly(expected));
+        containAnalyzer.reportMismatch(this, actualPath, () -> tokenizedMessage().valueFirstLinesOnly(actual).error("doesn't contain").valueFirstLinesOnly(expected));
     }
 
     @Override
     public void analyzeNotContain(ContainAnalyzer containAnalyzer, ValuePath actualPath, Object actual, Object expected) {
-        containAnalyzer.reportMismatch(this, actualPath, tokenizedMessage().valueFirstLinesOnly(actual).error("doesn't contain").valueFirstLinesOnly(expected));
+        containAnalyzer.reportMismatch(this, actualPath, () -> tokenizedMessage().valueFirstLinesOnly(actual).error("doesn't contain").valueFirstLinesOnly(expected));
     }
 }