This method is used in the Google teleporter.", - " *", - " *
Yes, we have a teleporter.", - " * ", - " *", - " * @param user the person to teleport.", - " * ", - " * Users must sign deatomize-waiver ahead of time.", - " * ", - " * ", - " * @deprecated Sometimes turns the user into a goat.", - " * ", - " */", - "class Test {}", - }; - String[] expected = { - "/**", - " * Deatomizes the given user.", - " * ", - " * See deatomizer-v5 for the design doc.", - " * ", - " * To reatomize, call {@link reatomize}.", - " *", - " * ", - " *
This method is used in the Google teleporter.", - " *", - " *
Yes, we have a teleporter.", - " * ", - " *", - " * @param user the person to teleport.", - " * ", - " * Users must sign deatomize-waiver ahead of time.", - " * ", - " * ", - " * @deprecated Sometimes turns the user into a goat.", - " * ", - " */", - "class Test {}", - }; + // We replace moe by MOE to avoid triggering actual MOE rewriting. + String input = + """ + /** + * Deatomizes the given user. + * + * See deatomizer-v5 for the design doc. + * + * To reatomize, call {@link reatomize}. + * + * + *
This method is used in the Google teleporter. + * + *
Yes, we have a teleporter. + * + * + * @param user the person to teleport. + * + * Users must sign deatomize-waiver ahead of time. + * + * + * @deprecated Sometimes turns the user into a goat. + * + */ + class Test {}\ + """ + .replace("moe", "MOE"); + String expected = + """ + /** + * Deatomizes the given user. + * + * See deatomizer-v5 for the design doc. + * + * To reatomize, call {@link reatomize}. + * + * + *
This method is used in the Google teleporter. + * + *
Yes, we have a teleporter. + * + * + * @param user the person to teleport. + * + * Users must sign deatomize-waiver ahead of time. + * + * + * @deprecated Sometimes turns the user into a goat. + * + */ + class Test {} + """ + .replace("moe", "MOE"); doFormatTest(input, expected); } @Test public void moeCommentBeginOnlyInMiddleOfDoc() { // We don't really care what happens here so long as we don't explode. - String[] input = { - "/**", // - " * Foo.", - " * ", - " * Bar.", - " */", - "class Test {}", - }; - String[] expected = { - "/**", // - " * Foo.", - " * ", - " * Bar.", - " */", - "class Test {}", - }; + String input = + """ + /** + * Foo. + * + * Bar. + */ + class Test {}\ + """ + .replace("moe", "MOE"); + String expected = + """ + /** + * Foo. + * + * Bar. + */ + class Test {} + """ + .replace("moe", "MOE"); doFormatTest(input, expected); } @@ -189,70 +210,79 @@ public void moeCommentBeginOnlyInMiddleOfDoc() { public void moeCommentBeginOnlyAtEndOfDoc() { // We don't really care what happens here so long as we don't explode. // TODO(cpovirk): OK, maybe try to leave it in.... - String[] input = { - "/**", // - " * Foo.", - " * ", - " */", - "class Test {}", - }; - String[] expected = { - "/** Foo. */", // - "class Test {}", - }; + String input = + """ + /** + * Foo. + * + */ + class Test {}\ + """ + .replace("moe", "MOE"); + String expected = + """ + /** Foo. */ + class Test {} + """; doFormatTest(input, expected); } @Test public void moeCommentEndOnly() { // We don't really care what happens here so long as we don't explode. - String[] input = { - "/**", // - " * Foo.", - " * ", - " */", - "class Test {}", - }; - String[] expected = { - "/**", // - " * Foo.", - " * ", - " */", - "class Test {}", - }; + String input = + """ + /** + * Foo. + * + */ + class Test {}\ + """ + .replace("moe", "MOE"); + String expected = + """ + /** + * Foo. + * + */ + class Test {} + """ + .replace("moe", "MOE"); doFormatTest(input, expected); } @Test public void tableMostlyUntouched() { - String[] input = { - "/**", - " * Foo.", - " *", - " *
| a | b |
| A", - " * | B", - " * |
| a | b |
| A", - " * | B", - " * |
| a | b |
| A + * | B + * |
| a | b |
| A + * | B + * |
", - "* 1 2", - " */", - "class Test {}", - }; - String[] expected = { - "/**", // - " * Example:", - " *", - " *
3 ", - " *4 5 6", - "7 8", - " *
", - " * 1 2", - " */", - "class Test {}", - }; + @SuppressWarnings("MisleadingEscapedSpace") // TODO(b/496180372): remove + String input = + """ + /** + * Example: + * + *
3", - " * 4 5 6", - " * 7 8", - " *
+ * 1 2+ */ + class Test {}\ + """; + String expected = + """ + /** + * Example: + * + *
3 \s + *4 5 6 + 7 8 + *
+ * 1 2+ */ + class Test {} + """; doFormatTest(input, expected); } @Test public void preCodeExample() { // We should figure out whether we want a newline or blank line before
3 + * 4 5 6 + * 7 8 + *
or not.
- String[] input = {
- "/**",
- " * Example:",
- " *",
- " * {@code",
- " *",
- " * Abc.def(foo, 7, true); // blah}",
- " */",
- "class Test {}",
- };
- String[] expected = {
- "/**",
- " * Example:",
- " *",
- " * {@code",
- " * Abc.def(foo, 7, true); // blah",
- " * }",
- " */",
- "class Test {}",
- };
+ String input =
+ """
+ /**
+ * Example:
+ *
+ * {@code
+ *
+ * Abc.def(foo, 7, true); // blah}
+ */
+ class Test {}\
+ """;
+ String expected =
+ """
+ /**
+ * Example:
+ *
+ * {@code
+ * Abc.def(foo, 7, true); // blah
+ * }
+ */
+ class Test {}
+ """;
doFormatTest(input, expected);
}
@Test
public void preNotWrapped() {
- String[] input = {
- "/**",
- " * Example:",
- " *",
- " * ",
- " * 456789012 456789012 456789012 456789012 456789012 456789012 456789012 456789012 "
- + "456789012 45678901",
- " *
",
- " */",
- "class Test {}",
- };
- String[] expected = {
- "/**",
- " * Example:",
- " *",
- " * ",
- " * 456789012 456789012 456789012 456789012 456789012 456789012 456789012 456789012 "
- + "456789012 45678901",
- " *
",
- " */",
- "class Test {}",
- };
+ String input =
+ """
+ /**
+ * Example:
+ *
+ *
+ * 456789012 456789012 456789012 456789012 456789012 456789012 456789012 456789012 456789012 45678901
+ *
+ */
+ class Test {}\
+ """;
+ String expected =
+ """
+ /**
+ * Example:
+ *
+ *
+ * 456789012 456789012 456789012 456789012 456789012 456789012 456789012 456789012 456789012 45678901
+ *
+ */
+ class Test {}
+ """;
doFormatTest(input, expected);
}
@Test
public void javaCodeInPre() {
- String[] input = {
- "/**",
- " * Example:",
- " *",
- " *",
- " * aaaaa | a | +",
- " * \"bbbb | b | \"",
- " *
",
- " */",
- "class Test {}",
- };
- String[] expected = {
- "/**",
- " * Example:",
- " *",
- " * ",
- " * aaaaa | a | +",
- " * \"bbbb | b | \"",
- " *
",
- " */",
- "class Test {}",
- };
+ String input =
+ """
+ /**
+ * Example:
+ *
+ *
+ * aaaaa | a | +
+ * "bbbb | b | "
+ *
+ */
+ class Test {}\
+ """;
+ String expected =
+ """
+ /**
+ * Example:
+ *
+ *
+ * aaaaa | a | +
+ * "bbbb | b | "
+ *
+ */
+ class Test {}
+ """;
doFormatTest(input, expected);
}
@Test
public void joinLines() {
- String[] input = {
- "/**", //
- " * foo",
- " * bar",
- " * baz",
- " */",
- "class Test {}",
- };
- String[] expected = {
- "/** foo bar baz */", //
- "class Test {}",
- };
+ String input =
+ """
+ /**
+ * foo
+ * bar
+ * baz
+ */
+ class Test {}\
+ """;
+ String expected =
+ """
+ /** foo bar baz */
+ class Test {}
+ """;
doFormatTest(input, expected);
}
@Test
public void oneLinerIs100() {
- String[] input = {
- "/**",
- " * 567890123 567890123 567890123 567890123 567890123 567890123 567890123 567890123 "
- + "567890123 567",
- " */",
- "class Test {}",
- };
- String[] expected = {
- "/** 567890123 567890123 567890123 567890123 567890123 567890123 567890123 567890123 "
- + "567890123 567 */",
- "class Test {}",
- };
+ String input =
+ """
+ /**
+ * 567890123 567890123 567890123 567890123 567890123 567890123 567890123 567890123 567890123 567
+ */
+ class Test {}\
+ """;
+ String expected =
+ """
+ /** 567890123 567890123 567890123 567890123 567890123 567890123 567890123 567890123 567890123 567 */
+ class Test {}
+ """;
doFormatTest(input, expected);
}
@Test
public void oneLinerWouldBe101() {
- String[] input = {
- "/**",
- " * 567890123 567890123 567890123 567890123 567890123 567890123 567890123 567890123 "
- + "567890123 5678",
- " */",
- "class Test {}",
- };
- String[] expected = {
- "/**",
- " * 567890123 567890123 567890123 567890123 567890123 567890123 567890123 567890123 "
- + "567890123 5678",
- " */",
- "class Test {}",
- };
+ String input =
+ """
+ /**
+ * 567890123 567890123 567890123 567890123 567890123 567890123 567890123 567890123 567890123 5678
+ */
+ class Test {}\
+ """;
+ String expected =
+ """
+ /**
+ * 567890123 567890123 567890123 567890123 567890123 567890123 567890123 567890123 567890123 5678
+ */
+ class Test {}
+ """;
doFormatTest(input, expected);
}
@Test
public void multilineWrap() {
- String[] input = {
- "/**",
- " * 456789012 456789012 456789012 456789012 456789012 456789012 456789012 456789012 "
- + "456789012 45678901",
- " */",
- "class Test {}",
- };
- String[] expected = {
- "/**",
- " * 456789012 456789012 456789012 456789012 456789012 456789012 456789012 456789012 "
- + "456789012",
- " * 45678901",
- " */",
- "class Test {}",
- };
+ String input =
+ """
+ /**
+ * 456789012 456789012 456789012 456789012 456789012 456789012 456789012 456789012 456789012 45678901
+ */
+ class Test {}\
+ """;
+ String expected =
+ """
+ /**
+ * 456789012 456789012 456789012 456789012 456789012 456789012 456789012 456789012 456789012
+ * 45678901
+ */
+ class Test {}
+ """;
doFormatTest(input, expected);
}
@Test
public void tooLong() {
- String[] input = {
- "/**",
- " * abc",
- " *",
- " * 789012345678901234567890123456789012345678901234567890123456789012345678901234567"
- + "8901234567890123456",
- " */",
- "class Test {}",
- };
- String[] expected = {
- "/**",
- " * abc",
- " *",
- " *
789012345678901234567890123456789012345678901234567890123456789012345678901234567"
- + "8901234567890123456",
- " */",
- "class Test {}",
- };
+ String input =
+ """
+ /**
+ * abc
+ *
+ *
7890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456
+ */
+ class Test {}\
+ """;
+ String expected =
+ """
+ /**
+ * abc
+ *
+ *
7890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456
+ */
+ class Test {}
+ """;
doFormatTest(input, expected);
}
@@ -477,21 +516,21 @@ public void joinedTokens() {
* Originally, 4, , and 8901 are separate tokens. Test that we join them (and thus don't
* split them across lines).
*/
- String[] input = {
- "/**",
- " * 456789012 456789012 456789012 456789012 456789012 456789012 456789012 456789012 "
- + "456789012 48901",
- " */",
- "class Test {}",
- };
- String[] expected = {
- "/**",
- " * 456789012 456789012 456789012 456789012 456789012 456789012 456789012 456789012 "
- + "456789012",
- " * 48901",
- " */",
- "class Test {}",
- };
+ String input =
+ """
+ /**
+ * 456789012 456789012 456789012 456789012 456789012 456789012 456789012 456789012 456789012 48901
+ */
+ class Test {}\
+ """;
+ String expected =
+ """
+ /**
+ * 456789012 456789012 456789012 456789012 456789012 456789012 456789012 456789012 456789012
+ * 48901
+ */
+ class Test {}
+ """;
doFormatTest(input, expected);
}
@@ -501,362 +540,375 @@ public void joinedAtSign() {
* The last 456789012 would fit on the first line with the others. But putting it there would
* mean the next line would start with @5678901, which would then be interpreted as a tag.
*/
- String[] input = {
- "/**",
- " * 456789012 456789012 456789012 456789012 456789012 456789012 456789012 456789012 "
- + "456789012 @5678901",
- " */",
- "class Test {}",
- };
- String[] expected = {
- "/**",
- " * 456789012 456789012 456789012 456789012 456789012 456789012 456789012 456789012",
- " * 456789012 @5678901",
- " */",
- "class Test {}",
- };
+ String input =
+ """
+ /**
+ * 456789012 456789012 456789012 456789012 456789012 456789012 456789012 456789012 456789012 @5678901
+ */
+ class Test {}\
+ """;
+ String expected =
+ """
+ /**
+ * 456789012 456789012 456789012 456789012 456789012 456789012 456789012 456789012
+ * 456789012 @5678901
+ */
+ class Test {}
+ """;
doFormatTest(input, expected);
}
@Test
public void joinedMultipleAtSign() {
// This is the same as above except that it tests multiple consecutive @... tokens.
- String[] input = {
- "/**",
- " * 456789012 456789012 456789012 456789012 456789012 456789012 456789012 456789012 "
- + "@56789012 @5678901",
- " */",
- "class Test {}",
- };
- String[] expected = {
- "/**",
- " * 456789012 456789012 456789012 456789012 456789012 456789012 456789012",
- " * 456789012 @56789012 @5678901",
- " */",
- "class Test {}",
- };
+ String input =
+ """
+ /**
+ * 456789012 456789012 456789012 456789012 456789012 456789012 456789012 456789012 @56789012 @5678901
+ */
+ class Test {}\
+ """;
+ String expected =
+ """
+ /**
+ * 456789012 456789012 456789012 456789012 456789012 456789012 456789012
+ * 456789012 @56789012 @5678901
+ */
+ class Test {}
+ """;
doFormatTest(input, expected);
}
@Test
public void noAsterisk() {
- String[] input = {
- "/**", //
- " abc
def",
- " */",
- "class Test {}",
- };
- String[] expected = {
- "/**", //
- " * abc",
- " *",
- " *
def",
- " */",
- "class Test {}",
- };
+ String input =
+ """
+ /**
+ abc
def
+ */
+ class Test {}\
+ """;
+ String expected =
+ """
+ /**
+ * abc
+ *
+ *
def
+ */
+ class Test {}
+ """;
doFormatTest(input, expected);
}
@Test
public void significantAsterisks() {
- String[] input = {
- "/** *", //
- " * *",
- " */",
- "class Test {}",
- };
- String[] expected = {
- "/** * * */", //
- "class Test {}",
- };
+ String input =
+ """
+ /** *
+ * *
+ */
+ class Test {}\
+ """;
+ String expected =
+ """
+ /** * * */
+ class Test {}
+ """;
doFormatTest(input, expected);
}
@Test
public void links() {
- String[] input = {
- "/**",
- " * 456789012 456789012 456789012 456789012 456789012 456789012 456789012 456789012 "
- + "456789012 4567 foo.",
- " *",
- " * 789012 456789012 456789012 456789012 456789012 456789012 456789012 456789 "
- + "",
- " * foo.",
- " *",
- " *
789012 456789012 456789012 456789012 456789012 456789012 456789012 4567890 "
- + "",
- " * foo.",
- " *",
- " *
",
- " * foo.",
- " *",
- " *
foo ",
- " * bar.",
- " *",
- " *
foo-",
- " * bar.",
- " *",
- " *
foo",
- " * bar.",
- " *",
- " *
foo bar.",
- " */",
- "class Test {}",
- };
- String[] expected = {
- "/**",
- " * 456789012 456789012 456789012 456789012 456789012 456789012 456789012 456789012 "
- + "456789012 4567 foo.",
- " *",
- " * 789012 456789012 456789012 456789012 456789012 456789012 456789012 456789 "
- + "foo.",
- " *",
- " *
789012 456789012 456789012 456789012 456789012 456789012 456789012 4567890 "
- + "",
- " * foo.",
- " *",
- " *
foo.",
- " *",
- " *
foo bar.",
- " *",
- " *
foo-bar.",
- " *",
- /*
- * In this next case, we've removed a space from the output. Fortunately, the depot doesn't
- * appear to contain any occurrences of this pattern. And if it does, the better fix is to
- * insert a space before rather than after.
- */
- " * foobar.",
- " *",
- " *
foo bar.",
- " */",
- "class Test {}",
- };
+ String input =
+ """
+ /**
+ * 456789012 456789012 456789012 456789012 456789012 456789012 456789012 456789012 456789012 4567 foo.
+ *
+ *
789012 456789012 456789012 456789012 456789012 456789012 456789012 456789
+ * foo.
+ *
+ *
789012 456789012 456789012 456789012 456789012 456789012 456789012 4567890
+ * foo.
+ *
+ *
+ * foo.
+ *
+ *
foo
+ * bar.
+ *
+ *
foo-
+ * bar.
+ *
+ *
foo
+ * bar.
+ *
+ *
foo bar.
+ */
+ class Test {}\
+ """;
+ String expected =
+ """
+ /**
+ * 456789012 456789012 456789012 456789012 456789012 456789012 456789012 456789012 456789012 4567 foo.
+ *
+ *
789012 456789012 456789012 456789012 456789012 456789012 456789012 456789 foo.
+ *
+ *
789012 456789012 456789012 456789012 456789012 456789012 456789012 4567890
+ * foo.
+ *
+ *
foo.
+ *
+ *
foo bar.
+ *
+ *
foo-bar.
+ *
+ *
foobar.
+ *
+ *
foo bar.
+ */
+ class Test {}
+ """;
doFormatTest(input, expected);
}
@Test
public void heading() {
- String[] input = {
- "/**", //
- " * abc
def
ghi",
- " */",
- "class Test {}",
- };
- String[] expected = {
- "/**", //
- " * abc",
- " *",
- " * def
",
- " *",
- " * ghi",
- " */",
- "class Test {}",
- };
+ String input =
+ """
+ /**
+ * abcdef
ghi
+ */
+ class Test {}\
+ """;
+ String expected =
+ """
+ /**
+ * abc
+ *
+ * def
+ *
+ * ghi
+ */
+ class Test {}
+ """;
doFormatTest(input, expected);
}
@Test
public void blockquote() {
- String[] input = {
- "/**", //
- " * abcdef
ghi",
- " */",
- "class Test {}",
- };
- String[] expected = {
- "/**", //
- " * abc",
- " *",
- " * ",
- " *",
- " * def",
- " *",
- " *
",
- " *",
- " * ghi",
- " */",
- "class Test {}",
- };
+ String input =
+ """
+ /**
+ * abcdef
ghi
+ */
+ class Test {}\
+ """;
+ String expected =
+ """
+ /**
+ * abc
+ *
+ *
+ *
+ * def
+ *
+ *
+ *
+ * ghi
+ */
+ class Test {}
+ """;
doFormatTest(input, expected);
}
@Test
public void lists() {
- String[] input = {
- "/**", //
- "* hi",
- "*",
- "* ",
- "* - ",
- "*
",
- "* - a
",
- "*
",
- "* ",
- "*
",
- "*/",
- "class Test {}",
- };
- String[] expected = {
- "/**", //
- " * hi",
- " *",
- " * ",
- " * - ",
- " *
",
- " * - a",
- " *
",
- " *
",
- " */",
- "class Test {}",
- };
+ String input =
+ """
+ /**
+ * hi
+ *
+ *
+ * -
+ *
+ * - a
+ *
+ *
+ *
+ */
+ class Test {}\
+ """;
+ String expected =
+ """
+ /**
+ * hi
+ *
+ *
+ * -
+ *
+ * - a
+ *
+ *
+ */
+ class Test {}
+ """;
doFormatTest(input, expected);
}
@Test
public void lists2() {
- String[] input = {
- "/**", //
- " * Foo.",
- " *",
- " * - 1
- 1a
- 1b
more 1still more 1
- 2
",
- " */",
- "class Test {}",
- };
- String[] expected = {
- "/**", //
- " * Foo.",
- " *",
- " * ",
- " * - 1",
- " *
",
- " * - 1a",
- " *
- 1b",
- " *
",
- " * more 1",
- " * still more 1",
- " *
- 2",
- " *
",
- " */",
- "class Test {}",
- };
+ String input =
+ """
+ /**
+ * Foo.
+ *
+ * - 1
- 1a
- 1b
more 1still more 1
- 2
+ */
+ class Test {}\
+ """;
+ String expected =
+ """
+ /**
+ * Foo.
+ *
+ *
+ * - 1
+ *
+ * - 1a
+ *
- 1b
+ *
+ * more 1
+ * still more 1
+ *
- 2
+ *
+ */
+ class Test {}
+ """;
doFormatTest(input, expected);
}
@Test
public void closeInnerListStillNewline() {
- String[] input = {
- "/**", //
- " * Foo.",
- " *",
- " * - a
b
",
- " */",
- "class Test {}",
- };
- String[] expected = {
- "/**", //
- " * Foo.",
- " *",
- " * ",
- " * - ",
- " *
",
- " * - a",
- " *
",
- " * b",
- " *
",
- " */",
- "class Test {}",
- };
+ String input =
+ """
+ /**
+ * Foo.
+ *
+ * - a
b
+ */
+ class Test {}\
+ """;
+ String expected =
+ """
+ /**
+ * Foo.
+ *
+ *
+ * -
+ *
+ * - a
+ *
+ * b
+ *
+ */
+ class Test {}
+ """;
doFormatTest(input, expected);
}
@Test
public void listItemWrap() {
- String[] input = {
- "/**", //
- " * Foo.",
- " *",
- " * - 234567890 234567890 234567890 234567890 234567890 234567890 234567890 234567890"
- + " 234567890 234567890
",
- " */",
- "class Test {}",
- };
- String[] expected = {
- "/**", //
- " * Foo.",
- " *",
- " * ",
- " * - 234567890 234567890 234567890 234567890 234567890 234567890 234567890 234567890"
- + " 234567890",
- " * 234567890",
- " *
",
- " */",
- "class Test {}",
- };
+ String input =
+ """
+ /**
+ * Foo.
+ *
+ * - 234567890 234567890 234567890 234567890 234567890 234567890 234567890 234567890 234567890 234567890
+ */
+ class Test {}\
+ """;
+ String expected =
+ """
+ /**
+ * Foo.
+ *
+ *
+ * - 234567890 234567890 234567890 234567890 234567890 234567890 234567890 234567890 234567890
+ * 234567890
+ *
+ */
+ class Test {}
+ """;
doFormatTest(input, expected);
}
@Test
public void unclosedList() {
- String[] input = {
- "/**", //
- " * Foo.",
- " *",
- " * - 1",
- " * @return blah",
- " */",
- "class Test {}",
- };
- String[] expected = {
- "/**", //
- " * Foo.",
- " *",
- " *
",
- " * - 1",
- " *",
- " * @return blah",
- " */",
- "class Test {}",
- };
+ String input =
+ """
+ /**
+ * Foo.
+ *
+ *
- 1
+ * @return blah
+ */
+ class Test {}\
+ """;
+ String expected =
+ """
+ /**
+ * Foo.
+ *
+ *
+ * - 1
+ *
+ * @return blah
+ */
+ class Test {}
+ """;
doFormatTest(input, expected);
}
@Test
public void br() {
- String[] input = {
- "/**", //
- " * abc
def",
- " */",
- "class Test {}",
- };
- String[] expected = {
- "/**", //
- " * abc
",
- " * def",
- " */",
- "class Test {}",
- };
+ String input =
+ """
+ /**
+ * abc
def
+ */
+ class Test {}\
+ """;
+ String expected =
+ """
+ /**
+ * abc
+ * def
+ */
+ class Test {}
+ """;
doFormatTest(input, expected);
}
@Test
public void brSpaceBug() {
// TODO(b/28983091): Remove the space before
here.
- String[] input = {
- "/**", //
- " * abc
def",
- " */",
- "class Test {}",
- };
- String[] expected = {
- "/**", //
- " * abc
",
- " * def",
- " */",
- "class Test {}",
- };
+ String input =
+ """
+ /**
+ * abc
def
+ */
+ class Test {}\
+ """;
+ String expected =
+ """
+ /**
+ * abc
+ * def
+ */
+ class Test {}
+ """;
doFormatTest(input, expected);
}
@@ -866,19 +918,22 @@ public void brAtSignBug() {
* This is a bug -- more of a "spec" bug than an implementation bug, and hard to fix.
* Fortunately, some very quick searching didn't turn up any instances in the Google codebase.
*/
- String[] input = {
- "/**", //
- " * abc
@foo ",
- " */",
- "class Test {}",
- };
- String[] expected = {
- "/**", //
- " * abc
",
- " * @foo", // interpreted as a block tag now!
- " */",
- "class Test {}",
- };
+ @SuppressWarnings("MisleadingEscapedSpace") // TODO(b/496180372): remove
+ String input =
+ """
+ /**
+ * abc
@foo\s
+ */
+ class Test {}\
+ """;
+ String expected =
+ """
+ /**
+ * abc
+ * @foo
+ */
+ class Test {}
+ """;
doFormatTest(input, expected);
}
@@ -889,292 +944,314 @@ public void unicodeCharacterCountArguableBug() {
* perhaps for all characters to be treated based on their width in monospace fonts). But
* currently we just count chars.
*/
- String[] input = {
- "/**",
- " * 456789π12 456789π12 456789π12 456789π12 456789π12 456789π12 456789π12 456789π12 "
- + "456789π12 456789π",
- " */",
- "class Test {}",
- };
- String[] expected = {
- "/**",
- " * 456789π12 456789π12 456789π12 456789π12 456789π12 456789π12 456789π12 456789π12",
- " * 456789π12 456789π",
- " */",
- "class Test {}",
- };
+ String input =
+ """
+ /**
+ * 456789π12 456789π12 456789π12 456789π12 456789π12 456789π12 456789π12 456789π12 456789π12 456789π
+ */
+ class Test {}\
+ """;
+ String expected =
+ """
+ /**
+ * 456789π12 456789π12 456789π12 456789π12 456789π12 456789π12 456789π12 456789π12
+ * 456789π12 456789π
+ */
+ class Test {}
+ """;
doFormatTest(input, expected);
}
@Test
public void blankLinesAroundSnippetAndNoMangling() {
- String[] input = {
- "/**", //
- " * hello world",
- " * {@snippet :",
- " * public class Foo {",
- " * private String s;",
- " * }",
- " * }",
- " * hello again",
- " */",
- "class Test {}",
- };
- String[] expected = {
- "/**", //
- " * hello world",
- " *",
- " * {@snippet :",
- " * public class Foo {",
- " * private String s;",
- " * }",
- " * }",
- " *",
- " * hello again",
- " */",
- "class Test {}",
- };
+ String input =
+ """
+ /**
+ * hello world
+ * {@snippet :
+ * public class Foo {
+ * private String s;
+ * }
+ * }
+ * hello again
+ */
+ class Test {}\
+ """;
+ String expected =
+ """
+ /**
+ * hello world
+ *
+ * {@snippet :
+ * public class Foo {
+ * private String s;
+ * }
+ * }
+ *
+ * hello again
+ */
+ class Test {}
+ """;
doFormatTest(input, expected);
}
@Test
public void notASnippetUnlessOuterTag() {
- String[] input = {
- "/** I would like to tell you about the {@code {@snippet ...}} tag. */", "class Test {}",
- };
- String[] expected = {
- "/** I would like to tell you about the {@code {@snippet ...}} tag. */", "class Test {}",
- };
+ String input =
+ """
+ /** I would like to tell you about the {@code {@snippet ...}} tag. */
+ class Test {}\
+ """;
+ String expected =
+ """
+ /** I would like to tell you about the {@code {@snippet ...}} tag. */
+ class Test {}
+ """;
doFormatTest(input, expected);
}
@Test
public void blankLineBeforeParams() {
- String[] input = {
- "/**", //
- " * hello world",
- " * @param this is a param",
- " */",
- "class Test {}",
- };
- String[] expected = {
- "/**", //
- " * hello world",
- " *",
- " * @param this is a param",
- " */",
- "class Test {}",
- };
+ String input =
+ """
+ /**
+ * hello world
+ * @param this is a param
+ */
+ class Test {}\
+ """;
+ String expected =
+ """
+ /**
+ * hello world
+ *
+ * @param this is a param
+ */
+ class Test {}
+ """;
doFormatTest(input, expected);
}
@Test
public void onlyParams() {
- String[] input = {
- "/**", //
- " *",
- " *",
- " * @param this is a param",
- " */",
- "class Test {}",
- };
- String[] expected = {
- "/**", //
- " * @param this is a param",
- " */",
- "class Test {}",
- };
+ String input =
+ """
+ /**
+ *
+ *
+ * @param this is a param
+ */
+ class Test {}\
+ """;
+ String expected =
+ """
+ /**
+ * @param this is a param
+ */
+ class Test {}
+ """;
doFormatTest(input, expected);
}
@Test
public void paramsContinuationIndented() {
- String[] input = {
- "/**", //
- " * hello world",
- " *",
- " * @param foo 567890123 567890123 567890123 567890123 567890123 567890123 567890123"
- + " 567890123 567890123",
- " * @param bar another",
- " */",
- "class Test {}",
- };
- String[] expected = {
- "/**", //
- " * hello world",
- " *",
- " * @param foo 567890123 567890123 567890123 567890123 567890123 567890123 567890123"
- + " 567890123",
- " * 567890123",
- " * @param bar another",
- " */",
- "class Test {}",
- };
+ String input =
+ """
+ /**
+ * hello world
+ *
+ * @param foo 567890123 567890123 567890123 567890123 567890123 567890123 567890123 567890123 567890123
+ * @param bar another
+ */
+ class Test {}\
+ """;
+ String expected =
+ """
+ /**
+ * hello world
+ *
+ * @param foo 567890123 567890123 567890123 567890123 567890123 567890123 567890123 567890123
+ * 567890123
+ * @param bar another
+ */
+ class Test {}
+ """;
doFormatTest(input, expected);
}
@Test
public void paramsOtherIndents() {
- String[] input = {
- "/**", //
- " * hello world",
- " *",
- " * @param foo ab
- a
- x
",
- " * @param bar another",
- " */",
- "class Test {}",
- };
- String[] expected = {
- "/**", //
- " * hello world",
- " *",
- " * @param foo a",
- " * b",
- " *
",
- " * - a",
- " *
",
- " * - x",
- " *
",
- " *
",
- " *", // TODO(cpovirk): Ideally we would probably eliminate this.
- " * @param bar another",
- " */",
- "class Test {}",
- };
+ String input =
+ """
+ /**
+ * hello world
+ *
+ * @param foo ab
- a
- x
+ * @param bar another
+ */
+ class Test {}\
+ """;
+ // TODO(cpovirk): Ideally we would probably eliminate the blank line before the second @param.
+ String expected =
+ """
+ /**
+ * hello world
+ *
+ * @param foo a
+ * b
+ *
+ * - a
+ *
+ * - x
+ *
+ *
+ *
+ * @param bar another
+ */
+ class Test {}
+ """;
doFormatTest(input, expected);
}
@Test
public void paragraphTag() {
- String[] input = {
- "class Test {",
- " /**",
- " * helloworld",
- " */",
- " void f() {}",
- "",
- " /**",
- " * hello",
- " *
",
- " * world",
- " */",
- " void f() {}",
- "}",
- };
- String[] expected = {
- "class Test {",
- " /**",
- " * hello",
- " *",
- " *
world",
- " */",
- " void f() {}",
- "",
- " /**",
- " * hello",
- " *",
- " *
world",
- " */",
- " void f() {}",
- "}",
- };
+ String input =
+ """
+ class Test {
+ /**
+ * hello
world
+ */
+ void f() {}
+
+ /**
+ * hello
+ *
+ * world
+ */
+ void f() {}
+ }\
+ """;
+ String expected =
+ """
+ class Test {
+ /**
+ * hello
+ *
+ *
world
+ */
+ void f() {}
+
+ /**
+ * hello
+ *
+ *
world
+ */
+ void f() {}
+ }
+ """;
doFormatTest(input, expected);
}
@Test
public void xhtmlParagraphTag() {
- String[] input = {
- "class Test {", //
- " /**",
- " * hello
world",
- " */",
- " void f() {}",
- "",
- "}",
- };
- String[] expected = {
- "class Test {", //
- " /**",
- " * hello",
- " *",
- " * world",
- " */",
- " void f() {}",
- "}",
- };
+ String input =
+ """
+ class Test {
+ /**
+ * hello
world
+ */
+ void f() {}
+
+ }\
+ """;
+ String expected =
+ """
+ class Test {
+ /**
+ * hello
+ *
+ * world
+ */
+ void f() {}
+ }
+ """;
doFormatTest(input, expected);
}
@Test
public void removeInitialParagraphTag() {
- String[] input = {
- "/**", //
- " *
hello
world",
- " */",
- "class Test {}",
- };
- String[] expected = {
- "/**", //
- " * hello",
- " *",
- " *
world",
- " */",
- "class Test {}",
- };
+ String input =
+ """
+ /**
+ *
hello
world
+ */
+ class Test {}\
+ """;
+ String expected =
+ """
+ /**
+ * hello
+ *
+ *
world
+ */
+ class Test {}
+ """;
doFormatTest(input, expected);
}
@Test
public void inferParagraphTags() {
- String[] input = {
- "/**",
- " *",
- " *",
- " * foo",
- " * foo",
- " *",
- " *",
- " * foo",
- " *",
- " * bar",
- " *",
- " *
",
- " *",
- " * baz",
- " *",
- " *
",
- " *",
- " * ",
- " * - foo",
- " *",
- " * bar",
- " *
",
- " *",
- " *",
- " */",
- "class Test {}",
- };
- String[] expected = {
- "/**",
- " * foo foo",
- " *",
- " * foo",
- " *",
- " *
bar",
- " *",
- " *
",
- " *",
- " * baz",
- " *",
- " *
",
- " *",
- " * ",
- " * - foo",
- " *
bar",
- " *
",
- " */",
- "class Test {}",
- };
+ String input =
+ """
+ /**
+ *
+ *
+ * foo
+ * foo
+ *
+ *
+ * foo
+ *
+ * bar
+ *
+ *
+ *
+ * baz
+ *
+ *
+ *
+ *
+ * - foo
+ *
+ * bar
+ *
+ *
+ *
+ */
+ class Test {}\
+ """;
+ String expected =
+ """
+ /**
+ * foo foo
+ *
+ * foo
+ *
+ *
bar
+ *
+ *
+ *
+ * baz
+ *
+ *
+ *
+ *
+ * - foo
+ *
bar
+ *
+ */
+ class Test {}
+ """;
doFormatTest(input, expected);
}
@@ -1208,45 +1285,51 @@ public void listItemSpaces() throws Exception {
@Test
public void htmlTagsInCode() {
- String[] input = {
- "/** abc {@code {}
-
} def */", //
- "class Test {}",
- };
- String[] expected = {
- "/** abc {@code {}
-
} def */", //
- "class Test {}",
- };
+ String input =
+ """
+ /** abc {@code {}
-
} def */
+ class Test {}\
+ """;
+ String expected =
+ """
+ /** abc {@code {}
-
} def */
+ class Test {}
+ """;
doFormatTest(input, expected);
}
@Test
public void loneBraceDoesNotStartInlineTag() {
- String[] input = {
- "/** { } */", //
- "class Test {}",
- };
- String[] expected = {
- "/**", //
- " * {",
- " *",
- " *
}",
- " */",
- "class Test {}",
- };
+ String input =
+ """
+ /** {
} */
+ class Test {}\
+ """;
+ String expected =
+ """
+ /**
+ * {
+ *
+ *
}
+ */
+ class Test {}
+ """;
doFormatTest(input, expected);
}
@Test
public void unicodeEscapesNotReplaced() {
// Test that we don't replace them with their interpretations.
- String[] input = {
- "/** foo \\u0000 bar \\u6c34 baz */", //
- "class Test {}",
- };
- String[] expected = {
- "/** foo \\u0000 bar \\u6c34 baz */", //
- "class Test {}",
- };
+ String input =
+ """
+ /** foo \\u0000 bar \\u6c34 baz */
+ class Test {}\
+ """;
+ String expected =
+ """
+ /** foo \\u0000 bar \\u6c34 baz */
+ class Test {}
+ """;
doFormatTest(input, expected);
}
@@ -1257,45 +1340,51 @@ public void unicodeEscapesNotInterpretedBug() {
* @, *, and other special chars. We don't recognize that, though, so we don't put what is
* effectively "
" on a new line.
*/
- String[] input = {
- "/** a\\u003Cp>b */", //
- "class Test {}",
- };
- String[] expected = {
- "/** a\\u003Cp>b */", //
- "class Test {}",
- };
+ String input =
+ """
+ /** a\\u003Cp>b */
+ class Test {}\
+ """;
+ String expected =
+ """
+ /** a\\u003Cp>b */
+ class Test {}
+ """;
doFormatTest(input, expected);
}
@Test
public void trailingLink() {
// Eclipse's parser seems to want to discard the line break after {@link}. Test that we see it.
- String[] input = {
- "/**", //
- " * abc {@link Foo}",
- " * def",
- " */",
- "class Test {}",
- };
- String[] expected = {
- "/** abc {@link Foo} def */", //
- "class Test {}",
- };
+ String input =
+ """
+ /**
+ * abc {@link Foo}
+ * def
+ */
+ class Test {}\
+ """;
+ String expected =
+ """
+ /** abc {@link Foo} def */
+ class Test {}
+ """;
doFormatTest(input, expected);
}
@Test
public void codeInCode() {
// Eclipse's parser seems to get confused at the second {@code}. Test that we handle it.
- String[] input = {
- "/** abc {@code {@code foo}} def */", //
- "class Test {}",
- };
- String[] expected = {
- "/** abc {@code {@code foo}} def */", //
- "class Test {}",
- };
+ String input =
+ """
+ /** abc {@code {@code foo}} def */
+ class Test {}\
+ """;
+ String expected =
+ """
+ /** abc {@code {@code foo}} def */
+ class Test {}
+ """;
doFormatTest(input, expected);
}
@@ -1305,124 +1394,130 @@ public void quotedTextSplitAcrossLinks() {
* This demonstrates one of multiple reasons that we can't hand the Javadoc *content* to
* Eclipse's lexer as if it were Java code.
*/
- String[] input = {
- "/**", //
- " * abc \"foo",
- " * bar baz\" def",
- " */",
- "class Test {}",
- };
- String[] expected = {
- "/** abc \"foo bar baz\" def */", //
- "class Test {}",
- };
+ String input =
+ """
+ /**
+ * abc "foo
+ * bar baz" def
+ */
+ class Test {}\
+ """;
+ String expected =
+ """
+ /** abc "foo bar baz" def */
+ class Test {}
+ """;
doFormatTest(input, expected);
}
@Test
public void standardizeTags() {
- String[] input = {
- "/**",
- " * foo",
- " *",
- " *
bar",
- " *",
- " *
baz
",
- " * baz",
- " */",
- "class Test {}",
- };
- String[] expected = {
- "/**",
- " * foo",
- " *",
- " *
bar",
- " *",
- " *
baz
",
- " * baz",
- " */",
- "class Test {}",
- };
+ String input =
+ """
+ /**
+ * foo
+ *
+ *
bar
+ *
+ *
baz
+ * baz
+ */
+ class Test {}\
+ """;
+ String expected =
+ """
+ /**
+ * foo
+ *
+ *
bar
+ *
+ *
baz
+ * baz
+ */
+ class Test {}
+ """;
doFormatTest(input, expected);
}
@Test
public void removeCloseTags() {
- String[] input = {
- "/**", //
- " * foo
",
- " *",
- " * bar
",
- " */",
- "class Test {}",
- };
- String[] expected = {
- "/**", //
- " * foo",
- " *",
- " * bar",
- " */",
- "class Test {}",
- };
+ String input =
+ """
+ /**
+ * foo
+ *
+ * bar
+ */
+ class Test {}\
+ """;
+ String expected =
+ """
+ /**
+ * foo
+ *
+ * bar
+ */
+ class Test {}
+ """;
doFormatTest(input, expected);
}
@Test
public void javadocFullSentences() {
- String[] input = {
- "/** In our application, bats are often found hanging from the ceiling, especially on"
- + " Wednesdays. Sometimes sick bats have issues where their claws do not close entirely."
- + " This class provides a nice, grippable surface for them to cling to. */",
- "class Grippable {}",
- };
- String[] expected = {
- "/**",
- " * In our application, bats are often found hanging from the ceiling, especially on"
- + " Wednesdays.",
- " * Sometimes sick bats have issues where their claws do not close entirely. This class"
- + " provides a",
- " * nice, grippable surface for them to cling to.",
- " */",
- "class Grippable {}",
- };
+ String input =
+ """
+ /** In our application, bats are often found hanging from the ceiling, especially on Wednesdays. Sometimes sick bats have issues where their claws do not close entirely. This class provides a nice, grippable surface for them to cling to. */
+ class Grippable {}\
+ """;
+ String expected =
+ """
+ /**
+ * In our application, bats are often found hanging from the ceiling, especially on Wednesdays.
+ * Sometimes sick bats have issues where their claws do not close entirely. This class provides a
+ * nice, grippable surface for them to cling to.
+ */
+ class Grippable {}
+ """;
doFormatTest(input, expected);
}
@Test
public void javadocSentenceFragment() {
- String[] input = {
- "/** Provides a comfy, grippable surface for sick bats with claw-closing problems, which are"
- + " sometimes found hanging from the ceiling on Wednesdays. */",
- "class Grippable {}",
- };
- String[] expected = {
- "/**",
- " * Provides a comfy, grippable surface for sick bats with claw-closing problems, which are"
- + " sometimes",
- " * found hanging from the ceiling on Wednesdays.",
- " */",
- "class Grippable {}",
- };
+ String input =
+ """
+ /** Provides a comfy, grippable surface for sick bats with claw-closing problems, which are sometimes found hanging from the ceiling on Wednesdays. */
+ class Grippable {}\
+ """;
+ String expected =
+ """
+ /**
+ * Provides a comfy, grippable surface for sick bats with claw-closing problems, which are sometimes
+ * found hanging from the ceiling on Wednesdays.
+ */
+ class Grippable {}
+ """;
doFormatTest(input, expected);
}
@Test
public void javadocCanEndAnywhere() {
- String[] input = {
- "/** foo world", " */", "class Test {}",
- };
- for (String separator : Arrays.asList("\r", "\r\n")) {
- String actual = formatter.formatSource(Joiner.on(separator).join(input));
- assertThat(actual).isEqualTo(Joiner.on(separator).join(input) + separator);
+ String input =
+ """
+ /**
+ * hello
+ *
+ * world
+ */
+ class Test {}\
+ """;
+ for (String separator : new String[] {"\r", "\r\n"}) {
+ String actual = formatter.formatSource(input.replace("\n", separator));
+ assertThat(actual).isEqualTo(input.replace("\n", separator) + separator);
}
}
@Test
public void u2028LineSeparator() {
- String[] input = {
- "public class Foo {",
- " /**\u2028",
- " * Set and enable something.",
- " */",
- " public void setSomething() {}",
- "}",
- };
- String[] expected = {
- "public class Foo {",
- " /**",
- " * \u2028 Set and enable something.",
- " */",
- " public void setSomething() {}",
- "}",
- };
+ // The subterfuge with β€ here is needed because of https://bugs.openjdk.org/browse/JDK-8380912.
+ String input =
+ """
+ public class Foo {
+ /**β€
+ * Set and enable something.
+ */
+ public void setSomething() {}
+ }\
+ """
+ .replace("β€", "\u2028");
+ String expected =
+ """
+ public class Foo {
+ /**
+ * β€ Set and enable something.
+ */
+ public void setSomething() {}
+ }
+ """
+ .replace("β€", "\u2028");
doFormatTest(input, expected);
}
@Test
public void missingSummaryFragment() {
- String[] input = {
- "public class Foo {",
- " /**",
- " * @return something.",
- " */",
- " public void setSomething() {}",
- "",
- " /**",
- " * @hide",
- " */",
- " public void setSomething() {}",
- "}",
- };
- String[] expected = {
- "public class Foo {",
- " /**",
- " * @return something.",
- " */",
- " public void setSomething() {}",
- "",
- " /** @hide */",
- " public void setSomething() {}",
- "}",
- };
+ String input =
+ """
+ public class Foo {
+ /**
+ * @return something.
+ */
+ public void setSomething() {}
+
+ /**
+ * @hide
+ */
+ public void setSomething() {}
+ }\
+ """;
+ String expected =
+ """
+ public class Foo {
+ /**
+ * @return something.
+ */
+ public void setSomething() {}
+
+ /** @hide */
+ public void setSomething() {}
+ }
+ """;
doFormatTest(input, expected);
}
@Test
public void simpleMarkdown() {
- String[] input = {
- "package com.example;",
- "",
- "/// # Heading",
- "///",
- "/// A very long line of text, long enough that it will need to be wrapped to fit within the"
- + " maximum line length.",
- "class Test {",
- " /// Another very long line of text, also long enough that it will need to be wrapped to"
- + " fit within the maximum line length.",
- " /// @param a generic type",
- " T method() {",
- " return null;",
- " }",
- "}",
- };
+ String input =
+ """
+ package com.example;
+
+ /// # Heading
+ ///
+ /// A very long line of text, long enough that it will need to be wrapped to fit within the maximum line length.
+ class Test {
+ /// Another very long line of text, also long enough that it will need to be wrapped to fit within the maximum line length.
+ /// @param a generic type
+ T method() {
+ return null;
+ }
+ }\
+ """;
// TODO(emcmanus): Actually format the javadoc. For now, we just leave `///` lines alone, unlike
// `//` lines which get wrapped.
- String[] expected = {
- "package com.example;",
- "",
- "/// # Heading",
- "///",
- "/// A very long line of text, long enough that it will need to be wrapped to fit within the"
- + " maximum line length.",
- "class Test {",
- " /// Another very long line of text, also long enough that it will need to be wrapped to"
- + " fit within the maximum line length.",
- " /// @param a generic type",
- " T method() {",
- " return null;",
- " }",
- "}",
- };
+ String expected =
+ """
+ package com.example;
+
+ /// # Heading
+ ///
+ /// A very long line of text, long enough that it will need to be wrapped to fit within the maximum line length.
+ class Test {
+ /// Another very long line of text, also long enough that it will need to be wrapped to fit within the maximum line length.
+ /// @param a generic type
+ T method() {
+ return null;
+ }
+ }
+ """;
doFormatTest(input, expected);
}
}
diff --git a/core/src/test/java/com/google/googlejavaformat/java/MainTest.java b/core/src/test/java/com/google/googlejavaformat/java/MainTest.java
index 2d9364082..56582848a 100644
--- a/core/src/test/java/com/google/googlejavaformat/java/MainTest.java
+++ b/core/src/test/java/com/google/googlejavaformat/java/MainTest.java
@@ -20,7 +20,6 @@
import static com.google.common.truth.Truth.assertWithMessage;
import static java.nio.charset.StandardCharsets.UTF_8;
-import com.google.common.base.Joiner;
import com.google.common.collect.ImmutableList;
import com.google.common.io.ByteStreams;
import java.io.BufferedWriter;
@@ -49,9 +48,6 @@ public class MainTest {
@Rule public TemporaryFolder testFolder = new TemporaryFolder();
- // PrintWriter instances used below are hard-coded to use system-default line separator.
- private final Joiner joiner = Joiner.on(System.lineSeparator());
-
private static final ImmutableList ADD_EXPORTS =
ImmutableList.of(
"--add-exports=jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED",
@@ -137,39 +133,38 @@ public void testMain() throws Exception {
// end to end javadoc formatting test
@Test
public void javadoc() throws Exception {
- String[] input = {
- "/**",
- " * graph",
- " *",
- " * graph",
- " *",
- " * @param foo lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do"
- + " eiusmod tempor incididunt ut labore et dolore magna aliqua",
- " */",
- "class Test {",
- " /**",
- " * creates entropy",
- " */",
- " public static void main(String... args) {}",
- "}",
- };
- String[] expected = {
- "/**",
- " * graph",
- " *",
- " * graph",
- " *",
- " * @param foo lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do"
- + " eiusmod tempor",
- " * incididunt ut labore et dolore magna aliqua",
- " */",
- "class Test {",
- " /** creates entropy */",
- " public static void main(String... args) {}",
- "}",
- "",
- };
- InputStream in = new ByteArrayInputStream(joiner.join(input).getBytes(UTF_8));
+ String input =
+"""
+/**
+ * graph
+ *
+ * graph
+ *
+ * @param foo lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua
+ */
+class Test {
+ /**
+ * creates entropy
+ */
+ public static void main(String... args) {}
+}\
+""";
+ String expected =
+"""
+/**
+ * graph
+ *
+ *
graph
+ *
+ * @param foo lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor
+ * incididunt ut labore et dolore magna aliqua
+ */
+class Test {
+ /** creates entropy */
+ public static void main(String... args) {}
+}
+""";
+ InputStream in = new ByteArrayInputStream(input.getBytes(UTF_8));
StringWriter out = new StringWriter();
Main main =
new Main(
@@ -177,35 +172,37 @@ public void javadoc() throws Exception {
new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.err, UTF_8)), true),
in);
assertThat(main.format("-")).isEqualTo(0);
- assertThat(out.toString()).isEqualTo(joiner.join(expected));
+ assertThat(out.toString()).isEqualTo(expected);
}
// end to end import fixing test
@Test
public void imports() throws Exception {
- String[] input = {
- "import java.util.LinkedList;",
- "import java.util.List;",
- "import java.util.ArrayList;",
- "class Test {",
- " /**",
- " * May be an {@link ArrayList}.",
- " */",
- " public static List names;",
- "}",
- };
- String[] expected = {
- "import java.util.ArrayList;",
- "import java.util.List;",
- "",
- "class Test {",
- " /**",
- " * May be an {@link ArrayList}.",
- " */",
- " public static List names;",
- "}",
- };
- InputStream in = new ByteArrayInputStream(joiner.join(input).getBytes(UTF_8));
+ String input =
+ """
+ import java.util.LinkedList;
+ import java.util.List;
+ import java.util.ArrayList;
+ class Test {
+ /**
+ * May be an {@link ArrayList}.
+ */
+ public static List names;
+ }\
+ """;
+ String expected =
+ """
+ import java.util.ArrayList;
+ import java.util.List;
+
+ class Test {
+ /**
+ * May be an {@link ArrayList}.
+ */
+ public static List names;
+ }\
+ """;
+ InputStream in = new ByteArrayInputStream(input.getBytes(UTF_8));
StringWriter out = new StringWriter();
Main main =
new Main(
@@ -213,40 +210,42 @@ public void imports() throws Exception {
new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.err, UTF_8)), true),
in);
assertThat(main.format("-", "--fix-imports-only")).isEqualTo(0);
- assertThat(out.toString()).isEqualTo(joiner.join(expected));
+ assertThat(out.toString()).isEqualTo(expected);
}
@Test
public void optimizeImportsDoesNotLeaveEmptyLines() throws Exception {
- String[] input = {
- "package abc;",
- "",
- "import java.util.LinkedList;",
- "import java.util.List;",
- "import java.util.ArrayList;",
- "",
- "import static java.nio.charset.StandardCharsets.UTF_8;",
- "",
- "import java.util.EnumSet;",
- "",
- "class Test ",
- "extends ArrayList {",
- "}"
- };
- String[] expected = {
- "package abc;", //
- "",
- "import java.util.ArrayList;",
- "",
- "class Test extends ArrayList {}",
- ""
- };
+ @SuppressWarnings("MisleadingEscapedSpace") // TODO(b/496180372): remove
+ String input =
+ """
+ package abc;
+
+ import java.util.LinkedList;
+ import java.util.List;
+ import java.util.ArrayList;
+
+ import static java.nio.charset.StandardCharsets.UTF_8;
+
+ import java.util.EnumSet;
+
+ class Test\s
+ extends ArrayList {
+ }\
+ """;
+ String expected =
+ """
+ package abc;
+
+ import java.util.ArrayList;
+
+ class Test extends ArrayList {}
+ """;
// pre-check expectation with local formatter instance
- String optimized = new Formatter().formatSourceAndFixImports(joiner.join(input));
- assertThat(optimized).isEqualTo(joiner.join(expected));
+ String optimized = new Formatter().formatSourceAndFixImports(input);
+ assertThat(optimized).isEqualTo(expected);
- InputStream in = new ByteArrayInputStream(joiner.join(input).getBytes(UTF_8));
+ InputStream in = new ByteArrayInputStream(input.getBytes(UTF_8));
StringWriter out = new StringWriter();
Main main =
new Main(
@@ -254,36 +253,39 @@ public void optimizeImportsDoesNotLeaveEmptyLines() throws Exception {
new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.err, UTF_8)), true),
in);
assertThat(main.format("-")).isEqualTo(0);
- assertThat(out.toString()).isEqualTo(joiner.join(expected));
+ assertThat(out.toString()).isEqualTo(expected);
}
// test that -lines handling works with import removal
@Test
public void importRemovalLines() throws Exception {
- String[] input = {
- "import java.util.ArrayList;",
- "import java.util.List;",
- "class Test {",
- "ArrayList a = new ArrayList<>();",
- "ArrayList b = new ArrayList<>();",
- "}",
- };
- String[] expected = {
- "import java.util.ArrayList;",
- "",
- "class Test {",
- " ArrayList a = new ArrayList<>();",
- "ArrayList b = new ArrayList<>();",
- "}",
- };
+ String input =
+ """
+ import java.util.ArrayList;
+ import java.util.List;
+ class Test {
+ ArrayList a = new ArrayList<>();
+ ArrayList b = new ArrayList<>();
+ }\
+ """;
+ String expected =
+ """
+ import java.util.ArrayList;
+
+ class Test {
+ ArrayList a = new ArrayList<>();
+ ArrayList b = new ArrayList<>();
+ }\
+ """;
StringWriter out = new StringWriter();
Main main =
new Main(
new PrintWriter(out, true),
new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.err, UTF_8)), true),
- new ByteArrayInputStream(joiner.join(input).getBytes(UTF_8)));
+ new ByteArrayInputStream(input.getBytes(UTF_8)));
assertThat(main.format("-", "-lines", "4")).isEqualTo(0);
- assertThat(out.toString()).isEqualTo(joiner.join(expected));
+ assertThat(out.toString()).isEqualTo(expected);
+ // Line 4 gets rewritten because of `-lines 4`, but line 5 does not.
}
// test that errors are reported on the right line when imports are removed
@@ -293,19 +295,20 @@ public void importRemoveErrorParseError() throws Exception {
try {
Locale.setDefault(Locale.ROOT);
- String[] input = {
- "import java.util.ArrayList;", //
- "import java.util.List;",
- "class Test {",
- "}}",
- };
+ String input =
+ """
+ import java.util.ArrayList;
+ import java.util.List;
+ class Test {
+ }}\
+ """;
StringWriter out = new StringWriter();
StringWriter err = new StringWriter();
Main main =
new Main(
new PrintWriter(out, true),
new PrintWriter(err, true),
- new ByteArrayInputStream(joiner.join(input).getBytes(UTF_8)));
+ new ByteArrayInputStream(input.getBytes(UTF_8)));
assertThat(main.format("-")).isEqualTo(1);
assertThat(err.toString()).contains(":4:2: error: class, interface");
@@ -316,24 +319,24 @@ public void importRemoveErrorParseError() throws Exception {
@Test
public void packageInfo() throws Exception {
- String[] input = {
- "@CheckReturnValue",
- "@ParametersAreNonnullByDefault",
- "package com.google.common.labs.base;",
- "",
- "import com.google.errorprone.annotations.CheckReturnValue;",
- "import javax.annotation.ParametersAreNonnullByDefault;",
- "",
- };
+ String input =
+ """
+ @CheckReturnValue
+ @ParametersAreNonnullByDefault
+ package com.google.common.labs.base;
+
+ import com.google.errorprone.annotations.CheckReturnValue;
+ import javax.annotation.ParametersAreNonnullByDefault;
+ """;
StringWriter out = new StringWriter();
StringWriter err = new StringWriter();
Main main =
new Main(
new PrintWriter(out, true),
new PrintWriter(err, true),
- new ByteArrayInputStream(joiner.join(input).getBytes(UTF_8)));
+ new ByteArrayInputStream(input.getBytes(UTF_8)));
assertThat(main.format("-")).isEqualTo(0);
- assertThat(out.toString()).isEqualTo(joiner.join(input));
+ assertThat(out.toString()).isEqualTo(input);
}
@Test
@@ -497,55 +500,56 @@ public void exitIfChangedFiles() throws Exception {
@Test
public void assumeFilename_error() throws Exception {
- String[] input = {
- "class Test {}}",
- };
+ String input =
+ """
+ class Test {}}\
+ """;
StringWriter out = new StringWriter();
StringWriter err = new StringWriter();
Main main =
new Main(
new PrintWriter(out, true),
new PrintWriter(err, true),
- new ByteArrayInputStream(joiner.join(input).getBytes(UTF_8)));
+ new ByteArrayInputStream(input.getBytes(UTF_8)));
assertThat(main.format("--assume-filename=Foo.java", "-")).isEqualTo(1);
assertThat(err.toString()).contains("Foo.java:1:14: error: class, interface");
}
@Test
public void assumeFilename_dryRun() throws Exception {
- String[] input = {
- "class Test {", //
- "}",
- };
+ String input =
+ """
+ class Test {
+ }\
+ """;
StringWriter out = new StringWriter();
StringWriter err = new StringWriter();
Main main =
new Main(
new PrintWriter(out, true),
new PrintWriter(err, true),
- new ByteArrayInputStream(joiner.join(input).getBytes(UTF_8)));
+ new ByteArrayInputStream(input.getBytes(UTF_8)));
assertThat(main.format("--dry-run", "--assume-filename=Foo.java", "-")).isEqualTo(0);
assertThat(out.toString()).isEqualTo("Foo.java" + System.lineSeparator());
}
@Test
public void reflowLongStrings() throws Exception {
- String[] input = {
- "class T {", //
- " String s = \"one long incredibly unbroken sentence moving from topic to topic so that no"
- + " one had a chance to interrupt\";",
- "}"
- };
- String[] expected = {
- "class T {",
- " String s =",
- " \"one long incredibly unbroken sentence moving from topic to topic so that no one had"
- + " a chance\"",
- " + \" to interrupt\";",
- "}",
- "",
- };
- InputStream in = new ByteArrayInputStream(joiner.join(input).getBytes(UTF_8));
+ String input =
+ """
+ class T {
+ String s = "one long incredibly unbroken sentence moving from topic to topic so that no one had a chance to interrupt";
+ }\
+ """;
+ String expected =
+ """
+ class T {
+ String s =
+ "one long incredibly unbroken sentence moving from topic to topic so that no one had a chance"
+ + " to interrupt";
+ }
+ """;
+ InputStream in = new ByteArrayInputStream(input.getBytes(UTF_8));
StringWriter out = new StringWriter();
Main main =
new Main(
@@ -553,26 +557,25 @@ public void reflowLongStrings() throws Exception {
new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.err, UTF_8)), true),
in);
assertThat(main.format("-")).isEqualTo(0);
- assertThat(out.toString()).isEqualTo(joiner.join(expected));
+ assertThat(out.toString()).isEqualTo(expected);
}
@Test
public void noReflowLongStrings() throws Exception {
- String[] input = {
- "class T {", //
- " String s = \"one long incredibly unbroken sentence moving from topic to topic so that no"
- + " one had a chance to interrupt\";",
- "}"
- };
- String[] expected = {
- "class T {",
- " String s =",
- " \"one long incredibly unbroken sentence moving from topic to topic so that no one had"
- + " a chance to interrupt\";",
- "}",
- "",
- };
- InputStream in = new ByteArrayInputStream(joiner.join(input).getBytes(UTF_8));
+ String input =
+"""
+class T {
+ String s = "one long incredibly unbroken sentence moving from topic to topic so that no one had a chance to interrupt";
+}\
+""";
+ String expected =
+"""
+class T {
+ String s =
+ "one long incredibly unbroken sentence moving from topic to topic so that no one had a chance to interrupt";
+}
+""";
+ InputStream in = new ByteArrayInputStream(input.getBytes(UTF_8));
StringWriter out = new StringWriter();
Main main =
new Main(
@@ -580,29 +583,29 @@ public void noReflowLongStrings() throws Exception {
new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.err, UTF_8)), true),
in);
assertThat(main.format("--skip-reflowing-long-strings", "-")).isEqualTo(0);
- assertThat(out.toString()).isEqualTo(joiner.join(expected));
+ assertThat(out.toString()).isEqualTo(expected);
}
@Test
public void noFormatJavadoc() throws Exception {
- String[] input = {
- "/**",
- " * graph",
- " *",
- " * graph",
- " *",
- " * @param foo lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do"
- + " eiusmod tempor incididunt ut labore et dolore magna aliqua",
- " */",
- "class Test {",
- " /**",
- " * creates entropy",
- " */",
- " public static void main(String... args) {}",
- "}",
- "",
- };
- InputStream in = new ByteArrayInputStream(joiner.join(input).getBytes(UTF_8));
+ String input =
+ """
+ /**
+ * graph
+ *
+ * graph
+ *
+ * @param foo lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor
+ * incididunt ut labore et dolore magna aliqua
+ */
+ class Test {
+ /**
+ * creates entropy
+ */
+ public static void main(String... args) {}
+ }
+ """;
+ InputStream in = new ByteArrayInputStream(input.getBytes(UTF_8));
StringWriter out = new StringWriter();
Main main =
new Main(
@@ -610,84 +613,83 @@ public void noFormatJavadoc() throws Exception {
new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.err, UTF_8)), true),
in);
assertThat(main.format("--skip-javadoc-formatting", "-")).isEqualTo(0);
- assertThat(out.toString()).isEqualTo(joiner.join(input));
+ assertThat(out.toString()).isEqualTo(input);
}
@Test
public void reorderModifiersOptionTest() throws Exception {
- String[] input = {
- "class Test {", //
- " static public void main(String... args) {}",
- "}",
- "",
- };
- String[] fixed = {
- "class Test {", //
- " public static void main(String... args) {}",
- "}",
- "",
- };
- String source = joiner.join(input);
- assertThat(new Formatter(JavaFormatterOptions.builder().build()).formatSource(source))
- .isEqualTo(joiner.join(fixed));
+ String input =
+ """
+ class Test {
+ static public void main(String... args) {}
+ }
+ """;
+ String fixed =
+ """
+ class Test {
+ public static void main(String... args) {}
+ }
+ """;
+ assertThat(new Formatter(JavaFormatterOptions.builder().build()).formatSource(input))
+ .isEqualTo(fixed);
assertThat(
new Formatter(JavaFormatterOptions.builder().reorderModifiers(false).build())
- .formatSource(source))
- .isEqualTo(source);
+ .formatSource(input))
+ .isEqualTo(input);
}
@Test
public void syntaxError() throws Exception {
Path path = testFolder.newFile("Test.java").toPath();
- String[] input = {
- "class Test {", //
- " void f(int package) {",
- " int",
- " }",
- "}",
- "",
- };
- String source = joiner.join(input);
- Files.writeString(path, source, UTF_8);
+ String input =
+ """
+ class Test {
+ void f(int package) {
+ int
+ }
+ }\
+ """;
+ Files.writeString(path, input, UTF_8);
StringWriter out = new StringWriter();
StringWriter err = new StringWriter();
Main main = new Main(new PrintWriter(out, true), new PrintWriter(err, true), System.in);
int errorCode = main.format(path.toAbsolutePath().toString());
assertWithMessage("Error Code").that(errorCode).isEqualTo(1);
- String[] expected = {
- path + ":2:13: error: expected",
- " void f(int package) {",
- " ^",
- path + ":3:5: error: not a statement",
- " int",
- " ^",
- path + ":3:8: error: ';' expected",
- " int",
- " ^",
- "",
- };
- assertThat(err.toString()).isEqualTo(joiner.join(expected));
+ String expected =
+ """
+ Β«pathΒ»:2:13: error: expected
+ void f(int package) {
+ ^
+ Β«pathΒ»:3:5: error: not a statement
+ int
+ ^
+ Β«pathΒ»:3:8: error: ';' expected
+ int
+ ^
+ """
+ .replace("Β«pathΒ»", path.toString())
+ .replace("\n", System.lineSeparator());
+ assertThat(err.toString()).isEqualTo(expected);
}
@Test
public void syntaxErrorBeginning() throws Exception {
Path path = testFolder.newFile("Test.java").toPath();
- String[] input = {
- "error", //
- };
- String source = joiner.join(input);
- Files.writeString(path, source, UTF_8);
+ String input = "error";
+ Files.writeString(path, input, UTF_8);
StringWriter out = new StringWriter();
StringWriter err = new StringWriter();
Main main = new Main(new PrintWriter(out, true), new PrintWriter(err, true), System.in);
int errorCode = main.format(path.toAbsolutePath().toString());
assertWithMessage("Error Code").that(errorCode).isEqualTo(1);
- String[] expected = {
- path + ":1:1: error: reached end of file while parsing", //
- "error",
- "^",
- "",
- };
- assertThat(err.toString()).isEqualTo(joiner.join(expected));
+ String expected =
+ """
+ Β«pathΒ»:1:1: error: reached end of file while parsing
+ error
+ ^
+ """
+ .replace("Β«pathΒ»", path.toString())
+ .replace("\n", System.lineSeparator());
+ assertThat(err.toString()).isEqualTo(expected);
}
}
diff --git a/core/src/test/java/com/google/googlejavaformat/java/ModifierOrdererTest.java b/core/src/test/java/com/google/googlejavaformat/java/ModifierOrdererTest.java
index 013d14358..1cb165435 100644
--- a/core/src/test/java/com/google/googlejavaformat/java/ModifierOrdererTest.java
+++ b/core/src/test/java/com/google/googlejavaformat/java/ModifierOrdererTest.java
@@ -18,7 +18,6 @@
import static com.google.common.truth.Truth.assertThat;
-import com.google.common.base.Joiner;
import com.google.common.collect.Range;
import java.util.Arrays;
import org.junit.Test;
@@ -67,13 +66,13 @@ public void everythingIncludingDefault() throws FormatterException {
@Test
public void subRange() throws FormatterException {
- String[] lines = {
- "class Test {", //
- " static public int a;",
- " static public int b;",
- "}",
- };
- String input = Joiner.on('\n').join(lines);
+ String input =
+ """
+ class Test {
+ static public int a;
+ static public int b;
+ }\
+ """;
String substring = "static public int a";
int start = input.indexOf(substring);
int end = start + substring.length();
@@ -87,13 +86,13 @@ public void subRange() throws FormatterException {
@Test
public void whitespace() throws FormatterException {
- String[] lines = {
- "class Test {", //
- " static",
- " public int a;",
- "}",
- };
- String input = Joiner.on('\n').join(lines);
+ String input =
+ """
+ class Test {
+ static
+ public int a;
+ }\
+ """;
String substring = "static public int a";
int start = input.indexOf(substring);
int end = start + substring.length();
diff --git a/core/src/test/java/com/google/googlejavaformat/java/RemoveUnusedImportsCaseLabelsTest.java b/core/src/test/java/com/google/googlejavaformat/java/RemoveUnusedImportsCaseLabelsTest.java
index c0babb0d4..9b2257a22 100644
--- a/core/src/test/java/com/google/googlejavaformat/java/RemoveUnusedImportsCaseLabelsTest.java
+++ b/core/src/test/java/com/google/googlejavaformat/java/RemoveUnusedImportsCaseLabelsTest.java
@@ -16,9 +16,7 @@
import static com.google.common.truth.Truth.assertThat;
import static com.google.googlejavaformat.java.RemoveUnusedImports.removeUnusedImports;
-import static org.junit.Assume.assumeTrue;
-import com.google.common.base.Joiner;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
@@ -28,22 +26,21 @@
public class RemoveUnusedImportsCaseLabelsTest {
@Test
public void preserveTypesInCaseLabels() throws FormatterException {
- assumeTrue(Runtime.version().feature() >= 17);
String input =
- Joiner.on('\n')
- .join(
- "package example;",
- "import example.model.SealedInterface;",
- "import example.model.TypeA;",
- "import example.model.TypeB;",
- "public class Main {",
- " public void apply(SealedInterface sealedInterface) {",
- " switch(sealedInterface) {",
- " case TypeA a -> System.out.println(\"A!\");",
- " case TypeB b -> System.out.println(\"B!\");",
- " }",
- " }",
- "}");
+ """
+ package example;
+ import example.model.SealedInterface;
+ import example.model.TypeA;
+ import example.model.TypeB;
+ public class Main {
+ public void apply(SealedInterface sealedInterface) {
+ switch(sealedInterface) {
+ case TypeA a -> System.out.println("A!");
+ case TypeB b -> System.out.println("B!");
+ }
+ }
+ }\
+ """;
assertThat(removeUnusedImports(input)).isEqualTo(input);
}
}
diff --git a/core/src/test/java/com/google/googlejavaformat/java/RemoveUnusedImportsTest.java b/core/src/test/java/com/google/googlejavaformat/java/RemoveUnusedImportsTest.java
index d8b63ef3e..f186b846e 100644
--- a/core/src/test/java/com/google/googlejavaformat/java/RemoveUnusedImportsTest.java
+++ b/core/src/test/java/com/google/googlejavaformat/java/RemoveUnusedImportsTest.java
@@ -29,248 +29,248 @@
public class RemoveUnusedImportsTest {
@Parameters(name = "{index}: {0}")
public static Collection parameters() {
- String[][][] inputsOutputs = {
+ String[][] inputsOutputs = {
{
- {
- "import java.util.List;",
- "import java.util.ArrayList;",
- "",
- "class Test {",
- " /** could be an {@link ArrayList} */",
- " List xs;",
- "}",
- },
- {
- "import java.util.List;",
- "import java.util.ArrayList;",
- "",
- "class Test {",
- " /** could be an {@link ArrayList} */",
- " List xs;",
- "}",
- },
+ """
+ import java.util.List;
+ import java.util.ArrayList;
+
+ class Test {
+ /** could be an {@link ArrayList} */
+ List xs;
+ }
+ """,
+ """
+ import java.util.List;
+ import java.util.ArrayList;
+
+ class Test {
+ /** could be an {@link ArrayList} */
+ List xs;
+ }
+ """,
},
{
- {
- "import java.util.ArrayList;", //
- "import java.util.Collection;",
- "/** {@link ArrayList#add} {@link Collection#remove(Object)} */",
- "class Test {}",
- },
- {
- "import java.util.ArrayList;", //
- "import java.util.Collection;",
- "/** {@link ArrayList#add} {@link Collection#remove(Object)} */",
- "class Test {}",
- },
+ """
+ import java.util.ArrayList;
+ import java.util.Collection;
+ /** {@link ArrayList#add} {@link Collection#remove(Object)} */
+ class Test {}
+ """,
+ """
+ import java.util.ArrayList;
+ import java.util.Collection;
+ /** {@link ArrayList#add} {@link Collection#remove(Object)} */
+ class Test {}
+ """,
},
{
- {
- "import a.A;",
- "import a.B;",
- "import a.C;",
- "class Test {",
- " /** a",
- " * {@link A} */",
- " void f() {}",
- "}",
- },
- {
- "import a.A;", //
- "class Test {",
- " /** a",
- " * {@link A} */",
- " void f() {}",
- "}",
- },
+ """
+ import a.A;
+ import a.B;
+ import a.C;
+ class Test {
+ /** a
+ * {@link A} */
+ void f() {}
+ }
+ """,
+ """
+ import a.A;
+ class Test {
+ /** a
+ * {@link A} */
+ void f() {}
+ }
+ """,
},
{
- {
- "import a.A;import a.B;", //
- "import a.C; // hello",
- "class Test {",
- " B b;",
- "}",
- },
- {
- "import a.B;", //
- "// hello",
- "class Test {",
- " B b;",
- "}",
- },
+ """
+ import a.A;import a.B;
+ import a.C; // hello
+ class Test {
+ B b;
+ }
+ """,
+ """
+ import a.B;
+ // hello
+ class Test {
+ B b;
+ }
+ """,
},
{
- {
- "import a.A;",
- "import b.B;",
- "import c.C;",
- "import d.D;",
- "import e.E;",
- "import f.F;",
- "import g.G;",
- "import h.H;",
- "/**",
- " * {@link A} {@linkplain B} {@value D#FOO}",
- " *",
- " * @exception E",
- " * @throws F",
- " * @see C",
- " * @see H#foo",
- " * @see ",
- " */",
- "class Test {",
- "}",
- },
- {
- "import a.A;",
- "import b.B;",
- "import c.C;",
- "import d.D;",
- "import e.E;",
- "import f.F;",
- "import h.H;",
- "/**",
- " * {@link A} {@linkplain B} {@value D#FOO}",
- " *",
- " * @exception E",
- " * @throws F",
- " * @see C",
- " * @see H#foo",
- " * @see ",
- " */",
- "class Test {",
- "}",
- },
+ """
+ import a.A;
+ import b.B;
+ import c.C;
+ import d.D;
+ import e.E;
+ import f.F;
+ import g.G;
+ import h.H;
+ /**
+ * {@link A} {@linkplain B} {@value D#FOO}
+ *
+ * @exception E
+ * @throws F
+ * @see C
+ * @see H#foo
+ * @see
+ */
+ class Test {
+ }
+ """,
+ """
+ import a.A;
+ import b.B;
+ import c.C;
+ import d.D;
+ import e.E;
+ import f.F;
+ import h.H;
+ /**
+ * {@link A} {@linkplain B} {@value D#FOO}
+ *
+ * @exception E
+ * @throws F
+ * @see C
+ * @see H#foo
+ * @see
+ */
+ class Test {
+ }
+ """,
},
{
- {
- "import java.util.Map;",
- "/** {@link Map.Entry#containsKey(Object)} } */",
- "class Test {}",
- },
- {
- "import java.util.Map;",
- "/** {@link Map.Entry#containsKey(Object)} } */",
- "class Test {}",
- },
+ """
+ import java.util.Map;
+ /** {@link Map.Entry#containsKey(Object)} } */
+ class Test {}
+ """,
+ """
+ import java.util.Map;
+ /** {@link Map.Entry#containsKey(Object)} } */
+ class Test {}
+ """,
},
{
- {
- "/** {@link #containsKey(Object)} } */", //
- "class Test {}",
- },
- {
- "/** {@link #containsKey(Object)} } */", //
- "class Test {}",
- },
+ """
+ /** {@link #containsKey(Object)} } */
+ class Test {}
+ """,
+ """
+ /** {@link #containsKey(Object)} } */
+ class Test {}
+ """,
},
{
- {
- "import java.util.*;", //
- "class Test {",
- " List xs;",
- "}",
- },
- {
- "import java.util.*;", //
- "class Test {",
- " List xs;",
- "}",
- },
+ """
+ import java.util.*;
+ class Test {
+ List xs;
+ }
+ """,
+ """
+ import java.util.*;
+ class Test {
+ List xs;
+ }
+ """,
},
{
- {
- "package com.foo;",
- "import static com.foo.Outer.A;",
- "import com.foo.*;",
- "import com.foo.B;",
- "import com.bar.C;",
- "class Test {",
- " A a;",
- " B b;",
- " C c;",
- "}",
- },
- {
- "package com.foo;",
- "import static com.foo.Outer.A;",
- "import com.bar.C;",
- "class Test {",
- " A a;",
- " B b;",
- " C c;",
- "}",
+ """
+ package com.foo;
+ import static com.foo.Outer.A;
+ import com.foo.*;
+ import com.foo.B;
+ import com.bar.C;
+ class Test {
+ A a;
+ B b;
+ C c;
+ }
+ """,
+ """
+ package com.foo;
+ import static com.foo.Outer.A;
+ import com.bar.C;
+ class Test {
+ A a;
+ B b;
+ C c;
}
+ """,
},
{
- {
- "import java.util.Map;", //
- "import java.util.Map.Entry;",
- "/** {@link #foo(Map.Entry[])} */",
- "public class Test {}",
- },
- {
- "import java.util.Map;", //
- "/** {@link #foo(Map.Entry[])} */",
- "public class Test {}",
- },
+ """
+ import java.util.Map;
+ import java.util.Map.Entry;
+ /** {@link #foo(Map.Entry[])} */
+ public class Test {}
+ """,
+ """
+ import java.util.Map;
+ /** {@link #foo(Map.Entry[])} */
+ public class Test {}
+ """,
},
{
- {
- "import java.util.List;",
- "import java.util.Collection;",
- "/** {@link java.util.List#containsAll(Collection)} */",
- "public class Test {}",
- },
- {
- "import java.util.Collection;",
- "/** {@link java.util.List#containsAll(Collection)} */",
- "public class Test {}",
- },
+ """
+ import java.util.List;
+ import java.util.Collection;
+ /** {@link java.util.List#containsAll(Collection)} */
+ public class Test {}
+ """,
+ """
+ import java.util.Collection;
+ /** {@link java.util.List#containsAll(Collection)} */
+ public class Test {}
+ """,
},
{
- {
- "package p;",
- "import java.lang.Foo;",
- "import java.lang.Foo.Bar;",
- "import p.Baz;",
- "import p.Baz.Bork;",
- "public class Test implements Foo, Bar, Baz, Bork {}",
- },
- {
- "package p;",
- "import java.lang.Foo.Bar;",
- "import p.Baz.Bork;",
- "public class Test implements Foo, Bar, Baz, Bork {}",
- },
+ """
+ package p;
+ import java.lang.Foo;
+ import java.lang.Foo.Bar;
+ import p.Baz;
+ import p.Baz.Bork;
+ public class Test implements Foo, Bar, Baz, Bork {}
+ """,
+ """
+ package p;
+ import java.lang.Foo.Bar;
+ import p.Baz.Bork;
+ public class Test implements Foo, Bar, Baz, Bork {}
+ """,
},
{
- {
- "import java.lang.Foo;", //
- "interface Test { private static void foo() {} }",
- },
- {
- "interface Test { private static void foo() {} }",
- },
+ """
+ import java.lang.Foo;
+ interface Test { private static void foo() {} }
+ """,
+ """
+ interface Test { private static void foo() {} }
+ """,
},
{
- {
- "import module java.base;", //
- "import java.lang.Foo;",
- "interface Test { private static void foo() {} }",
- },
- {
- "import module java.base;", //
- "interface Test { private static void foo() {} }",
- },
+ """
+ import module java.base;
+ import java.lang.Foo;
+ interface Test { private static void foo() {} }
+ """,
+ """
+ import module java.base;
+ interface Test { private static void foo() {} }
+ """,
},
};
ImmutableList.Builder builder = ImmutableList.builder();
- for (String[][] inputAndOutput : inputsOutputs) {
+ for (String[] inputAndOutput : inputsOutputs) {
assertThat(inputAndOutput).hasLength(2);
- String input = String.join("\n", inputAndOutput[0]) + "\n";
- String output = String.join("\n", inputAndOutput[1]) + "\n";
+ String input = inputAndOutput[0];
+ String output = inputAndOutput[1];
if (input.contains("import module") && Runtime.version().feature() < 25) {
// TODO: cushon - remove this once the minimum supported JDK updates past 25
continue;
diff --git a/core/src/test/java/com/google/googlejavaformat/java/StringWrapperIntegrationTest.java b/core/src/test/java/com/google/googlejavaformat/java/StringWrapperIntegrationTest.java
index 5032ac97c..f13eec608 100644
--- a/core/src/test/java/com/google/googlejavaformat/java/StringWrapperIntegrationTest.java
+++ b/core/src/test/java/com/google/googlejavaformat/java/StringWrapperIntegrationTest.java
@@ -17,7 +17,6 @@
import static com.google.common.collect.ImmutableList.toImmutableList;
import static com.google.common.truth.Truth.assertThat;
-import com.google.common.base.Joiner;
import java.util.Arrays;
import java.util.Collection;
import org.junit.Test;
@@ -31,404 +30,389 @@ public class StringWrapperIntegrationTest {
@Parameters
public static Collection parameters() {
- String[][][] inputsAndOutputs = {
+ String[][] inputsAndOutputs = {
{
- {
- "class T {", //
- " String s =",
- " \"one long incredibly unbroken sentence\"",
- " + \" moving from topic to topic\"",
- " + \" so that no-one had a chance to\"",
- " + \" interrupt\";",
- "}"
- },
- {
- "class T {",
- " String s =",
- " \"one long incredibly unbroken\"",
- " + \" sentence moving from\"",
- " + \" topic to topic so that\"",
- " + \" no-one had a chance to\"",
- " + \" interrupt\";",
- "}",
+ """
+ class T {
+ String s =
+ "one long incredibly unbroken sentence"
+ + " moving from topic to topic"
+ + " so that no-one had a chance to"
+ + " interrupt";
}
+ """,
+ """
+ class T {
+ String s =
+ "one long incredibly unbroken"
+ + " sentence moving from"
+ + " topic to topic so that"
+ + " no-one had a chance to"
+ + " interrupt";
+ }
+ """,
},
{
- {
- "class T {", //
- " String s =",
- " \"one long incredibly unbroken\"",
- " + \" sentence moving from topic to topic so that\"",
- " + \" no-one had a chance to\"",
- " + \" interrupt\";",
- "}"
- },
- {
- "class T {",
- " String s =",
- " \"one long incredibly unbroken\"",
- " + \" sentence moving from\"",
- " + \" topic to topic so that\"",
- " + \" no-one had a chance to\"",
- " + \" interrupt\";",
- "}",
+ """
+ class T {
+ String s =
+ "one long incredibly unbroken"
+ + " sentence moving from topic to topic so that"
+ + " no-one had a chance to"
+ + " interrupt";
+ }
+ """,
+ """
+ class T {
+ String s =
+ "one long incredibly unbroken"
+ + " sentence moving from"
+ + " topic to topic so that"
+ + " no-one had a chance to"
+ + " interrupt";
}
+ """,
},
{
- {
- "class T {", //
- " String s =",
- " \"one long incredibly unbroken\"",
- " + \" sentence moving from topic to topic\"",
- " + \" so that no-one had a chance to interr\"",
- " + \"upt\";",
- "}"
- },
- {
- "class T {",
- " String s =",
- " \"one long incredibly unbroken\"",
- " + \" sentence moving from\"",
- " + \" topic to topic so that\"",
- " + \" no-one had a chance to\"",
- " + \" interrupt\";",
- "}",
+ """
+ class T {
+ String s =
+ "one long incredibly unbroken"
+ + " sentence moving from topic to topic"
+ + " so that no-one had a chance to interr"
+ + "upt";
+ }
+ """,
+ """
+ class T {
+ String s =
+ "one long incredibly unbroken"
+ + " sentence moving from"
+ + " topic to topic so that"
+ + " no-one had a chance to"
+ + " interrupt";
}
+ """,
},
{
- {
- "class T {", //
- " String s = \"one long incredibly unbroken sentence moving from topic to topic so that"
- + " no-one had a chance to interrupt\";",
- "}"
- },
- {
- "class T {",
- " String s =",
- " \"one long incredibly unbroken\"",
- " + \" sentence moving from\"",
- " + \" topic to topic so that\"",
- " + \" no-one had a chance to\"",
- " + \" interrupt\";",
- "}",
- },
+ """
+ class T {
+ String s = "one long incredibly unbroken sentence moving from topic to topic so that no-one had a chance to interrupt";
+ }
+ """,
+ """
+ class T {
+ String s =
+ "one long incredibly unbroken"
+ + " sentence moving from"
+ + " topic to topic so that"
+ + " no-one had a chance to"
+ + " interrupt";
+ }
+ """,
},
{
- {
- "class T {", //
- " String s =",
- " \"one long incredibly unbroken sentence\"",
- " + \" moving from topic to topic\"",
- " + 42",
- " + \" so that no-one had a chance to interr\"",
- " + \"upt\";",
- "}"
- },
- {
- "class T {",
- " String s =",
- " \"one long incredibly unbroken\"",
- " + \" sentence moving from\"",
- " + \" topic to topic\"",
- " + 42",
- " + \" so that no-one had a\"",
- " + \" chance to interrupt\";",
- "}",
+ """
+ class T {
+ String s =
+ "one long incredibly unbroken sentence"
+ + " moving from topic to topic"
+ + 42
+ + " so that no-one had a chance to interr"
+ + "upt";
+ }
+ """,
+ """
+ class T {
+ String s =
+ "one long incredibly unbroken"
+ + " sentence moving from"
+ + " topic to topic"
+ + 42
+ + " so that no-one had a"
+ + " chance to interrupt";
}
+ """,
},
{
- {
- "class T {", //
- " String s ="
- + " \"onelongincrediblyunbrokensentencemovingfromtopictotopicsothatnoonehadachanceto"
- + " interrupt\";",
- "}"
- },
- {
- "class T {",
- " String s =",
- " "
- + " \"onelongincrediblyunbrokensentencemovingfromtopictotopicsothatnoonehadachanceto\"",
- " + \" interrupt\";",
- "}",
+ """
+ class T {
+ String s = "onelongincrediblyunbrokensentencemovingfromtopictotopicsothatnoonehadachanceto interrupt";
}
+ """,
+ """
+ class T {
+ String s =
+ "onelongincrediblyunbrokensentencemovingfromtopictotopicsothatnoonehadachanceto"
+ + " interrupt";
+ }
+ """,
},
{
- {
- "class T {", //
- " String s = \"\\n\\none\\nlong\\nincredibly\\nunbroken\\nsentence\\nmoving\\nfrom\\n"
- + " topic\\nto\\n topic\\nso\\nthat\\nno-one\\nhad\\na\\nchance\\nto\\ninterrupt\";",
- "}"
- },
- {
- "class T {",
- " String s =",
- " \"\\n\\n\"",
- " + \"one\\n\"",
- " + \"long\\n\"",
- " + \"incredibly\\n\"",
- " + \"unbroken\\n\"",
- " + \"sentence\\n\"",
- " + \"moving\\n\"",
- " + \"from\\n\"",
- " + \" topic\\n\"",
- " + \"to\\n\"",
- " + \" topic\\n\"",
- " + \"so\\n\"",
- " + \"that\\n\"",
- " + \"no-one\\n\"",
- " + \"had\\n\"",
- " + \"a\\n\"",
- " + \"chance\\n\"",
- " + \"to\\n\"",
- " + \"interrupt\";",
- "}",
- },
+"""
+class T {
+ String s = "\\n\\none\\nlong\\nincredibly\\nunbroken\\nsentence\\nmoving\\n\
+from\\n topic\\nto\\n topic\\nso\\nthat\\nno-one\\nhad\\na\\nchance\\nto\\ninterrupt";
+}
+""",
+"""
+class T {
+ String s =
+ "\\n\\n"
+ + "one\\n"
+ + "long\\n"
+ + "incredibly\\n"
+ + "unbroken\\n"
+ + "sentence\\n"
+ + "moving\\n"
+ + "from\\n"
+ + " topic\\n"
+ + "to\\n"
+ + " topic\\n"
+ + "so\\n"
+ + "that\\n"
+ + "no-one\\n"
+ + "had\\n"
+ + "a\\n"
+ + "chance\\n"
+ + "to\\n"
+ + "interrupt";
+}
+""",
},
{
- {
- "class T {", //
- " String s = \"\\n\\n\\none\\n\\nlong\\n\\nincredibly\\n\\nunbroken\\n\\nsentence\\n\\n"
- + "moving\\n\\nfrom\\n\\n topic\\n\\nto\\n\\n topic\\n\\nso\\n\\nthat\\n\\nno-one"
- + "\\n\\nhad\\n\\na\\n\\nchance\\n\\nto\\n\\ninterrupt\\n\\n\";",
- "}"
- },
- {
- "class T {",
- " String s =",
- " \"\\n\\n\\n\"",
- " + \"one\\n\\n\"",
- " + \"long\\n\\n\"",
- " + \"incredibly\\n\\n\"",
- " + \"unbroken\\n\\n\"",
- " + \"sentence\\n\\n\"",
- " + \"moving\\n\\n\"",
- " + \"from\\n\\n\"",
- " + \" topic\\n\\n\"",
- " + \"to\\n\\n\"",
- " + \" topic\\n\\n\"",
- " + \"so\\n\\n\"",
- " + \"that\\n\\n\"",
- " + \"no-one\\n\\n\"",
- " + \"had\\n\\n\"",
- " + \"a\\n\\n\"",
- " + \"chance\\n\\n\"",
- " + \"to\\n\\n\"",
- " + \"interrupt\\n\\n\";",
- "}",
- },
+"""
+class T {
+ String s = "\\n\\n\\none\\n\\nlong\\n\\nincredibly\\n\\nunbroken\\n\\nsentence\\n\\nmoving\\n\\n\
+from\\n\\n topic\\n\\nto\\n\\n topic\\n\\nso\\n\\nthat\\n\\nno-one\\n\\nhad\\n\\na\\n\\nchance\\n\\nto\\n\\ninterrupt\\n\\n";
+}
+""",
+"""
+class T {
+ String s =
+ "\\n\\n\\n"
+ + "one\\n\\n"
+ + "long\\n\\n"
+ + "incredibly\\n\\n"
+ + "unbroken\\n\\n"
+ + "sentence\\n\\n"
+ + "moving\\n\\n"
+ + "from\\n\\n"
+ + " topic\\n\\n"
+ + "to\\n\\n"
+ + " topic\\n\\n"
+ + "so\\n\\n"
+ + "that\\n\\n"
+ + "no-one\\n\\n"
+ + "had\\n\\n"
+ + "a\\n\\n"
+ + "chance\\n\\n"
+ + "to\\n\\n"
+ + "interrupt\\n\\n";
+}
+""",
},
{
- {
- "class T {", //
- " String s = \"onelongincrediblyunbrokensenten\\tcemovingfromtopictotopicsothatnoonehada"
- + "chance tointerrupt\";",
- "}"
- },
- {
- "class T {",
- " String s =",
- " \"onelongincrediblyunbrokensenten\"",
- " + \"\\tcemovingfromtopictotopicsothatnoonehadachance\"",
- " + \" tointerrupt\";",
- "}",
+ """
+ class T {
+ String s = "onelongincrediblyunbrokensenten\\tcemovingfromtopictotopicsothatnoonehadachance tointerrupt";
+ }
+ """,
+ """
+ class T {
+ String s =
+ "onelongincrediblyunbrokensenten"
+ + "\\tcemovingfromtopictotopicsothatnoonehadachance"
+ + " tointerrupt";
}
+ """,
},
{
- {
- "class T {", //
- " String s = \"onelongincrediblyunbrokensentencemovingfromtopictotopicsothatnoonehada"
- + "chancetointerrupt_____________________)_\";",
- "}"
- },
- {
- "class T {",
- " String s =",
- " \"onelongincrediblyunbrokensentencemovingfromtopictotopicsothatnoonehada"
- + "chancetointerrupt_____________________)_\";",
- "}",
+ """
+ class T {
+ String s = "onelongincrediblyunbrokensentencemovingfromtopictotopicsothatnoonehadachancetointerrupt_____________________)_";
}
+ """,
+ """
+ class T {
+ String s =
+ "onelongincrediblyunbrokensentencemovingfromtopictotopicsothatnoonehadachancetointerrupt_____________________)_";
+ }
+ """,
},
{
- {
- "class T {", //
- " String s = \"onelongincrediblyunbrokensentencemovingfromtopictotopicsot atnoonehada"
- + "chancetointerrupt______________________\";;",
- "}"
- },
- {
- "class T {",
- " String s =",
- " \"onelongincrediblyunbrokensentencemovingfromtopictotopicsot\"",
- " + \" atnoonehadachancetointerrupt______________________\";",
- " ;",
- "}",
+ """
+ class T {
+ String s = "onelongincrediblyunbrokensentencemovingfromtopictotopicsot atnoonehadachancetointerrupt______________________";;
+ }
+ """,
+ """
+ class T {
+ String s =
+ "onelongincrediblyunbrokensentencemovingfromtopictotopicsot"
+ + " atnoonehadachancetointerrupt______________________";
+ ;
}
+ """,
},
{
- {
- "class T {", //
- " String s = \"__ onelongincrediblyunbrokensentencemovingfromtopictotopicsothatnoonehada"
- + "chanceto interrupt\";",
- "}"
- },
- {
- "class T {",
- " String s =",
- " \"__"
- + " onelongincrediblyunbrokensentencemovingfromtopictotopicsothatnoonehadachanceto\"",
- " + \" interrupt\";",
- "}",
+ """
+ class T {
+ String s = "__ onelongincrediblyunbrokensentencemovingfromtopictotopicsothatnoonehadachanceto interrupt";
+ }
+ """,
+ """
+ class T {
+ String s =
+ "__ onelongincrediblyunbrokensentencemovingfromtopictotopicsothatnoonehadachanceto"
+ + " interrupt";
}
+ """,
},
{
- {
- "class T {", //
- " String s =",
- " \"one long incredibly unbroken sentence\"",
- " // comment",
- " + \" moving from topic to topic\"",
- " // comment",
- " + \" so that no-one had a chance to\"",
- " // comment",
- " + \" interrupt\";",
- "}"
- },
- {
- "class T {",
- " String s =",
- " \"one long incredibly unbroken\"",
- " + \" sentence\"",
- " // comment",
- " + \" moving from topic to\"",
- " + \" topic\"",
- " // comment",
- " + \" so that no-one had a\"",
- " + \" chance to\"",
- " // comment",
- " + \" interrupt\";",
- "}",
+ """
+ class T {
+ String s =
+ "one long incredibly unbroken sentence"
+ // comment
+ + " moving from topic to topic"
+ // comment
+ + " so that no-one had a chance to"
+ // comment
+ + " interrupt";
}
+ """,
+ """
+ class T {
+ String s =
+ "one long incredibly unbroken"
+ + " sentence"
+ // comment
+ + " moving from topic to"
+ + " topic"
+ // comment
+ + " so that no-one had a"
+ + " chance to"
+ // comment
+ + " interrupt";
+ }
+ """,
},
{
- {
- "class T {", //
- " String s =",
- " \"aaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbb ccccccccccccccccccccccccccc"
- + " dddddddddddddddddd\";",
- "}"
- },
- {
- "class T {",
- " String s =",
- " \"aaaaaaaaaaaaaaaaaaaaaaaa\"",
- " + \" bbbbbbbbbbbbbbbbbb\"",
- " + \" ccccccccccccccccccccccccccc\"",
- " + \" dddddddddddddddddd\";",
- "}",
+ """
+ class T {
+ String s =
+ "aaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbb ccccccccccccccccccccccccccc dddddddddddddddddd";
+ }
+ """,
+ """
+ class T {
+ String s =
+ "aaaaaaaaaaaaaaaaaaaaaaaa"
+ + " bbbbbbbbbbbbbbbbbb"
+ + " ccccccccccccccccccccccccccc"
+ + " dddddddddddddddddd";
}
+ """,
},
{
- {
- "class T {", //
- " String s =",
- " \"aaaaaaaaaaaaaaaaaaaaaaaa \"",
- " + \"bbbbbbbbbbbbbbbbbb \"",
- " + \"ccccccccccccccccccccccccccc \"",
- " + \"dddddddddddddddddd\";",
- "}"
- },
- {
- "class T {",
- " String s =",
- " \"aaaaaaaaaaaaaaaaaaaaaaaa\"",
- " + \" bbbbbbbbbbbbbbbbbb\"",
- " + \" ccccccccccccccccccccccccccc\"",
- " + \" dddddddddddddddddd\";",
- "}",
+ """
+ class T {
+ String s =
+ "aaaaaaaaaaaaaaaaaaaaaaaa "
+ + "bbbbbbbbbbbbbbbbbb "
+ + "ccccccccccccccccccccccccccc "
+ + "dddddddddddddddddd";
+ }
+ """,
+ """
+ class T {
+ String s =
+ "aaaaaaaaaaaaaaaaaaaaaaaa"
+ + " bbbbbbbbbbbbbbbbbb"
+ + " ccccccccccccccccccccccccccc"
+ + " dddddddddddddddddd";
}
+ """,
},
{
- {
- "class T {", //
- " byte[] bytes =",
- " \"one long incredibly unbroken sentence moving from topic to topic so that no-one"
- + " had a chance to interrupt\".getBytes();",
- "}"
- },
- {
- "class T {", //
- " byte[] bytes =",
- " \"one long incredibly unbroken sentence moving from topic to topic so that no-one"
- + " had a chance to interrupt\"",
- " .getBytes();",
- "}"
- },
+"""
+class T {
+ byte[] bytes =
+ "one long incredibly unbroken sentence moving from topic to topic so that no-one had a chance to interrupt".getBytes();
+}
+""",
+"""
+class T {
+ byte[] bytes =
+ "one long incredibly unbroken sentence moving from topic to topic so that no-one had a chance to interrupt"
+ .getBytes();
+}
+""",
},
{
- {
- "class T {", //
- " String s = \"\\r\\rone\\rlong\\rincredibly\\runbroken\\rsentence\\rmoving\\rfrom\\r"
- + " topic\\rto\\r topic\\rso\\rthat\\rno-one\\rhad\\ra\\rchance\\rto\\rinterrupt\";",
- "}"
- },
- {
- "class T {",
- " String s =",
- " \"\\r\\r\"",
- " + \"one\\r\"",
- " + \"long\\r\"",
- " + \"incredibly\\r\"",
- " + \"unbroken\\r\"",
- " + \"sentence\\r\"",
- " + \"moving\\r\"",
- " + \"from\\r\"",
- " + \" topic\\r\"",
- " + \"to\\r\"",
- " + \" topic\\r\"",
- " + \"so\\r\"",
- " + \"that\\r\"",
- " + \"no-one\\r\"",
- " + \"had\\r\"",
- " + \"a\\r\"",
- " + \"chance\\r\"",
- " + \"to\\r\"",
- " + \"interrupt\";",
- "}",
- },
+"""
+class T {
+ String s = "\\r\\rone\\rlong\\rincredibly\\runbroken\\rsentence\\rmoving\\r\
+from\\r topic\\rto\\r topic\\rso\\rthat\\rno-one\\rhad\\ra\\rchance\\rto\\rinterrupt";
+}
+""",
+"""
+class T {
+ String s =
+ "\\r\\r"
+ + "one\\r"
+ + "long\\r"
+ + "incredibly\\r"
+ + "unbroken\\r"
+ + "sentence\\r"
+ + "moving\\r"
+ + "from\\r"
+ + " topic\\r"
+ + "to\\r"
+ + " topic\\r"
+ + "so\\r"
+ + "that\\r"
+ + "no-one\\r"
+ + "had\\r"
+ + "a\\r"
+ + "chance\\r"
+ + "to\\r"
+ + "interrupt";
+}
+""",
},
{
- {
- "class T {", //
- " String s = \"\\r\\n\\r\\none\\r\\nlong\\r\\nincredibly\\r\\nunbroken\\r\\nsentence"
- + "\\r\\nmoving\\r\\nfrom\\r\\n topic\\r\\nto\\r\\n topic\\r\\nso\\r\\nthat\\r\\n"
- + "no-one\\r\\nhad\\r\\na\\r\\nchance\\r\\nto\\r\\ninterrupt\";",
- "}"
- },
- {
- "class T {",
- " String s =",
- " \"\\r\\n\\r\\n\"",
- " + \"one\\r\\n\"",
- " + \"long\\r\\n\"",
- " + \"incredibly\\r\\n\"",
- " + \"unbroken\\r\\n\"",
- " + \"sentence\\r\\n\"",
- " + \"moving\\r\\n\"",
- " + \"from\\r\\n\"",
- " + \" topic\\r\\n\"",
- " + \"to\\r\\n\"",
- " + \" topic\\r\\n\"",
- " + \"so\\r\\n\"",
- " + \"that\\r\\n\"",
- " + \"no-one\\r\\n\"",
- " + \"had\\r\\n\"",
- " + \"a\\r\\n\"",
- " + \"chance\\r\\n\"",
- " + \"to\\r\\n\"",
- " + \"interrupt\";",
- "}",
- },
+"""
+class T {
+ String s = "\\r\\n\\r\\none\\r\\nlong\\r\\nincredibly\\r\\nunbroken\\r\\nsentence\\r\\nmoving\\r\\n\
+from\\r\\n topic\\r\\nto\\r\\n topic\\r\\nso\\r\\nthat\\r\\nno-one\\r\\nhad\\r\\na\\r\\nchance\\r\\nto\\r\\ninterrupt";
+}
+""",
+"""
+class T {
+ String s =
+ "\\r\\n\\r\\n"
+ + "one\\r\\n"
+ + "long\\r\\n"
+ + "incredibly\\r\\n"
+ + "unbroken\\r\\n"
+ + "sentence\\r\\n"
+ + "moving\\r\\n"
+ + "from\\r\\n"
+ + " topic\\r\\n"
+ + "to\\r\\n"
+ + " topic\\r\\n"
+ + "so\\r\\n"
+ + "that\\r\\n"
+ + "no-one\\r\\n"
+ + "had\\r\\n"
+ + "a\\r\\n"
+ + "chance\\r\\n"
+ + "to\\r\\n"
+ + "interrupt";
+}
+""",
},
};
return Arrays.stream(inputsAndOutputs)
@@ -436,8 +420,7 @@ public static Collection parameters() {
inputAndOutput -> {
assertThat(inputAndOutput).hasLength(2);
return new String[] {
- Joiner.on('\n').join(inputAndOutput[0]) + '\n', //
- Joiner.on('\n').join(inputAndOutput[1]) + '\n',
+ inputAndOutput[0], inputAndOutput[1],
};
})
.collect(toImmutableList());
diff --git a/core/src/test/java/com/google/googlejavaformat/java/StringWrapperTest.java b/core/src/test/java/com/google/googlejavaformat/java/StringWrapperTest.java
index a9ceeacb6..afc1533f4 100644
--- a/core/src/test/java/com/google/googlejavaformat/java/StringWrapperTest.java
+++ b/core/src/test/java/com/google/googlejavaformat/java/StringWrapperTest.java
@@ -17,7 +17,6 @@
import static com.google.common.truth.Truth.assertThat;
import static org.junit.Assume.assumeTrue;
-import com.google.common.base.Joiner;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
@@ -28,27 +27,27 @@ public class StringWrapperTest {
@Test
public void testAwkwardLineEndWrapping() throws Exception {
String input =
- lines(
- "class T {",
- // This is a wide line, but has to be split in code because of 100-char limit.
- " String s = someMethodWithQuiteALongNameThatWillGetUsUpCloseToTheColumnLimit() "
- + "+ \"foo bar foo bar foo bar\";",
- "",
- " String someMethodWithQuiteALongNameThatWillGetUsUpCloseToTheColumnLimit() {",
- " return null;",
- " }",
- "}");
+"""
+class T {
+ String s = someMethodWithQuiteALongNameThatWillGetUsUpCloseToTheColumnLimit() + "foo bar foo bar foo bar";
+
+ String someMethodWithQuiteALongNameThatWillGetUsUpCloseToTheColumnLimit() {
+ return null;
+ }
+}
+""";
String output =
- lines(
- "class T {",
- " String s =",
- " someMethodWithQuiteALongNameThatWillGetUsUpCloseToTheColumnLimit()",
- " + \"foo bar foo bar foo bar\";",
- "",
- " String someMethodWithQuiteALongNameThatWillGetUsUpCloseToTheColumnLimit() {",
- " return null;",
- " }",
- "}");
+ """
+ class T {
+ String s =
+ someMethodWithQuiteALongNameThatWillGetUsUpCloseToTheColumnLimit()
+ + "foo bar foo bar foo bar";
+
+ String someMethodWithQuiteALongNameThatWillGetUsUpCloseToTheColumnLimit() {
+ return null;
+ }
+ }
+ """;
assertThat(StringWrapper.wrap(100, input, new Formatter())).isEqualTo(output);
}
@@ -57,19 +56,19 @@ public void testAwkwardLineEndWrapping() throws Exception {
public void textBlock() throws Exception {
assumeTrue(Runtime.version().feature() >= 15);
String input =
- lines(
- "package com.mypackage;",
- "public class ReproBug {",
- " private String myString;",
- " private ReproBug() {",
- " String str =",
- "\"\"\"",
- "{\"sourceEndpoint\":\"ri.something.1-1.object-internal.1\",\"targetEndpoint"
- + "\":\"ri.something.1-1.object-internal.2\",\"typeId\":\"typeId\"}\\",
- "\"\"\";",
- " myString = str;",
- " }",
- "}");
+"""
+package com.mypackage;
+public class ReproBug {
+ private String myString;
+ private ReproBug() {
+ String str =
+\"""
+{"sourceEndpoint":"ri.something.1-1.object-internal.1","targetEndpoint":"ri.something.1-1.object-internal.2","typeId":"typeId"}\\
+\""";
+ myString = str;
+ }
+}
+""";
assertThat(StringWrapper.wrap(100, input, new Formatter())).isEqualTo(input);
}
@@ -81,16 +80,17 @@ public void textBlockControlCharacter() throws Exception {
// We want an actual control character in the Java source being formatted, not a unicode escape,
// i.e. the escape below doesn't need to be double-escaped.
String input =
- lines(
- "package p;",
- "public class T {",
- " String s =",
- " \"\"\"",
- " \u0007lorem",
- " \u0007",
- " ipsum",
- " \"\"\";",
- "}");
+ """
+ package p;
+ public class T {
+ String s =
+ \"""
+ \u0007lorem
+ \u0007
+ ipsum
+ \""";
+ }
+ """;
String actual = StringWrapper.wrap(100, input, new Formatter());
assertThat(actual).isEqualTo(input);
}
@@ -98,24 +98,27 @@ public void textBlockControlCharacter() throws Exception {
@Test
public void textBlockTrailingWhitespace() throws Exception {
assumeTrue(Runtime.version().feature() >= 15);
+ @SuppressWarnings("MisleadingEscapedSpace") // TODO(b/496180372): remove
String input =
- lines(
- "public class T {",
- " String s =",
- " \"\"\"",
- " lorem ",
- " ipsum",
- " \"\"\";",
- "}");
+ """
+ public class T {
+ String s =
+ \"""
+ lorem \s
+ ipsum
+ \""";
+ }
+ """;
String expected =
- lines(
- "public class T {",
- " String s =",
- " \"\"\"",
- " lorem",
- " ipsum",
- " \"\"\";",
- "}");
+ """
+ public class T {
+ String s =
+ \"""
+ lorem
+ ipsum
+ \""";
+ }
+ """;
String actual = StringWrapper.wrap(100, input, new Formatter());
assertThat(actual).isEqualTo(expected);
}
@@ -128,23 +131,25 @@ public void textBlockTrailingWhitespaceUnicodeEscape() throws Exception {
// We want a unicode escape in the Java source being formatted, so it needs to be escaped
// in the string literal in this test.
String input =
- lines(
- "public class T {",
- " String s =",
- " \"\"\"",
- " lorem\\u0020",
- " ipsum",
- " \"\"\";",
- "}");
+ """
+ public class T {
+ String s =
+ \"""
+ lorem\\u0020
+ ipsum
+ \""";
+ }
+ """;
String expected =
- lines(
- "public class T {",
- " String s =",
- " \"\"\"",
- " lorem\\u0020",
- " ipsum",
- " \"\"\";",
- "}");
+ """
+ public class T {
+ String s =
+ \"""
+ lorem\\u0020
+ ipsum
+ \""";
+ }
+ """;
String actual = StringWrapper.wrap(100, input, new Formatter());
assertThat(actual).isEqualTo(expected);
}
@@ -153,23 +158,25 @@ public void textBlockTrailingWhitespaceUnicodeEscape() throws Exception {
public void textBlockSpaceTabMix() throws Exception {
assumeTrue(Runtime.version().feature() >= 15);
String input =
- lines(
- "public class T {",
- " String s =",
- " \"\"\"",
- " lorem",
- " \tipsum",
- " \"\"\";",
- "}");
+ """
+ public class T {
+ String s =
+ \"""
+ lorem
+ \tipsum
+ \""";
+ }
+ """;
String expected =
- lines(
- "public class T {",
- " String s =",
- " \"\"\"",
- " lorem",
- " ipsum",
- " \"\"\";",
- "}");
+ """
+ public class T {
+ String s =
+ \"""
+ lorem
+ ipsum
+ \""";
+ }
+ """;
String actual = StringWrapper.wrap(100, input, new Formatter());
assertThat(actual).isEqualTo(expected);
}
@@ -178,30 +185,28 @@ public void textBlockSpaceTabMix() throws Exception {
public void leadingBlankLine() throws Exception {
assumeTrue(Runtime.version().feature() >= 15);
String input =
- lines(
- "public class T {",
- " String s =",
- " \"\"\"",
- "",
- " lorem",
- " ipsum",
- " \"\"\";",
- "}");
+ """
+ public class T {
+ String s =
+ \"""
+
+ lorem
+ ipsum
+ \""";
+ }
+ """;
String expected =
- lines(
- "public class T {",
- " String s =",
- " \"\"\"",
- "",
- " lorem",
- " ipsum",
- " \"\"\";",
- "}");
+ """
+ public class T {
+ String s =
+ \"""
+
+ lorem
+ ipsum
+ \""";
+ }
+ """;
String actual = StringWrapper.wrap(100, input, new Formatter());
assertThat(actual).isEqualTo(expected);
}
-
- private static String lines(String... line) {
- return Joiner.on('\n').join(line) + '\n';
- }
}
diff --git a/core/src/test/java/com/google/googlejavaformat/java/filer/FormattingFilerTest.java b/core/src/test/java/com/google/googlejavaformat/java/filer/FormattingFilerTest.java
index 38cac3550..5fa4f4217 100644
--- a/core/src/test/java/com/google/googlejavaformat/java/filer/FormattingFilerTest.java
+++ b/core/src/test/java/com/google/googlejavaformat/java/filer/FormattingFilerTest.java
@@ -90,14 +90,13 @@ public void formatsFile() throws IOException {
assertThat(sourceFile.getCharContent(false).toString())
.isEqualTo(
- Joiner.on('\n')
- .join(
- "package foo;",
- "",
- "class Bar {",
- " private String baz;",
- "}",
- "")); // trailing newline
+ """
+ package foo;
+
+ class Bar {
+ private String baz;
+ }
+ """);
}
private static class FakeFiler implements Filer {