Write concatenated multi-line strings as text blocks

error-prone's StringConcatToTextBlock warned at 16 concatenations of
string literals: the inputs and expected outputs in ModuleImportTest,
and the template DebugRenderer writes to output.js. They are text
blocks now, from error-prone's own fix formatted with formatDiff.

The strings are the same: both classes hold the same string constants
before and after, ./gradlew test passes, and so does
:open-java-format:test on JDK 25, which runs the ModuleImportTest cases
that JDK 21 skips.

Author: abashev

open-java-format/src/main/java/com/palantir/javaformat/java/DebugRenderer.java

@@ -61,8 +61,15 @@ static void render(
             String formatterDecisionsJson) {
 
         String javascript = String.format(
-                "window.palantirJavaFormat = {\njavaInput: %s,\nops: %s,\ndoc: %s,\njavaOutput: %s,\n"
-                        + "formatterDecisions: %s\n};\n",
+                """
+                window.palantirJavaFormat = {
+                javaInput: %s,
+                ops: %s,
+                doc: %s,
+                javaOutput: %s,
+                formatterDecisions: %s
+                };
+                """,
                 jsonEscapedString(javaInput.getText()),
                 opsJson(opsOutput),
                 new JsonDocVisitor(finalState).visit(doc),

open-java-format/src/test/java/com/palantir/javaformat/java/ModuleImportTest.java

@@ -49,17 +49,31 @@ private static void assertFormats(String input, String expected) throws Formatte
 
     @Test
     public void formatsAndFixesImports() throws FormatterException {
-        String input = "import module java.base;\n" + "class Example {}\n";
-        String expected = "import module java.base;\n" + "\n" + "class Example {}\n";
+        String input = """
+            import module java.base;
+            class Example {}
+            """;
+        String expected = """
+            import module java.base;
+
+            class Example {}
+            """;
         assertFormats(input, expected);
     }
 
     @Test
     public void fixesImportsOnlyFromTheCommandLine() throws Exception {
         // The flag combination from the #1506 report, which failed with `Expected ; after import`.
-        String input = "import module java.base;\n" + "class Example {}\n";
+        String input = """
+            import module java.base;
+            class Example {}
+            """;
         // Reordering puts a blank line after the import block; nothing else changes.
-        String expected = "import module java.base;\n" + "\n" + "class Example {}\n";
+        String expected = """
+            import module java.base;
+
+            class Example {}
+            """;
         StringWriter out = new StringWriter();
         StringWriter err = new StringWriter();
         Main main = new Main(
@@ -74,50 +88,88 @@ public void fixesImportsOnlyFromTheCommandLine() throws Exception {
 
     @Test
     public void keepsACommentBetweenModuleAndTheModuleName() throws FormatterException {
-        String input = "import module /* comment */ java.base;\n" + "class Example {}\n";
-        String expected = "import module /* comment */ java.base;\n" + "\n" + "class Example {}\n";
+        String input = """
+            import module /* comment */ java.base;
+            class Example {}
+            """;
+        String expected = """
+            import module /* comment */ java.base;
+
+            class Example {}
+            """;
         assertFormats(input, expected);
     }
 
     @Test
     public void keepsACommentBetweenThePartsOfTheModuleName() throws FormatterException {
-        String input = "import module java./* comment */base;\n" + "class Example {}\n";
+        String input = """
+            import module java./* comment */base;
+            class Example {}
+            """;
         // Reordering normalizes the whitespace around the comment and leaves it between the parts.
-        String reordered = "import module java./* comment */ base;\n" + "\n" + "class Example {}\n";
+        String reordered = """
+            import module java./* comment */ base;
+
+            class Example {}
+            """;
         assertThat(Formatter.create().fixImports(input)).isEqualTo(reordered);
         assertThat(Formatter.create().fixImports(reordered)).isEqualTo(reordered);
 
         // Formatting then breaks the line after the dot, which is where the formatter puts a comment
         // in a qualified name; that output is stable too.
-        String formatted = "import module java.\n" + "/* comment */ base;\n" + "\n" + "class Example {}\n";
+        String formatted = """
+            import module java.
+            /* comment */ base;
+
+            class Example {}
+            """;
         assertThat(Formatter.create().formatSourceAndFixImports(input)).isEqualTo(formatted);
         assertThat(Formatter.create().formatSourceAndFixImports(formatted)).isEqualTo(formatted);
     }
 
     @Test
     public void normalizesWhitespaceInsideTheModuleName() throws FormatterException {
-        String input = "import module java . base;\n" + "class Example {}\n";
-        String expected = "import module java.base;\n" + "\n" + "class Example {}\n";
+        String input = """
+            import module java . base;
+            class Example {}
+            """;
+        String expected = """
+            import module java.base;
+
+            class Example {}
+            """;
         assertFormats(input, expected);
     }
 
     @Test
     public void keepsBothCopiesOfADuplicateThatCarriesAComment() throws FormatterException {
         // Identical declarations collapse; ones that differ are both kept, so no comment is dropped.
-        String input = "import module /* explanation A */ java.base;\n"
-                + "import module /* explanation B */ java.base;\n"
-                + "class Example {}\n";
-        String expected = "import module /* explanation A */ java.base;\n"
-                + "import module /* explanation B */ java.base;\n"
-                + "\n"
-                + "class Example {}\n";
+        String input = """
+            import module /* explanation A */ java.base;
+            import module /* explanation B */ java.base;
+            class Example {}
+            """;
+        String expected = """
+            import module /* explanation A */ java.base;
+            import module /* explanation B */ java.base;
+
+            class Example {}
+            """;
         assertFormats(input, expected);
     }
 
     @Test
     public void acceptsALineBreakAfterModule() throws FormatterException {
-        String input = "import module\n" + "    java.base;\n" + "class Example {}\n";
-        String expected = "import module java.base;\n" + "\n" + "class Example {}\n";
+        String input = """
+            import module
+                java.base;
+            class Example {}
+            """;
+        String expected = """
+            import module java.base;
+
+            class Example {}
+            """;
         assertFormats(input, expected);
     }
 }