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 "FormatTestBase.h"
10
11 #define DEBUG_TYPE "format-test"
12
13 namespace clang {
14 namespace format {
15 namespace test {
16 namespace {
17
18 class FormatTestJava : public test::FormatTestBase {
19 protected:
getDefaultStyle() const20 FormatStyle getDefaultStyle() const override {
21 return getGoogleStyle(FormatStyle::LK_Java);
22 }
23
getStyleWithColumns(unsigned ColumnLimit)24 static FormatStyle getStyleWithColumns(unsigned ColumnLimit) {
25 FormatStyle Style = getGoogleStyle(FormatStyle::LK_Java);
26 Style.ColumnLimit = ColumnLimit;
27 return Style;
28 }
29 };
30
TEST_F(FormatTestJava,NoAlternativeOperatorNames)31 TEST_F(FormatTestJava, NoAlternativeOperatorNames) {
32 verifyFormat("someObject.and();");
33 }
34
TEST_F(FormatTestJava,UnderstandsCasts)35 TEST_F(FormatTestJava, UnderstandsCasts) {
36 verifyFormat("a[b >> 1] = (byte) (c() << 4);");
37 }
38
TEST_F(FormatTestJava,FormatsInstanceOfLikeOperators)39 TEST_F(FormatTestJava, FormatsInstanceOfLikeOperators) {
40 FormatStyle Style = getStyleWithColumns(50);
41 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
42 " instanceof bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;",
43 Style);
44 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
45 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaa instanceof\n"
46 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;",
47 Style);
48 verifyFormat("return aaaaaaaaaaaaaaaaaaa instanceof bbbbbbbbbbbbbbbbbbbbbbb\n"
49 " && ccccccccccccccccccc instanceof dddddddddddddddddddddd;");
50 }
51
TEST_F(FormatTestJava,Chromium)52 TEST_F(FormatTestJava, Chromium) {
53 verifyFormat("class SomeClass {\n"
54 " void f() {}\n"
55 " int g() {\n"
56 " return 0;\n"
57 " }\n"
58 " void h() {\n"
59 " while (true) f();\n"
60 " for (;;) f();\n"
61 " if (true) f();\n"
62 " }\n"
63 "}",
64 getChromiumStyle(FormatStyle::LK_Java));
65 }
66
TEST_F(FormatTestJava,QualifiedNames)67 TEST_F(FormatTestJava, QualifiedNames) {
68 verifyFormat("public some.package.Type someFunction( // comment\n"
69 " int parameter) {}");
70 }
71
TEST_F(FormatTestJava,ClassKeyword)72 TEST_F(FormatTestJava, ClassKeyword) {
73 verifyFormat("SomeClass.class.getName();");
74 verifyFormat("Class c = SomeClass.class;");
75 }
76
TEST_F(FormatTestJava,ClassDeclarations)77 TEST_F(FormatTestJava, ClassDeclarations) {
78 verifyFormat("public class SomeClass {\n"
79 " private int a;\n"
80 " private int b;\n"
81 "}");
82 verifyFormat("public class A {\n"
83 " class B {\n"
84 " int i;\n"
85 " }\n"
86 " class C {\n"
87 " int j;\n"
88 " }\n"
89 "}");
90 verifyFormat("public class A extends B.C {}");
91
92 verifyFormat("abstract class SomeClass\n"
93 " extends SomeOtherClass implements SomeInterface {}",
94 getStyleWithColumns(60));
95 verifyFormat("abstract class SomeClass extends SomeOtherClass\n"
96 " implements SomeInterfaceeeeeeeeeeeee {}",
97 getStyleWithColumns(60));
98 verifyFormat("abstract class SomeClass\n"
99 " extends SomeOtherClass\n"
100 " implements SomeInterface {}",
101 getStyleWithColumns(40));
102 verifyFormat("abstract class SomeClass\n"
103 " extends SomeOtherClass\n"
104 " implements SomeInterface,\n"
105 " AnotherInterface {}",
106 getStyleWithColumns(40));
107 verifyFormat("abstract class SomeClass\n"
108 " implements SomeInterface, AnotherInterface {}",
109 getStyleWithColumns(60));
110 verifyFormat("@SomeAnnotation()\n"
111 "abstract class aaaaaaaaaaaa\n"
112 " extends bbbbbbbbbbbbbbb implements cccccccccccc {}",
113 getStyleWithColumns(76));
114 verifyFormat("@SomeAnnotation()\n"
115 "abstract class aaaaaaaaa<a>\n"
116 " extends bbbbbbbbbbbb<b> implements cccccccccccc {}",
117 getStyleWithColumns(76));
118 verifyFormat("interface SomeInterface<A> extends Foo, Bar {\n"
119 " void doStuff(int theStuff);\n"
120 " void doMoreStuff(int moreStuff);\n"
121 "}");
122 verifyFormat("public interface SomeInterface {\n"
123 " void doStuff(int theStuff);\n"
124 " void doMoreStuff(int moreStuff);\n"
125 " default void doStuffWithDefault() {}\n"
126 "}");
127 verifyFormat("@interface SomeInterface {\n"
128 " void doStuff(int theStuff);\n"
129 " void doMoreStuff(int moreStuff);\n"
130 "}");
131 verifyFormat("public @interface SomeInterface {\n"
132 " void doStuff(int theStuff);\n"
133 " void doMoreStuff(int moreStuff);\n"
134 "}");
135 verifyFormat("class A {\n"
136 " public @interface SomeInterface {\n"
137 " int stuff;\n"
138 " void doMoreStuff(int moreStuff);\n"
139 " }\n"
140 "}");
141 verifyFormat("class A {\n"
142 " public @interface SomeInterface {}\n"
143 "}");
144 }
145
TEST_F(FormatTestJava,AnonymousClasses)146 TEST_F(FormatTestJava, AnonymousClasses) {
147 verifyFormat("return new A() {\n"
148 " public String toString() {\n"
149 " return \"NotReallyA\";\n"
150 " }\n"
151 "};");
152 verifyFormat("A a = new A() {\n"
153 " public String toString() {\n"
154 " return \"NotReallyA\";\n"
155 " }\n"
156 "};");
157 }
158
TEST_F(FormatTestJava,EnumDeclarations)159 TEST_F(FormatTestJava, EnumDeclarations) {
160 verifyFormat("enum SomeThing { ABC, CDE }");
161 verifyFormat("enum SomeThing {\n"
162 " ABC,\n"
163 " CDE,\n"
164 "}");
165 verifyFormat("public class SomeClass {\n"
166 " enum SomeThing { ABC, CDE }\n"
167 " void f() {}\n"
168 "}");
169 verifyFormat("public class SomeClass implements SomeInterface {\n"
170 " enum SomeThing { ABC, CDE }\n"
171 " void f() {}\n"
172 "}");
173 verifyFormat("enum SomeThing {\n"
174 " ABC,\n"
175 " CDE;\n"
176 " void f() {}\n"
177 "}");
178 verifyFormat("enum SomeThing {\n"
179 " void f() {}");
180 verifyFormat("enum SomeThing {\n"
181 " ABC(1, \"ABC\"),\n"
182 " CDE(2, \"CDE\");\n"
183 " Something(int i, String s) {}\n"
184 "}");
185 verifyFormat("enum SomeThing {\n"
186 " ABC(new int[] {1, 2}),\n"
187 " CDE(new int[] {2, 3});\n"
188 " Something(int[] i) {}\n"
189 "}");
190 verifyFormat("public enum SomeThing {\n"
191 " ABC {\n"
192 " public String toString() {\n"
193 " return \"ABC\";\n"
194 " }\n"
195 " },\n"
196 " CDE {\n"
197 " @Override\n"
198 " public String toString() {\n"
199 " return \"CDE\";\n"
200 " }\n"
201 " };\n"
202 " public void f() {}\n"
203 "}");
204 verifyFormat("private enum SomeEnum implements Foo<?, B> {\n"
205 " ABC {\n"
206 " @Override\n"
207 " public String toString() {\n"
208 " return \"ABC\";\n"
209 " }\n"
210 " },\n"
211 " CDE {\n"
212 " @Override\n"
213 " public String toString() {\n"
214 " return \"CDE\";\n"
215 " }\n"
216 " };\n"
217 "}");
218 verifyFormat("public enum VeryLongEnum {\n"
219 " ENUM_WITH_MANY_PARAMETERS(\n"
220 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\", \"bbbbbbbbbbbbbbbb\", "
221 "\"cccccccccccccccccccccccc\"),\n"
222 " SECOND_ENUM(\"a\", \"b\", \"c\");\n"
223 " private VeryLongEnum(String a, String b, String c) {}\n"
224 "}");
225 }
226
TEST_F(FormatTestJava,ArrayInitializers)227 TEST_F(FormatTestJava, ArrayInitializers) {
228 verifyFormat("new int[] {1, 2, 3, 4};");
229 verifyFormat("new int[] {\n"
230 " 1,\n"
231 " 2,\n"
232 " 3,\n"
233 " 4,\n"
234 "};");
235
236 FormatStyle Style = getStyleWithColumns(65);
237 Style.Cpp11BracedListStyle = false;
238 verifyFormat(
239 "expected = new int[] { 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,\n"
240 " 100, 100, 100, 100, 100, 100, 100, 100, 100, 100 };",
241 Style);
242 }
243
TEST_F(FormatTestJava,ThrowsDeclarations)244 TEST_F(FormatTestJava, ThrowsDeclarations) {
245 verifyFormat("public void doSooooooooooooooooooooooooooomething()\n"
246 " throws LooooooooooooooooooooooooooooongException {}");
247 verifyFormat("public void doSooooooooooooooooooooooooooomething()\n"
248 " throws LoooooooooongException, LooooooooooongException {}");
249 }
250
TEST_F(FormatTestJava,Annotations)251 TEST_F(FormatTestJava, Annotations) {
252 verifyFormat("@Override\n"
253 "public String toString() {}");
254 verifyFormat("@Override\n"
255 "@Nullable\n"
256 "public String getNameIfPresent() {}");
257 verifyFormat("@Override // comment\n"
258 "@Nullable\n"
259 "public String getNameIfPresent() {}");
260 verifyFormat("@java.lang.Override // comment\n"
261 "@Nullable\n"
262 "public String getNameIfPresent() {}");
263
264 verifyFormat("@SuppressWarnings(value = \"unchecked\")\n"
265 "public void doSomething() {}");
266 verifyFormat("@SuppressWarnings(value = \"unchecked\")\n"
267 "@Author(name = \"abc\")\n"
268 "public void doSomething() {}");
269
270 verifyFormat("DoSomething(new A() {\n"
271 " @Override\n"
272 " public String toString() {}\n"
273 "});");
274
275 verifyFormat("void SomeFunction(@Nullable String something) {}");
276 verifyFormat("void SomeFunction(@org.llvm.Nullable String something) {}");
277
278 verifyFormat("@Partial @Mock DataLoader loader;");
279 verifyFormat("@Partial\n"
280 "@Mock\n"
281 "DataLoader loader;",
282 getChromiumStyle(FormatStyle::LK_Java));
283 verifyFormat("@SuppressWarnings(value = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\")\n"
284 "public static int iiiiiiiiiiiiiiiiiiiiiiii;");
285
286 verifyFormat("@SomeAnnotation(\"With some really looooooooooooooong text\")\n"
287 "private static final long something = 0L;");
288 verifyFormat("@org.llvm.Qualified(\"With some really looooooooooong text\")\n"
289 "private static final long something = 0L;");
290 verifyFormat("@Mock\n"
291 "DataLoader loooooooooooooooooooooooader =\n"
292 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
293 getStyleWithColumns(60));
294 verifyFormat("@org.llvm.QualifiedMock\n"
295 "DataLoader loooooooooooooooooooooooader =\n"
296 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
297 getStyleWithColumns(60));
298 verifyFormat("@Test(a)\n"
299 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
300 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa);");
301 verifyFormat("@SomeAnnotation(\n"
302 " aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa)\n"
303 "int i;",
304 getStyleWithColumns(50));
305 verifyFormat("@Test\n"
306 "ReturnType doSomething(\n"
307 " String aaaaaaaaaaaaa, String bbbbbbbbbbbbbbb) {}",
308 getStyleWithColumns(60));
309 verifyFormat("{\n"
310 " boolean someFunction(\n"
311 " @Param(aaaaaaaaaaaaaaaa) String aaaaa,\n"
312 " String bbbbbbbbbbbbbbb) {}\n"
313 "}",
314 getStyleWithColumns(60));
315 verifyFormat("@Annotation(\"Some\"\n"
316 " + \" text\")\n"
317 "List<Integer> list;");
318
319 verifyFormat(
320 "@Test\n"
321 "@Feature({\"Android-TabSwitcher\"})\n"
322 "@CommandLineFlags.Add({ChromeSwitches.DISABLE_FIRST_RUN_EXPERIENCE})\n"
323 "@Features.EnableFeatures({FEATURE})\n"
324 "public void test(@Foo.bar(\"baz\") @Quux.Qoob int theFirstParaaaaam,\n"
325 " @Foo.bar(\"baz\") @Quux.Qoob int theSecondParaaaaaaaaaaaaaaaam) {}");
326 }
327
TEST_F(FormatTestJava,Generics)328 TEST_F(FormatTestJava, Generics) {
329 verifyFormat("Iterable<?> a;");
330 verifyFormat("Iterable<?> a;");
331 verifyFormat("Iterable<? extends SomeObject> a;");
332
333 verifyFormat("A.<B>doSomething();");
334 verifyFormat("A.<B<C>>doSomething();");
335 verifyFormat("A.<B<C<D>>>doSomething();");
336 verifyFormat("A.<B<C<D<E>>>>doSomething();");
337
338 verifyFormat("OrderedPair<String, List<Box<Integer>>> p = null;");
339
340 verifyFormat("@Override\n"
341 "public Map<String, ?> getAll() {}");
342
343 verifyFormat("public <R> ArrayList<R> get() {}");
344 verifyFormat("protected <R> ArrayList<R> get() {}");
345 verifyFormat("private <R> ArrayList<R> get() {}");
346 verifyFormat("public static <R> ArrayList<R> get() {}");
347 verifyFormat("public static native <R> ArrayList<R> get();");
348 verifyFormat("public final <X> Foo foo() {}");
349 verifyFormat("public abstract <X> Foo foo();");
350 verifyFormat("<T extends B> T getInstance(Class<T> type);");
351 verifyFormat("Function<F, ? extends T> function;");
352
353 verifyFormat("private Foo<X, Y>[] foos;");
354 verifyFormat("Foo<X, Y>[] foos = this.foos;");
355 verifyFormat("return (a instanceof List<?>)\n"
356 " ? aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n"
357 " : aaaaaaaaaaaaaaaaaaaaaaa;",
358 getStyleWithColumns(60));
359
360 verifyFormat(
361 "SomeLoooooooooooooooooooooongType name =\n"
362 " SomeType.foo(someArgument)\n"
363 " .<X>method()\n"
364 " .aaaaaaaaaaaaaaaaaaa()\n"
365 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
366 }
367
TEST_F(FormatTestJava,StringConcatenation)368 TEST_F(FormatTestJava, StringConcatenation) {
369 verifyFormat("String someString = \"abc\"\n"
370 " + \"cde\";");
371 }
372
TEST_F(FormatTestJava,TryCatchFinally)373 TEST_F(FormatTestJava, TryCatchFinally) {
374 verifyFormat("try {\n"
375 " Something();\n"
376 "} catch (SomeException e) {\n"
377 " HandleException(e);\n"
378 "}");
379 verifyFormat("try {\n"
380 " Something();\n"
381 "} finally {\n"
382 " AlwaysDoThis();\n"
383 "}");
384 verifyFormat("try {\n"
385 " Something();\n"
386 "} catch (SomeException e) {\n"
387 " HandleException(e);\n"
388 "} finally {\n"
389 " AlwaysDoThis();\n"
390 "}");
391
392 verifyFormat("try {\n"
393 " Something();\n"
394 "} catch (SomeException | OtherException e) {\n"
395 " HandleException(e);\n"
396 "}");
397 }
398
TEST_F(FormatTestJava,TryWithResources)399 TEST_F(FormatTestJava, TryWithResources) {
400 verifyFormat("try (SomeResource rs = someFunction()) {\n"
401 " Something();\n"
402 "}");
403 verifyFormat("try (SomeResource rs = someFunction()) {\n"
404 " Something();\n"
405 "} catch (SomeException e) {\n"
406 " HandleException(e);\n"
407 "}");
408 }
409
TEST_F(FormatTestJava,SynchronizedKeyword)410 TEST_F(FormatTestJava, SynchronizedKeyword) {
411 verifyFormat("synchronized (mData) {\n"
412 " // ...\n"
413 "}");
414
415 FormatStyle Style = getLLVMStyle(FormatStyle::LK_Java);
416 Style.BreakBeforeBraces = FormatStyle::BS_Custom;
417
418 Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always;
419 Style.BraceWrapping.AfterFunction = false;
420 verifyFormat("synchronized (mData)\n"
421 "{\n"
422 " // ...\n"
423 "}",
424 Style);
425
426 Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Never;
427 Style.BraceWrapping.AfterFunction = true;
428 verifyFormat("synchronized (mData) {\n"
429 " // ...\n"
430 "}",
431 Style);
432 }
433
TEST_F(FormatTestJava,AssertKeyword)434 TEST_F(FormatTestJava, AssertKeyword) {
435 verifyFormat("assert a && b;");
436 verifyFormat("assert (a && b);");
437 }
438
TEST_F(FormatTestJava,PackageDeclarations)439 TEST_F(FormatTestJava, PackageDeclarations) {
440 verifyFormat("package some.really.loooooooooooooooooooooong.package;",
441 getStyleWithColumns(50));
442 }
443
TEST_F(FormatTestJava,ImportDeclarations)444 TEST_F(FormatTestJava, ImportDeclarations) {
445 verifyFormat("import some.really.loooooooooooooooooooooong.imported.Class;",
446 getStyleWithColumns(50));
447 verifyFormat("import static some.really.looooooooooooooooong.imported.Class;",
448 getStyleWithColumns(50));
449 }
450
TEST_F(FormatTestJava,MethodDeclarations)451 TEST_F(FormatTestJava, MethodDeclarations) {
452 verifyFormat("void methodName(Object arg1,\n"
453 " Object arg2, Object arg3) {}",
454 getStyleWithColumns(40));
455 verifyFormat("void methodName(\n"
456 " Object arg1, Object arg2) {}",
457 getStyleWithColumns(40));
458 }
459
TEST_F(FormatTestJava,MethodReference)460 TEST_F(FormatTestJava, MethodReference) {
461 EXPECT_EQ("private void foo() {\n"
462 " f(this::methodReference);\n"
463 " f(C.super::methodReference);\n"
464 " Consumer<String> c = System.out::println;\n"
465 " Iface<Integer> mRef = Ty::<Integer>meth;\n"
466 "}",
467 format("private void foo() {\n"
468 " f(this ::methodReference);\n"
469 " f(C.super ::methodReference);\n"
470 " Consumer<String> c = System.out ::println;\n"
471 " Iface<Integer> mRef = Ty :: <Integer> meth;\n"
472 "}"));
473 }
474
TEST_F(FormatTestJava,CppKeywords)475 TEST_F(FormatTestJava, CppKeywords) {
476 verifyFormat("public void union(Type a, Type b);");
477 verifyFormat("public void struct(Object o);");
478 verifyFormat("public void delete(Object o);");
479 verifyFormat("return operator && (aa);");
480 }
481
TEST_F(FormatTestJava,NeverAlignAfterReturn)482 TEST_F(FormatTestJava, NeverAlignAfterReturn) {
483 verifyFormat("return aaaaaaaaaaaaaaaaaaa\n"
484 " && bbbbbbbbbbbbbbbbbbb\n"
485 " && ccccccccccccccccccc;",
486 getStyleWithColumns(40));
487 verifyFormat("return (result == null)\n"
488 " ? aaaaaaaaaaaaaaaaa\n"
489 " : bbbbbbbbbbbbbbbbb;",
490 getStyleWithColumns(40));
491 verifyFormat("return aaaaaaaaaaaaaaaaaaa()\n"
492 " .bbbbbbbbbbbbbbbbbbb()\n"
493 " .ccccccccccccccccccc();",
494 getStyleWithColumns(40));
495 verifyFormat("return aaaaaaaaaaaaaaaaaaa()\n"
496 " .bbbbbbbbbbbbbbbbbbb(\n"
497 " ccccccccccccccc)\n"
498 " .ccccccccccccccccccc();",
499 getStyleWithColumns(40));
500 }
501
TEST_F(FormatTestJava,FormatsInnerBlocks)502 TEST_F(FormatTestJava, FormatsInnerBlocks) {
503 verifyFormat("someObject.someFunction(new Runnable() {\n"
504 " @Override\n"
505 " public void run() {\n"
506 " System.out.println(42);\n"
507 " }\n"
508 "}, someOtherParameter);");
509 verifyFormat("someFunction(new Runnable() {\n"
510 " public void run() {\n"
511 " System.out.println(42);\n"
512 " }\n"
513 "});");
514 verifyFormat("someObject.someFunction(\n"
515 " new Runnable() {\n"
516 " @Override\n"
517 " public void run() {\n"
518 " System.out.println(42);\n"
519 " }\n"
520 " },\n"
521 " new Runnable() {\n"
522 " @Override\n"
523 " public void run() {\n"
524 " System.out.println(43);\n"
525 " }\n"
526 " },\n"
527 " someOtherParameter);");
528 }
529
TEST_F(FormatTestJava,FormatsLambdas)530 TEST_F(FormatTestJava, FormatsLambdas) {
531 verifyFormat("(aaaaaaaaaa, bbbbbbbbbb) -> aaaaaaaaaa + bbbbbbbbbb;");
532 verifyFormat("(aaaaaaaaaa, bbbbbbbbbb)\n"
533 " -> aaaaaaaaaa + bbbbbbbbbb;",
534 getStyleWithColumns(40));
535 verifyFormat("Runnable someLambda = () -> DoSomething();");
536 verifyFormat("Runnable someLambda = () -> {\n"
537 " DoSomething();\n"
538 "}");
539
540 verifyFormat("Runnable someLambda =\n"
541 " (int aaaaa) -> DoSomething(aaaaa);",
542 getStyleWithColumns(40));
543 }
544
TEST_F(FormatTestJava,BreaksStringLiterals)545 TEST_F(FormatTestJava, BreaksStringLiterals) {
546 verifyFormat("x = \"some text \"\n"
547 " + \"other\";",
548 "x = \"some text other\";", getStyleWithColumns(18));
549 }
550
TEST_F(FormatTestJava,AlignsBlockComments)551 TEST_F(FormatTestJava, AlignsBlockComments) {
552 EXPECT_EQ("/*\n"
553 " * Really multi-line\n"
554 " * comment.\n"
555 " */\n"
556 "void f() {}",
557 format(" /*\n"
558 " * Really multi-line\n"
559 " * comment.\n"
560 " */\n"
561 " void f() {}"));
562 }
563
TEST_F(FormatTestJava,AlignDeclarations)564 TEST_F(FormatTestJava, AlignDeclarations) {
565 FormatStyle Style = getLLVMStyle(FormatStyle::LK_Java);
566 Style.AlignConsecutiveDeclarations.Enabled = true;
567 verifyFormat("private final String[] args;\n"
568 "private final A_ParserHelper parserHelper;\n"
569 "private final int numOfCmdArgs;\n"
570 "private int numOfCmdArgs;\n"
571 "private String[] args;",
572 Style);
573 }
574
TEST_F(FormatTestJava,KeepsDelimitersOnOwnLineInJavaDocComments)575 TEST_F(FormatTestJava, KeepsDelimitersOnOwnLineInJavaDocComments) {
576 EXPECT_EQ("/**\n"
577 " * javadoc line 1\n"
578 " * javadoc line 2\n"
579 " */",
580 format("/** javadoc line 1\n"
581 " * javadoc line 2 */"));
582 }
583
TEST_F(FormatTestJava,RetainsLogicalShifts)584 TEST_F(FormatTestJava, RetainsLogicalShifts) {
585 verifyFormat("void f() {\n"
586 " int a = 1;\n"
587 " a >>>= 1;\n"
588 "}");
589 verifyFormat("void f() {\n"
590 " int a = 1;\n"
591 " a = a >>> 1;\n"
592 "}");
593 }
594
TEST_F(FormatTestJava,ShortFunctions)595 TEST_F(FormatTestJava, ShortFunctions) {
596 FormatStyle Style = getLLVMStyle(FormatStyle::LK_Java);
597 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
598 verifyFormat("enum Enum {\n"
599 " E1,\n"
600 " E2;\n"
601 " void f() { return; }\n"
602 "}",
603 Style);
604 }
605
TEST_F(FormatTestJava,ConfigurableSpacesInSquareBrackets)606 TEST_F(FormatTestJava, ConfigurableSpacesInSquareBrackets) {
607 FormatStyle Spaces = getLLVMStyle(FormatStyle::LK_Java);
608
609 verifyFormat("Object[] arguments", Spaces);
610 verifyFormat("final Class<?>[] types = new Class<?>[numElements];", Spaces);
611 verifyFormat("types[i] = arguments[i].getClass();", Spaces);
612
613 Spaces.SpacesInSquareBrackets = true;
614
615 verifyFormat("Object[ ] arguments", Spaces);
616 verifyFormat("final Class<?>[ ] types = new Class<?>[ numElements ];",
617 Spaces);
618 verifyFormat("types[ i ] = arguments[ i ].getClass();", Spaces);
619 }
620
TEST_F(FormatTestJava,SwitchExpression)621 TEST_F(FormatTestJava, SwitchExpression) {
622 auto Style = getLLVMStyle(FormatStyle::LK_Java);
623 EXPECT_TRUE(Style.AllowShortCaseExpressionOnASingleLine);
624
625 verifyFormat("foo(switch (day) {\n"
626 " case THURSDAY, SATURDAY -> 8;\n"
627 " case WEDNESDAY -> 9;\n"
628 " default -> 1;\n"
629 "});",
630 Style);
631
632 constexpr StringRef Code1{"i = switch (day) {\n"
633 " case THURSDAY, SATURDAY -> 8;\n"
634 " case WEDNESDAY -> 9;\n"
635 " default -> 0;\n"
636 "};"};
637 verifyFormat(Code1, Style);
638
639 Style.IndentCaseLabels = true;
640 verifyFormat(Code1, Style);
641
642 constexpr StringRef Code2{"i = switch (day) {\n"
643 " case THURSDAY, SATURDAY -> {\n"
644 " foo();\n"
645 " yield 8;\n"
646 " }\n"
647 " case WEDNESDAY -> {\n"
648 " bar();\n"
649 " yield 9;\n"
650 " }\n"
651 " default -> {\n"
652 " yield 0;\n"
653 " }\n"
654 "};"};
655 verifyFormat(Code2, Style);
656
657 Style.IndentCaseLabels = false;
658 verifyFormat(Code2, Style);
659
660 constexpr StringRef Code3{"switch (day) {\n"
661 "case THURSDAY, SATURDAY -> i = 8;\n"
662 "case WEDNESDAY -> i = 9;\n"
663 "default -> i = 0;\n"
664 "};"};
665 verifyFormat(Code3, Style);
666
667 Style.IndentCaseLabels = true;
668 verifyFormat("switch (day) {\n"
669 " case THURSDAY, SATURDAY -> i = 8;\n"
670 " case WEDNESDAY -> i = 9;\n"
671 " default -> i = 0;\n"
672 "};",
673 Code3, Style);
674 }
675
TEST_F(FormatTestJava,ShortCaseExpression)676 TEST_F(FormatTestJava, ShortCaseExpression) {
677 auto Style = getLLVMStyle(FormatStyle::LK_Java);
678
679 verifyFormat("i = switch (a) {\n"
680 " case 1 -> 1;\n"
681 " case 2 -> // comment\n"
682 " 2;\n"
683 " case 3 ->\n"
684 " // comment\n"
685 " 3;\n"
686 " case 4 -> 4; // comment\n"
687 " default -> 0;\n"
688 "};",
689 Style);
690
691 verifyNoChange("i = switch (a) {\n"
692 " case 1 -> 1;\n"
693 " // comment\n"
694 " case 2 -> 2;\n"
695 " // comment 1\n"
696 " // comment 2\n"
697 " case 3 -> 3; /* comment */\n"
698 " case 4 -> /* comment */ 4;\n"
699 " case 5 -> x + /* comment */ 1;\n"
700 " default ->\n"
701 " 0; // comment line 1\n"
702 " // comment line 2\n"
703 "};",
704 Style);
705
706 Style.ColumnLimit = 18;
707 verifyFormat("i = switch (a) {\n"
708 " case Monday ->\n"
709 " 1;\n"
710 " default -> 9999;\n"
711 "};",
712 Style);
713
714 Style.ColumnLimit = 80;
715 Style.AllowShortCaseExpressionOnASingleLine = false;
716 Style.IndentCaseLabels = true;
717 verifyFormat("i = switch (n) {\n"
718 " default /*comments*/ ->\n"
719 " 1;\n"
720 " case 0 ->\n"
721 " 0;\n"
722 "};",
723 Style);
724
725 Style.AllowShortCaseExpressionOnASingleLine = true;
726 Style.BreakBeforeBraces = FormatStyle::BS_Custom;
727 Style.BraceWrapping.AfterCaseLabel = true;
728 Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always;
729 verifyFormat("i = switch (n)\n"
730 "{\n"
731 " case 0 ->\n"
732 " {\n"
733 " yield 0;\n"
734 " }\n"
735 " default ->\n"
736 " {\n"
737 " yield 1;\n"
738 " }\n"
739 "};",
740 Style);
741 }
742
TEST_F(FormatTestJava,AlignCaseArrows)743 TEST_F(FormatTestJava, AlignCaseArrows) {
744 auto Style = getLLVMStyle(FormatStyle::LK_Java);
745 Style.AlignConsecutiveShortCaseStatements.Enabled = true;
746
747 verifyFormat("foo(switch (day) {\n"
748 " case THURSDAY, SATURDAY -> 8;\n"
749 " case WEDNESDAY -> 9;\n"
750 " default -> 1;\n"
751 "});",
752 Style);
753
754 verifyFormat("i = switch (day) {\n"
755 " case THURSDAY, SATURDAY -> 8;\n"
756 " case WEDNESDAY -> 9;\n"
757 " default -> 0;\n"
758 "};",
759 Style);
760
761 verifyFormat("switch (day) {\n"
762 "case THURSDAY, SATURDAY -> i = 8;\n"
763 "case WEDNESDAY -> i = 9;\n"
764 "default -> i = 0;\n"
765 "};",
766 Style);
767
768 Style.AlignConsecutiveShortCaseStatements.AlignCaseArrows = true;
769
770 verifyFormat("foo(switch (day) {\n"
771 " case THURSDAY, SATURDAY -> 8;\n"
772 " case WEDNESDAY -> 9;\n"
773 " default -> 1;\n"
774 "});",
775 Style);
776
777 verifyFormat("i = switch (day) {\n"
778 " case THURSDAY, SATURDAY -> 8;\n"
779 " case WEDNESDAY -> 9;\n"
780 " default -> 0;\n"
781 "};",
782 Style);
783
784 verifyFormat("switch (day) {\n"
785 "case THURSDAY, SATURDAY -> i = 8;\n"
786 "case WEDNESDAY -> i = 9;\n"
787 "default -> i = 0;\n"
788 "};",
789 Style);
790 }
791
792 } // namespace
793 } // namespace test
794 } // namespace format
795 } // namespace clang
796