Main { public int format(String... args) throws UsageException { CommandLineOptions parameters = processArgs(args); if (parameters.version()) { errWriter.println(versionString()); return 0; } if (parameters.help()) { throw new UsageException(); } JavaFormatterOptions options = JavaFormatterOptions.builder() .style(parameters.aosp() ? Style.AOSP : Style.GOOGLE) .formatJavadoc(parameters.formatJavadoc()) .build(); if (parameters.stdin()) { return formatStdin(parameters, options); } else { return formatFiles(parameters, options); } } Main(PrintWriter outWriter, PrintWriter errWriter, InputStream inStream); static void main(String[] args); int format(String... args); static CommandLineOptions processArgs(String... args);  }
@Test public void testUsageOutput() { StringWriter out = new StringWriter(); StringWriter err = new StringWriter(); Main main = new Main(new PrintWriter(out, true), new PrintWriter(err, true), System.in); try { main.format("--help"); throw new AssertionError("Expected UsageException to be thrown"); } catch (UsageException e) { String usage = e.getMessage(); assertThat(usage).contains("https: assertThat(usage).contains("Usage: google-java-format"); assertThat(usage).contains("--length"); assertThat(usage).contains("Character length to format."); assertThat(usage).contains("the result is sent to stdout"); } }
@Test public void version() throws UsageException { StringWriter out = new StringWriter(); StringWriter err = new StringWriter(); Main main = new Main(new PrintWriter(out, true), new PrintWriter(err, true), System.in); assertThat(main.format("-version")).isEqualTo(0); assertThat(err.toString()).contains("google-java-format: Version "); }
@Test public void preserveOriginalFile() throws Exception { Path path = testFolder.newFile("Test.java").toPath(); Files.write(path, "class Test {}\n".getBytes(UTF_8)); try { Files.setPosixFilePermissions(path, EnumSet.of(PosixFilePermission.OWNER_READ)); } catch (UnsupportedOperationException e) { return; } Main main = new Main( new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out, UTF_8)), true), new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.err, UTF_8)), true), System.in); int errorCode = main.format("-replace", path.toAbsolutePath().toString()); assertWithMessage("Error Code").that(errorCode).isEqualTo(0); }
@Test public void javadoc() throws Exception { String[] input = { "", "class Test {", " ", " public static void main(String... args) {}", "}", }; String[] expected = { "", "class Test {", " ", " public static void main(String... args) {}", "}", "", }; InputStream in = new ByteArrayInputStream(joiner.join(input).getBytes(UTF_8)); StringWriter out = new StringWriter(); Main main = new Main( new PrintWriter(out, true), new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.err, UTF_8)), true), in); assertThat(main.format("-")).isEqualTo(0); assertThat(out.toString()).isEqualTo(joiner.join(expected)); }
@Test public void imports() throws Exception { String[] input = { "import java.util.LinkedList;", "import java.util.List;", "import java.util.ArrayList;", "class Test {", " ", " public static List<String> names;", "}", }; String[] expected = { "import java.util.ArrayList;", "import java.util.List;", "", "class Test {", " ", " public static List<String> names;", "}", }; InputStream in = new ByteArrayInputStream(joiner.join(input).getBytes(UTF_8)); StringWriter out = new StringWriter(); Main main = new Main( new PrintWriter(out, true), 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)); }
@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 {}", "" }; String optimized = new Formatter().formatSourceAndFixImports(joiner.join(input)); assertThat(optimized).isEqualTo(joiner.join(expected)); InputStream in = new ByteArrayInputStream(joiner.join(input).getBytes(UTF_8)); StringWriter out = new StringWriter(); Main main = new Main( new PrintWriter(out, true), new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.err, UTF_8)), true), in); assertThat(main.format("-")).isEqualTo(0); assertThat(out.toString()).isEqualTo(joiner.join(expected)); }
@Test public void importRemovalLines() throws Exception { String[] input = { "import java.util.ArrayList;", "import java.util.List;", "class Test {", "ArrayList<String> a = new ArrayList<>();", "ArrayList<String> b = new ArrayList<>();", "}", }; String[] expected = { "import java.util.ArrayList;", "", "class Test {", " ArrayList<String> a = new ArrayList<>();", "ArrayList<String> 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))); assertThat(main.format("-", "-lines", "4")).isEqualTo(0); assertThat(out.toString()).isEqualTo(joiner.join(expected)); }
@Test public void importRemoveErrorParseError() throws Exception { Locale backupLocale = Locale.getDefault(); try { Locale.setDefault(Locale.ROOT); 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))); assertThat(main.format("-")).isEqualTo(1); assertThat(err.toString()).contains("<stdin>:4:3: error: class, interface"); } finally { Locale.setDefault(backupLocale); } }
@Test public void packageInfo() throws Exception { String[] input = { "@CheckReturnValue", "@ParametersAreNonnullByDefault", "package com.google.common.labs.base;", "", "import javax.annotation.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))); assertThat(main.format("-")).isEqualTo(0); assertThat(out.toString()).isEqualTo(joiner.join(input)); }
@Test public void newline() throws Exception { StringWriter out = new StringWriter(); StringWriter err = new StringWriter(); Main main = new Main( new PrintWriter(out, true), new PrintWriter(err, true), new ByteArrayInputStream("class T {}\n\t".getBytes(UTF_8))); assertThat(main.format("-")).isEqualTo(0); assertThat(out.toString()).isEqualTo("class T {}\n"); }
@Test public void dryRunStdinUnchanged() throws Exception { StringWriter out = new StringWriter(); StringWriter err = new StringWriter(); Main main = new Main( new PrintWriter(out, true), new PrintWriter(err, true), new ByteArrayInputStream("class Test {}\n".getBytes(UTF_8))); assertThat(main.format("-n", "-")).isEqualTo(0); assertThat(out.toString()).isEmpty(); assertThat(err.toString()).isEmpty(); }
@Test public void dryRunStdinChanged() throws Exception { StringWriter out = new StringWriter(); StringWriter err = new StringWriter(); String input = "class Test {\n}\n"; Main main = new Main( new PrintWriter(out, true), new PrintWriter(err, true), new ByteArrayInputStream(input.getBytes(UTF_8))); assertThat(main.format("-n", "-")).isEqualTo(0); assertThat(out.toString()).isEqualTo("<stdin>" + System.lineSeparator()); assertThat(err.toString()).isEmpty(); }
@Test public void dryRunFiles() throws Exception { Path a = testFolder.newFile("A.java").toPath(); Path b = testFolder.newFile("B.java").toPath(); Path c = testFolder.newFile("C.java").toPath(); Files.write(a, "class A {}\n".getBytes(UTF_8)); Files.write(b, "class B {\n}\n".getBytes(UTF_8)); Files.write(c, "class C {\n}\n".getBytes(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 exitCode = main.format( "-n", a.toAbsolutePath().toAbsolutePath().toString(), b.toAbsolutePath().toString(), c.toAbsolutePath().toString()); assertThat(exitCode).isEqualTo(0); assertThat(out.toString()) .isEqualTo( b.toAbsolutePath().toString() + System.lineSeparator() + c.toAbsolutePath().toString() + System.lineSeparator()); assertThat(err.toString()).isEmpty(); }
@Test public void keepGoingWhenFilesDontExist() throws Exception { Path a = testFolder.newFile("A.java").toPath(); Path b = testFolder.newFile("B.java").toPath(); File cFile = testFolder.newFile("C.java"); Path c = cFile.toPath(); cFile.delete(); Files.write(a, "class A{}\n".getBytes(UTF_8)); Files.write(b, "class B{}\n".getBytes(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 exitCode = main.format( "", a.toAbsolutePath().toString(), c.toAbsolutePath().toString(), b.toAbsolutePath().toString()); assertThat(exitCode).isEqualTo(1); assertThat(out.toString()).isEqualTo("class A {}\nclass B {}\n"); assertThat(err.toString()).isNotEmpty(); }
@Test public void assumeFilename_error() throws Exception { 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))); assertThat(main.format("--assume-filename=Foo.java", "-")).isEqualTo(1); assertThat(err.toString()).contains("Foo.java:1:15: error: class, interface"); }
@Test public void assumeFilename_dryRun() throws Exception { 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))); 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)); StringWriter out = new StringWriter(); Main main = new Main( new PrintWriter(out, true), new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.err, UTF_8)), true), in); assertThat(main.format("-")).isEqualTo(0); assertThat(out.toString()).isEqualTo(joiner.join(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)); StringWriter out = new StringWriter(); Main main = new Main( new PrintWriter(out, true), 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)); }
@Test public void noFormatJavadoc() throws Exception { String[] input = { "", "class Test {", " ", " public static void main(String... args) {}", "}", "", }; InputStream in = new ByteArrayInputStream(joiner.join(input).getBytes(UTF_8)); StringWriter out = new StringWriter(); Main main = new Main( new PrintWriter(out, true), 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)); }