868 lines · 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-exception6//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(FormatStyle::LK_Java);22 }23 24 static FormatStyle getStyleWithColumns(unsigned ColumnLimit) {25 FormatStyle Style = getGoogleStyle(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(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(65);239 Style.Cpp11BracedListStyle = FormatStyle::BLS_Block;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(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(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(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(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(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(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(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 851TEST_F(FormatTestJava, BreakAfterRecord) {852 auto Style = getLLVMStyle(FormatStyle::LK_Java);853 Style.EmptyLineBeforeAccessModifier = FormatStyle::ELBAMS_Never;854 Style.BreakBeforeBraces = FormatStyle::BS_Custom;855 Style.BraceWrapping.AfterClass = true;856 Style.BraceWrapping.SplitEmptyRecord = true;857 858 verifyFormat("public record Foo(int i)\n"859 "{\n"860 "}",861 "public record Foo(int i) {}", Style);862}863 864} // namespace865} // namespace test866} // namespace format867} // namespace clang868