Clang Project

clang_source_code/unittests/Format/FormatTestJava.cpp
1//===- unittest/Format/FormatTestJava.cpp - Formatting tests for Java -----===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#include "FormatTestUtils.h"
10#include "clang/Format/Format.h"
11#include "llvm/Support/Debug.h"
12#include "gtest/gtest.h"
13
14#define DEBUG_TYPE "format-test"
15
16namespace clang {
17namespace format {
18
19class FormatTestJava : public ::testing::Test {
20protected:
21  static std::string format(llvm::StringRef Code, unsigned Offset,
22                            unsigned Length, const FormatStyle &Style) {
23    LLVM_DEBUG(llvm::errs() << "---\n");
24    LLVM_DEBUG(llvm::errs() << Code << "\n\n");
25    std::vector<tooling::Range> Ranges(1, tooling::Range(Offset, Length));
26    tooling::Replacements Replaces = reformat(Style, Code, Ranges);
27    auto Result = applyAllReplacements(Code, Replaces);
28    EXPECT_TRUE(static_cast<bool>(Result));
29    LLVM_DEBUG(llvm::errs() << "\n" << *Result << "\n\n");
30    return *Result;
31  }
32
33  static std::string
34  format(llvm::StringRef Code,
35         const FormatStyle &Style = getGoogleStyle(FormatStyle::LK_Java)) {
36    return format(Code, 0, Code.size(), Style);
37  }
38
39  static FormatStyle getStyleWithColumns(unsigned ColumnLimit) {
40    FormatStyle Style = getGoogleStyle(FormatStyle::LK_Java);
41    Style.ColumnLimit = ColumnLimit;
42    return Style;
43  }
44
45  static void verifyFormat(
46      llvm::StringRef Code,
47      const FormatStyle &Style = getGoogleStyle(FormatStyle::LK_Java)) {
48    EXPECT_EQ(Code.str(), format(Code, Style)) << "Expected code is not stable";
49    EXPECT_EQ(Code.str(), format(test::messUp(Code), Style));
50  }
51};
52
53TEST_F(FormatTestJava, NoAlternativeOperatorNames) {
54  verifyFormat("someObject.and();");
55}
56
57TEST_F(FormatTestJava, UnderstandsCasts) {
58  verifyFormat("a[b >> 1] = (byte) (c() << 4);");
59}
60
61TEST_F(FormatTestJava, FormatsInstanceOfLikeOperators) {
62  FormatStyle Style = getStyleWithColumns(50);
63  verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
64               "    instanceof bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;",
65               Style);
66  Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
67  verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaa instanceof\n"
68               "    bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;",
69               Style);
70  verifyFormat("return aaaaaaaaaaaaaaaaaaa instanceof bbbbbbbbbbbbbbbbbbbbbbb\n"
71               "    && ccccccccccccccccccc instanceof dddddddddddddddddddddd;");
72}
73
74TEST_F(FormatTestJava, Chromium) {
75  verifyFormat("class SomeClass {\n"
76               "    void f() {}\n"
77               "    int g() {\n"
78               "        return 0;\n"
79               "    }\n"
80               "    void h() {\n"
81               "        while (true) f();\n"
82               "        for (;;) f();\n"
83               "        if (true) f();\n"
84               "    }\n"
85               "}",
86               getChromiumStyle(FormatStyle::LK_Java));
87}
88
89TEST_F(FormatTestJava, QualifiedNames) {
90  verifyFormat("public some.package.Type someFunction( // comment\n"
91               "    int parameter) {}");
92}
93
94TEST_F(FormatTestJava, ClassKeyword) {
95  verifyFormat("SomeClass.class.getName();");
96  verifyFormat("Class c = SomeClass.class;");
97}
98
99TEST_F(FormatTestJava, ClassDeclarations) {
100  verifyFormat("public class SomeClass {\n"
101               "  private int a;\n"
102               "  private int b;\n"
103               "}");
104  verifyFormat("public class A {\n"
105               "  class B {\n"
106               "    int i;\n"
107               "  }\n"
108               "  class C {\n"
109               "    int j;\n"
110               "  }\n"
111               "}");
112  verifyFormat("public class A extends B.C {}");
113
114  verifyFormat("abstract class SomeClass\n"
115               "    extends SomeOtherClass implements SomeInterface {}",
116               getStyleWithColumns(60));
117  verifyFormat("abstract class SomeClass extends SomeOtherClass\n"
118               "    implements SomeInterfaceeeeeeeeeeeee {}",
119               getStyleWithColumns(60));
120  verifyFormat("abstract class SomeClass\n"
121               "    extends SomeOtherClass\n"
122               "    implements SomeInterface {}",
123               getStyleWithColumns(40));
124  verifyFormat("abstract class SomeClass\n"
125               "    extends SomeOtherClass\n"
126               "    implements SomeInterface,\n"
127               "               AnotherInterface {}",
128               getStyleWithColumns(40));
129  verifyFormat("abstract class SomeClass\n"
130               "    implements SomeInterface, AnotherInterface {}",
131               getStyleWithColumns(60));
132  verifyFormat("@SomeAnnotation()\n"
133               "abstract class aaaaaaaaaaaa\n"
134               "    extends bbbbbbbbbbbbbbb implements cccccccccccc {}",
135               getStyleWithColumns(76));
136  verifyFormat("@SomeAnnotation()\n"
137               "abstract class aaaaaaaaa<a>\n"
138               "    extends bbbbbbbbbbbb<b> implements cccccccccccc {}",
139               getStyleWithColumns(76));
140  verifyFormat("interface SomeInterface<A> extends Foo, Bar {\n"
141               "  void doStuff(int theStuff);\n"
142               "  void doMoreStuff(int moreStuff);\n"
143               "}");
144  verifyFormat("public interface SomeInterface {\n"
145               "  void doStuff(int theStuff);\n"
146               "  void doMoreStuff(int moreStuff);\n"
147               "  default void doStuffWithDefault() {}\n"
148               "}");
149  verifyFormat("@interface SomeInterface {\n"
150               "  void doStuff(int theStuff);\n"
151               "  void doMoreStuff(int moreStuff);\n"
152               "}");
153  verifyFormat("public @interface SomeInterface {\n"
154               "  void doStuff(int theStuff);\n"
155               "  void doMoreStuff(int moreStuff);\n"
156               "}");
157  verifyFormat("class A {\n"
158               "  public @interface SomeInterface {\n"
159               "    int stuff;\n"
160               "    void doMoreStuff(int moreStuff);\n"
161               "  }\n"
162               "}");
163  verifyFormat("class A {\n"
164               "  public @interface SomeInterface {}\n"
165               "}");
166}
167
168TEST_F(FormatTestJava, AnonymousClasses) {
169  verifyFormat("return new A() {\n"
170               "  public String toString() {\n"
171               "    return \"NotReallyA\";\n"
172               "  }\n"
173               "};");
174  verifyFormat("A a = new A() {\n"
175               "  public String toString() {\n"
176               "    return \"NotReallyA\";\n"
177               "  }\n"
178               "};");
179}
180
181TEST_F(FormatTestJava, EnumDeclarations) {
182  verifyFormat("enum SomeThing { ABC, CDE }");
183  verifyFormat("enum SomeThing {\n"
184               "  ABC,\n"
185               "  CDE,\n"
186               "}");
187  verifyFormat("public class SomeClass {\n"
188               "  enum SomeThing { ABC, CDE }\n"
189               "  void f() {}\n"
190               "}");
191  verifyFormat("public class SomeClass implements SomeInterface {\n"
192               "  enum SomeThing { ABC, CDE }\n"
193               "  void f() {}\n"
194               "}");
195  verifyFormat("enum SomeThing {\n"
196               "  ABC,\n"
197               "  CDE;\n"
198               "  void f() {}\n"
199               "}");
200  verifyFormat("enum SomeThing {\n"
201               "  ABC(1, \"ABC\"),\n"
202               "  CDE(2, \"CDE\");\n"
203               "  Something(int i, String s) {}\n"
204               "}");
205  verifyFormat("enum SomeThing {\n"
206               "  ABC(new int[] {1, 2}),\n"
207               "  CDE(new int[] {2, 3});\n"
208               "  Something(int[] i) {}\n"
209               "}");
210  verifyFormat("public enum SomeThing {\n"
211               "  ABC {\n"
212               "    public String toString() {\n"
213               "      return \"ABC\";\n"
214               "    }\n"
215               "  },\n"
216               "  CDE {\n"
217               "    @Override\n"
218               "    public String toString() {\n"
219               "      return \"CDE\";\n"
220               "    }\n"
221               "  };\n"
222               "  public void f() {}\n"
223               "}");
224  verifyFormat("private enum SomeEnum implements Foo<?, B> {\n"
225               "  ABC {\n"
226               "    @Override\n"
227               "    public String toString() {\n"
228               "      return \"ABC\";\n"
229               "    }\n"
230               "  },\n"
231               "  CDE {\n"
232               "    @Override\n"
233               "    public String toString() {\n"
234               "      return \"CDE\";\n"
235               "    }\n"
236               "  };\n"
237               "}");
238  verifyFormat("public enum VeryLongEnum {\n"
239               "  ENUM_WITH_MANY_PARAMETERS(\n"
240               "      \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\", \"bbbbbbbbbbbbbbbb\", "
241               "\"cccccccccccccccccccccccc\"),\n"
242               "  SECOND_ENUM(\"a\", \"b\", \"c\");\n"
243               "  private VeryLongEnum(String a, String b, String c) {}\n"
244               "}\n");
245}
246
247TEST_F(FormatTestJava, ArrayInitializers) {
248  verifyFormat("new int[] {1, 2, 3, 4};");
249  verifyFormat("new int[] {\n"
250               "    1,\n"
251               "    2,\n"
252               "    3,\n"
253               "    4,\n"
254               "};");
255
256  FormatStyle Style = getStyleWithColumns(65);
257  Style.Cpp11BracedListStyle = false;
258  verifyFormat(
259      "expected = new int[] { 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,\n"
260      "  100, 100, 100, 100, 100, 100, 100, 100, 100, 100 };",
261      Style);
262}
263
264TEST_F(FormatTestJava, ThrowsDeclarations) {
265  verifyFormat("public void doSooooooooooooooooooooooooooomething()\n"
266               "    throws LooooooooooooooooooooooooooooongException {}");
267  verifyFormat("public void doSooooooooooooooooooooooooooomething()\n"
268               "    throws LoooooooooongException, LooooooooooongException {}");
269}
270
271TEST_F(FormatTestJava, Annotations) {
272  verifyFormat("@Override\n"
273               "public String toString() {}");
274  verifyFormat("@Override\n"
275               "@Nullable\n"
276               "public String getNameIfPresent() {}");
277  verifyFormat("@Override // comment\n"
278               "@Nullable\n"
279               "public String getNameIfPresent() {}");
280  verifyFormat("@java.lang.Override // comment\n"
281               "@Nullable\n"
282               "public String getNameIfPresent() {}");
283
284  verifyFormat("@SuppressWarnings(value = \"unchecked\")\n"
285               "public void doSomething() {}");
286  verifyFormat("@SuppressWarnings(value = \"unchecked\")\n"
287               "@Author(name = \"abc\")\n"
288               "public void doSomething() {}");
289
290  verifyFormat("DoSomething(new A() {\n"
291               "  @Override\n"
292               "  public String toString() {}\n"
293               "});");
294
295  verifyFormat("void SomeFunction(@Nullable String something) {}");
296  verifyFormat("void SomeFunction(@org.llvm.Nullable String something) {}");
297
298  verifyFormat("@Partial @Mock DataLoader loader;");
299  verifyFormat("@Partial\n"
300               "@Mock\n"
301               "DataLoader loader;",
302               getChromiumStyle(FormatStyle::LK_Java));
303  verifyFormat("@SuppressWarnings(value = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\")\n"
304               "public static int iiiiiiiiiiiiiiiiiiiiiiii;");
305
306  verifyFormat("@SomeAnnotation(\"With some really looooooooooooooong text\")\n"
307               "private static final long something = 0L;");
308  verifyFormat("@org.llvm.Qualified(\"With some really looooooooooong text\")\n"
309               "private static final long something = 0L;");
310  verifyFormat("@Mock\n"
311               "DataLoader loooooooooooooooooooooooader =\n"
312               "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
313               getStyleWithColumns(60));
314  verifyFormat("@org.llvm.QualifiedMock\n"
315               "DataLoader loooooooooooooooooooooooader =\n"
316               "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
317               getStyleWithColumns(60));
318  verifyFormat("@Test(a)\n"
319               "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
320               "    aaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa);");
321  verifyFormat("@SomeAnnotation(\n"
322               "    aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa)\n"
323               "int i;",
324               getStyleWithColumns(50));
325  verifyFormat("@Test\n"
326               "ReturnType doSomething(\n"
327               "    String aaaaaaaaaaaaa, String bbbbbbbbbbbbbbb) {}",
328               getStyleWithColumns(60));
329  verifyFormat("{\n"
330               "  boolean someFunction(\n"
331               "      @Param(aaaaaaaaaaaaaaaa) String aaaaa,\n"
332               "      String bbbbbbbbbbbbbbb) {}\n"
333               "}",
334               getStyleWithColumns(60));
335  verifyFormat("@Annotation(\"Some\"\n"
336               "    + \" text\")\n"
337               "List<Integer> list;");
338}
339
340TEST_F(FormatTestJava, Generics) {
341  verifyFormat("Iterable<?> a;");
342  verifyFormat("Iterable<?> a;");
343  verifyFormat("Iterable<? extends SomeObject> a;");
344
345  verifyFormat("A.<B>doSomething();");
346  verifyFormat("A.<B<C>>doSomething();");
347  verifyFormat("A.<B<C<D>>>doSomething();");
348  verifyFormat("A.<B<C<D<E>>>>doSomething();");
349
350  verifyFormat("OrderedPair<String, List<Box<Integer>>> p = null;");
351
352  verifyFormat("@Override\n"
353               "public Map<String, ?> getAll() {}");
354
355  verifyFormat("public <R> ArrayList<R> get() {}");
356  verifyFormat("protected <R> ArrayList<R> get() {}");
357  verifyFormat("private <R> ArrayList<R> get() {}");
358  verifyFormat("public static <R> ArrayList<R> get() {}");
359  verifyFormat("public static native <R> ArrayList<R> get();");
360  verifyFormat("public final <X> Foo foo() {}");
361  verifyFormat("public abstract <X> Foo foo();");
362  verifyFormat("<T extends B> T getInstance(Class<T> type);");
363  verifyFormat("Function<F, ? extends T> function;");
364
365  verifyFormat("private Foo<X, Y>[] foos;");
366  verifyFormat("Foo<X, Y>[] foos = this.foos;");
367  verifyFormat("return (a instanceof List<?>)\n"
368               "    ? aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n"
369               "    : aaaaaaaaaaaaaaaaaaaaaaa;",
370               getStyleWithColumns(60));
371
372  verifyFormat(
373      "SomeLoooooooooooooooooooooongType name =\n"
374      "    SomeType.foo(someArgument)\n"
375      "        .<X>method()\n"
376      "        .aaaaaaaaaaaaaaaaaaa()\n"
377      "        .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
378}
379
380TEST_F(FormatTestJava, StringConcatenation) {
381  verifyFormat("String someString = \"abc\"\n"
382               "    + \"cde\";");
383}
384
385TEST_F(FormatTestJava, TryCatchFinally) {
386  verifyFormat("try {\n"
387               "  Something();\n"
388               "} catch (SomeException e) {\n"
389               "  HandleException(e);\n"
390               "}");
391  verifyFormat("try {\n"
392               "  Something();\n"
393               "} finally {\n"
394               "  AlwaysDoThis();\n"
395               "}");
396  verifyFormat("try {\n"
397               "  Something();\n"
398               "} catch (SomeException e) {\n"
399               "  HandleException(e);\n"
400               "} finally {\n"
401               "  AlwaysDoThis();\n"
402               "}");
403
404  verifyFormat("try {\n"
405               "  Something();\n"
406               "} catch (SomeException | OtherException e) {\n"
407               "  HandleException(e);\n"
408               "}");
409}
410
411TEST_F(FormatTestJava, TryWithResources) {
412  verifyFormat("try (SomeResource rs = someFunction()) {\n"
413               "  Something();\n"
414               "}");
415  verifyFormat("try (SomeResource rs = someFunction()) {\n"
416               "  Something();\n"
417               "} catch (SomeException e) {\n"
418               "  HandleException(e);\n"
419               "}");
420}
421
422TEST_F(FormatTestJava, SynchronizedKeyword) {
423  verifyFormat("synchronized (mData) {\n"
424               "  // ...\n"
425               "}");
426}
427
428TEST_F(FormatTestJava, AssertKeyword) {
429  verifyFormat("assert a && b;");
430  verifyFormat("assert (a && b);");
431}
432
433TEST_F(FormatTestJava, PackageDeclarations) {
434  verifyFormat("package some.really.loooooooooooooooooooooong.package;",
435               getStyleWithColumns(50));
436}
437
438TEST_F(FormatTestJava, ImportDeclarations) {
439  verifyFormat("import some.really.loooooooooooooooooooooong.imported.Class;",
440               getStyleWithColumns(50));
441  verifyFormat("import static some.really.looooooooooooooooong.imported.Class;",
442               getStyleWithColumns(50));
443}
444
445TEST_F(FormatTestJava, MethodDeclarations) {
446  verifyFormat("void methodName(Object arg1,\n"
447               "    Object arg2, Object arg3) {}",
448               getStyleWithColumns(40));
449  verifyFormat("void methodName(\n"
450               "    Object arg1, Object arg2) {}",
451               getStyleWithColumns(40));
452}
453
454TEST_F(FormatTestJava, MethodReference) {
455  EXPECT_EQ(
456      "private void foo() {\n"
457      "  f(this::methodReference);\n"
458      "  f(C.super::methodReference);\n"
459      "  Consumer<String> c = System.out::println;\n"
460      "  Iface<Integer> mRef = Ty::<Integer>meth;\n"
461      "}",
462      format("private void foo() {\n"
463             "  f(this ::methodReference);\n"
464             "  f(C.super ::methodReference);\n"
465             "  Consumer<String> c = System.out ::println;\n"
466             "  Iface<Integer> mRef = Ty :: <Integer> meth;\n"
467             "}"));
468}
469
470TEST_F(FormatTestJava, CppKeywords) {
471  verifyFormat("public void union(Type a, Type b);");
472  verifyFormat("public void struct(Object o);");
473  verifyFormat("public void delete(Object o);");
474  verifyFormat("return operator && (aa);");
475}
476
477TEST_F(FormatTestJava, NeverAlignAfterReturn) {
478  verifyFormat("return aaaaaaaaaaaaaaaaaaa\n"
479               "    && bbbbbbbbbbbbbbbbbbb\n"
480               "    && ccccccccccccccccccc;",
481               getStyleWithColumns(40));
482  verifyFormat("return (result == null)\n"
483               "    ? aaaaaaaaaaaaaaaaa\n"
484               "    : bbbbbbbbbbbbbbbbb;",
485               getStyleWithColumns(40));
486  verifyFormat("return aaaaaaaaaaaaaaaaaaa()\n"
487               "    .bbbbbbbbbbbbbbbbbbb()\n"
488               "    .ccccccccccccccccccc();",
489               getStyleWithColumns(40));
490  verifyFormat("return aaaaaaaaaaaaaaaaaaa()\n"
491               "    .bbbbbbbbbbbbbbbbbbb(\n"
492               "        ccccccccccccccc)\n"
493               "    .ccccccccccccccccccc();",
494               getStyleWithColumns(40));
495}
496
497TEST_F(FormatTestJava, FormatsInnerBlocks) {
498  verifyFormat("someObject.someFunction(new Runnable() {\n"
499               "  @Override\n"
500               "  public void run() {\n"
501               "    System.out.println(42);\n"
502               "  }\n"
503               "}, someOtherParameter);");
504  verifyFormat("someFunction(new Runnable() {\n"
505               "  public void run() {\n"
506               "    System.out.println(42);\n"
507               "  }\n"
508               "});");
509  verifyFormat("someObject.someFunction(\n"
510               "    new Runnable() {\n"
511               "      @Override\n"
512               "      public void run() {\n"
513               "        System.out.println(42);\n"
514               "      }\n"
515               "    },\n"
516               "    new Runnable() {\n"
517               "      @Override\n"
518               "      public void run() {\n"
519               "        System.out.println(43);\n"
520               "      }\n"
521               "    },\n"
522               "    someOtherParameter);");
523}
524
525TEST_F(FormatTestJava, FormatsLambdas) {
526  verifyFormat("(aaaaaaaaaa, bbbbbbbbbb) -> aaaaaaaaaa + bbbbbbbbbb;");
527  verifyFormat("(aaaaaaaaaa, bbbbbbbbbb)\n"
528               "    -> aaaaaaaaaa + bbbbbbbbbb;",
529               getStyleWithColumns(40));
530  verifyFormat("Runnable someLambda = () -> DoSomething();");
531  verifyFormat("Runnable someLambda = () -> {\n"
532               "  DoSomething();\n"
533               "}");
534
535  verifyFormat("Runnable someLambda =\n"
536               "    (int aaaaa) -> DoSomething(aaaaa);",
537               getStyleWithColumns(40));
538}
539
540TEST_F(FormatTestJava, BreaksStringLiterals) {
541  // FIXME: String literal breaking is currently disabled for Java and JS, as it
542  // requires strings to be merged using "+" which we don't support.
543  EXPECT_EQ("\"some text other\";",
544            format("\"some text other\";", getStyleWithColumns(14)));
545}
546
547TEST_F(FormatTestJava, AlignsBlockComments) {
548  EXPECT_EQ("/*\n"
549            " * Really multi-line\n"
550            " * comment.\n"
551            " */\n"
552            "void f() {}",
553            format("  /*\n"
554                   "   * Really multi-line\n"
555                   "   * comment.\n"
556                   "   */\n"
557                   "  void f() {}"));
558}
559
560TEST_F(FormatTestJava, KeepsDelimitersOnOwnLineInJavaDocComments) {
561  EXPECT_EQ("/**\n"
562            " * javadoc line 1\n"
563            " * javadoc line 2\n"
564            " */",
565            format("/** javadoc line 1\n"
566                   " * javadoc line 2 */"));
567}
568
569TEST_F(FormatTestJava, RetainsLogicalShifts) {
570    verifyFormat("void f() {\n"
571                 "  int a = 1;\n"
572                 "  a >>>= 1;\n"
573                 "}");
574    verifyFormat("void f() {\n"
575                 "  int a = 1;\n"
576                 "  a = a >>> 1;\n"
577                 "}");
578}
579
580
581} // end namespace tooling
582} // end namespace clang
583
CodeThinker, Enjoy your reading code