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

source code of clang/unittests/Format/FormatTestJava.cpp