Refactored how tests are printed

Small visual changes to how the tests are shown being ran, reducing noise by removing duplicated qualified paths. At the end of the test run, it prints, on a per-module base, the errors with the file, error message and code block, but Maven still duplicates it at the end.

Author: cheestree

liquidjava-verifier/src/main/java/liquidjava/api/CommandLineLauncher.java

@@ -1,6 +1,8 @@
 package liquidjava.api;
 
 import java.io.File;
+import java.nio.file.Path;
+import java.nio.file.Paths;
 import java.util.Arrays;
 import java.util.List;
 
@@ -20,6 +22,7 @@ public class CommandLineLauncher {
 
     private static final Diagnostics diagnostics = Diagnostics.getInstance();
     private static final ContextHistory contextHistory = ContextHistory.getInstance();
+    private static String lastPrintedParent = null;
 
     public static void main(String[] args) {
         if (args.length == 0) {
@@ -45,7 +48,19 @@ public static void main(String[] args) {
     }
 
     public static void launch(String... paths) {
-        System.out.println("Running LiquidJava on: " + Arrays.toString(paths).replaceAll("[\\[\\]]", ""));
+        StringBuilder output = new StringBuilder();
+        for (String path : paths) {
+            String currentParent = new File(path).getParent();
+            if (output.length() > 0)
+                output.append(System.lineSeparator());
+            if (!(currentParent != null && currentParent.equals(lastPrintedParent))) {
+                output.append(Template.LAUNCH_PREFIX).append(toRelativePath(path));
+            } else {
+                output.append(Template.LAUNCH_PREFIX_SPACER).append(getNonQualifiedName(path));
+            }
+            lastPrintedParent = currentParent;
+        }
+        System.out.println(output);
 
         diagnostics.clear();
         contextHistory.clearHistory();
@@ -77,4 +92,19 @@ public static void launch(String... paths) {
         if (root != null)
             processingManager.process(root);
     }
+
+    private static String getNonQualifiedName(String path) {
+        String name = new File(path).getName();
+        return name.isEmpty() ? path : name;
+    }
+
+    private static String toRelativePath(String path) {
+        try {
+            Path cwd = Paths.get(".").toAbsolutePath().normalize();
+            Path target = Paths.get(path).toAbsolutePath().normalize();
+            return cwd.relativize(target).toString();
+        } catch (Exception e) {
+            return path;
+        }
+    }
 }

liquidjava-verifier/src/main/java/liquidjava/api/Template.java

@@ -0,0 +1,17 @@
+package liquidjava.api;
+
+public final class Template {
+
+    public static final int TEST_MESSAGE_GAP = 5;
+    public static final String LAUNCH_PREFIX = "Running LiquidJava on: ";
+    public static final String LAUNCH_PREFIX_SPACER = String.format("%" + LAUNCH_PREFIX.length() + "s", "");
+
+    private Template() {
+        // utility class
+    }
+
+    public static String formatFailureAtRight(String testName, String message) {
+        String gap = String.format("%" + TEST_MESSAGE_GAP + "s", "");
+        return LAUNCH_PREFIX_SPACER + testName + gap + message;
+    }
+}

liquidjava-verifier/src/test/java/liquidjava/api/tests/TestExamples.java

@@ -1,18 +1,24 @@
 package liquidjava.api.tests;
 
 import static liquidjava.utils.TestUtils.*;
-import static org.junit.Assert.fail;
 
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.util.Optional;
+import java.util.Set;
+import java.util.stream.Collectors;
 import java.util.stream.Stream;
+
+import static org.junit.Assert.fail;
+
 import liquidjava.api.CommandLineLauncher;
+import liquidjava.api.Template;
 import liquidjava.diagnostics.Diagnostics;
 
 import liquidjava.diagnostics.errors.LJError;
+
 import org.junit.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.MethodSource;
@@ -39,40 +45,43 @@ public void testPath(final Path path) {
 
         // verification should pass, check if any errors were found
         if (shouldPass(pathName) && diagnostics.foundError()) {
-            System.out.println("Error in: " + pathName + " --- should pass but an error was found");
-            fail();
+            LJError error = diagnostics.getErrors().iterator().next();
+            printFailureAtRight(pathName, "should pass but an error was found");
+            failCompact(formatShouldPassErrorMessage(pathName, error));
         }
         // verification should fail, check if it failed as expected (we assume each error test has exactly one error)
         else if (shouldFail(pathName)) {
             if (!diagnostics.foundError()) {
-                System.out.println("Error in: " + pathName + " --- should fail but no errors were found");
-                fail();
+                printFailureAtRight(pathName, "should fail but no errors were found");
+                failCompact("Expected an error but none were found");
             } else {
                 // check if expected error was found
                 Optional<String> expected = isDirectory ? getExpectedErrorFromDirectory(path)
                         : getExpectedErrorFromFile(path);
                 if (diagnostics.getErrors().size() > 1) {
-                    System.out.println("Multiple errors found in: " + pathName + " --- expected exactly one error");
-                    fail();
+                    Set<String> errorTitles = diagnostics.getErrors().stream().map(LJError::getTitle)
+                            .collect(Collectors.toSet());
+                    printFailureAtRight(pathName, "expected exactly one error, but found multiple: " + errorTitles);
+                    failCompact(errorTitles.toString());
                 }
                 LJError error = diagnostics.getErrors().iterator().next();
                 if (error.getPosition() == null) {
-                    System.out.println("Error in: " + pathName + " --- error has no position information");
-                    fail();
+                    printFailureAtRight(pathName, "error has no position information");
+                    failCompact("Error has no position information");
                 }
                 if (expected.isPresent()) {
                     String expectedError = expected.get();
                     String foundError = error.getTitle();
                     if (!foundError.equalsIgnoreCase(expectedError)) {
-                        System.out.println("Error in: " + pathName + " --- expected error: " + expectedError
-                                + ", but found: " + foundError);
-                        fail();
+                        printFailureAtRight(pathName,
+                                "expected error: " + expectedError + ", but found: " + foundError);
+                        failCompact("Expected error: " + expectedError + ", but found: " + foundError);
                     }
                 } else {
-                    System.out.println("No expected error message found for: " + pathName);
+                    printFailureAtRight(pathName, "no expected error message found");
                     System.out.println("Please provide an expected error in " + (isDirectory
                             ? "a .expected file in the directory" : "the first line of the test file as a comment"));
-                    fail();
+                    failCompact("No expected error message provided for: " + pathName);
                 }
             }
         }
@@ -115,8 +124,60 @@ public void testMultiplePaths() {
         CommandLineLauncher.launch(paths);
         // Check if any of the paths that should be correct found an error
         if (diagnostics.foundError()) {
-            System.out.println("Error found in files that should be correct");
-            fail();
+            printFailureAtRight("testMultiplePaths", "error found in files that should be correct");
+            fail("Error found in files that should be correct");
+        }
+    }
+
+    private static void printFailureAtRight(String testName, String message) {
+        System.out.println(Template.formatFailureAtRight(testName, message));
+    }
+
+    private static void failCompact(String message) {
+        throw new CompactAssertionError(message);
+    }
+
+    private static String formatShouldPassErrorMessage(String pathName, LJError error) {
+        String location;
+        if (error.getPosition() != null) {
+            location = pathName + ":" + error.getPosition().lineStart() + ":" + error.getPosition().colStart();
+        } else {
+            location = pathName;
+        }
+        StringBuilder message = new StringBuilder();
+        message.append("Error found in file that should be correct: ").append(location).append("\n")
+                .append(error.getTitle()).append(error.getMessage());
+
+        String snippet = error.getSnippet();
+        if (snippet != null && !snippet.isBlank()) {
+            message.append(System.lineSeparator()).append(System.lineSeparator()).append(snippet);
+        }
+
+        return message.toString();
+    }
+
+    // Keep assertion failures concise by suppressing stack trace population.
+    private static final class CompactAssertionError extends AssertionError {
+        private final String compactMessage;
+
+        CompactAssertionError(String message) {
+            super(message);
+            this.compactMessage = message;
+        }
+
+        @Override
+        public String getMessage() {
+            return compactMessage;
+        }
+
+        @Override
+        public String toString() {
+            return compactMessage;
+        }
+
+        @Override
+        public Throwable fillInStackTrace() {
+            return this;
         }
     }
 }