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 16 namespace clang { 17 namespace format { 18 19 class FormatTestJava : public ::testing::Test { 20 protected: 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 53 TEST_F(FormatTestJava, NoAlternativeOperatorNames) { 54 verifyFormat("someObject.and();"); 55 } 56 57 TEST_F(FormatTestJava, UnderstandsCasts) { 58 verifyFormat("a[b >> 1] = (byte) (c() << 4);"); 59 } 60 61 TEST_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 74 TEST_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 89 TEST_F(FormatTestJava, QualifiedNames) { 90 verifyFormat("public some.package.Type someFunction( // comment\n" 91 " int parameter) {}"); 92 } 93 94 TEST_F(FormatTestJava, ClassKeyword) { 95 verifyFormat("SomeClass.class.getName();"); 96 verifyFormat("Class c = SomeClass.class;"); 97 } 98 99 TEST_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 168 TEST_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 181 TEST_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 " void f() {}"); 202 verifyFormat("enum SomeThing {\n" 203 " ABC(1, \"ABC\"),\n" 204 " CDE(2, \"CDE\");\n" 205 " Something(int i, String s) {}\n" 206 "}"); 207 verifyFormat("enum SomeThing {\n" 208 " ABC(new int[] {1, 2}),\n" 209 " CDE(new int[] {2, 3});\n" 210 " Something(int[] i) {}\n" 211 "}"); 212 verifyFormat("public enum SomeThing {\n" 213 " ABC {\n" 214 " public String toString() {\n" 215 " return \"ABC\";\n" 216 " }\n" 217 " },\n" 218 " CDE {\n" 219 " @Override\n" 220 " public String toString() {\n" 221 " return \"CDE\";\n" 222 " }\n" 223 " };\n" 224 " public void f() {}\n" 225 "}"); 226 verifyFormat("private enum SomeEnum implements Foo<?, B> {\n" 227 " ABC {\n" 228 " @Override\n" 229 " public String toString() {\n" 230 " return \"ABC\";\n" 231 " }\n" 232 " },\n" 233 " CDE {\n" 234 " @Override\n" 235 " public String toString() {\n" 236 " return \"CDE\";\n" 237 " }\n" 238 " };\n" 239 "}"); 240 verifyFormat("public enum VeryLongEnum {\n" 241 " ENUM_WITH_MANY_PARAMETERS(\n" 242 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\", \"bbbbbbbbbbbbbbbb\", " 243 "\"cccccccccccccccccccccccc\"),\n" 244 " SECOND_ENUM(\"a\", \"b\", \"c\");\n" 245 " private VeryLongEnum(String a, String b, String c) {}\n" 246 "}\n"); 247 } 248 249 TEST_F(FormatTestJava, ArrayInitializers) { 250 verifyFormat("new int[] {1, 2, 3, 4};"); 251 verifyFormat("new int[] {\n" 252 " 1,\n" 253 " 2,\n" 254 " 3,\n" 255 " 4,\n" 256 "};"); 257 258 FormatStyle Style = getStyleWithColumns(65); 259 Style.Cpp11BracedListStyle = false; 260 verifyFormat( 261 "expected = new int[] { 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,\n" 262 " 100, 100, 100, 100, 100, 100, 100, 100, 100, 100 };", 263 Style); 264 } 265 266 TEST_F(FormatTestJava, ThrowsDeclarations) { 267 verifyFormat("public void doSooooooooooooooooooooooooooomething()\n" 268 " throws LooooooooooooooooooooooooooooongException {}"); 269 verifyFormat("public void doSooooooooooooooooooooooooooomething()\n" 270 " throws LoooooooooongException, LooooooooooongException {}"); 271 } 272 273 TEST_F(FormatTestJava, Annotations) { 274 verifyFormat("@Override\n" 275 "public String toString() {}"); 276 verifyFormat("@Override\n" 277 "@Nullable\n" 278 "public String getNameIfPresent() {}"); 279 verifyFormat("@Override // comment\n" 280 "@Nullable\n" 281 "public String getNameIfPresent() {}"); 282 verifyFormat("@java.lang.Override // comment\n" 283 "@Nullable\n" 284 "public String getNameIfPresent() {}"); 285 286 verifyFormat("@SuppressWarnings(value = \"unchecked\")\n" 287 "public void doSomething() {}"); 288 verifyFormat("@SuppressWarnings(value = \"unchecked\")\n" 289 "@Author(name = \"abc\")\n" 290 "public void doSomething() {}"); 291 292 verifyFormat("DoSomething(new A() {\n" 293 " @Override\n" 294 " public String toString() {}\n" 295 "});"); 296 297 verifyFormat("void SomeFunction(@Nullable String something) {}"); 298 verifyFormat("void SomeFunction(@org.llvm.Nullable String something) {}"); 299 300 verifyFormat("@Partial @Mock DataLoader loader;"); 301 verifyFormat("@Partial\n" 302 "@Mock\n" 303 "DataLoader loader;", 304 getChromiumStyle(FormatStyle::LK_Java)); 305 verifyFormat("@SuppressWarnings(value = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\")\n" 306 "public static int iiiiiiiiiiiiiiiiiiiiiiii;"); 307 308 verifyFormat("@SomeAnnotation(\"With some really looooooooooooooong text\")\n" 309 "private static final long something = 0L;"); 310 verifyFormat("@org.llvm.Qualified(\"With some really looooooooooong text\")\n" 311 "private static final long something = 0L;"); 312 verifyFormat("@Mock\n" 313 "DataLoader loooooooooooooooooooooooader =\n" 314 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 315 getStyleWithColumns(60)); 316 verifyFormat("@org.llvm.QualifiedMock\n" 317 "DataLoader loooooooooooooooooooooooader =\n" 318 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 319 getStyleWithColumns(60)); 320 verifyFormat("@Test(a)\n" 321 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 322 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa);"); 323 verifyFormat("@SomeAnnotation(\n" 324 " aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa)\n" 325 "int i;", 326 getStyleWithColumns(50)); 327 verifyFormat("@Test\n" 328 "ReturnType doSomething(\n" 329 " String aaaaaaaaaaaaa, String bbbbbbbbbbbbbbb) {}", 330 getStyleWithColumns(60)); 331 verifyFormat("{\n" 332 " boolean someFunction(\n" 333 " @Param(aaaaaaaaaaaaaaaa) String aaaaa,\n" 334 " String bbbbbbbbbbbbbbb) {}\n" 335 "}", 336 getStyleWithColumns(60)); 337 verifyFormat("@Annotation(\"Some\"\n" 338 " + \" text\")\n" 339 "List<Integer> list;"); 340 341 verifyFormat( 342 "@Test\n" 343 "@Feature({\"Android-TabSwitcher\"})\n" 344 "@CommandLineFlags.Add({ChromeSwitches.DISABLE_FIRST_RUN_EXPERIENCE})\n" 345 "@Features.EnableFeatures({FEATURE})\n" 346 "public void test(@Foo.bar(\"baz\") @Quux.Qoob int theFirstParaaaaam,\n" 347 " @Foo.bar(\"baz\") @Quux.Qoob int theSecondParaaaaaaaaaaaaaaaam) {}"); 348 } 349 350 TEST_F(FormatTestJava, Generics) { 351 verifyFormat("Iterable<?> a;"); 352 verifyFormat("Iterable<?> a;"); 353 verifyFormat("Iterable<? extends SomeObject> a;"); 354 355 verifyFormat("A.<B>doSomething();"); 356 verifyFormat("A.<B<C>>doSomething();"); 357 verifyFormat("A.<B<C<D>>>doSomething();"); 358 verifyFormat("A.<B<C<D<E>>>>doSomething();"); 359 360 verifyFormat("OrderedPair<String, List<Box<Integer>>> p = null;"); 361 362 verifyFormat("@Override\n" 363 "public Map<String, ?> getAll() {}"); 364 365 verifyFormat("public <R> ArrayList<R> get() {}"); 366 verifyFormat("protected <R> ArrayList<R> get() {}"); 367 verifyFormat("private <R> ArrayList<R> get() {}"); 368 verifyFormat("public static <R> ArrayList<R> get() {}"); 369 verifyFormat("public static native <R> ArrayList<R> get();"); 370 verifyFormat("public final <X> Foo foo() {}"); 371 verifyFormat("public abstract <X> Foo foo();"); 372 verifyFormat("<T extends B> T getInstance(Class<T> type);"); 373 verifyFormat("Function<F, ? extends T> function;"); 374 375 verifyFormat("private Foo<X, Y>[] foos;"); 376 verifyFormat("Foo<X, Y>[] foos = this.foos;"); 377 verifyFormat("return (a instanceof List<?>)\n" 378 " ? aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n" 379 " : aaaaaaaaaaaaaaaaaaaaaaa;", 380 getStyleWithColumns(60)); 381 382 verifyFormat( 383 "SomeLoooooooooooooooooooooongType name =\n" 384 " SomeType.foo(someArgument)\n" 385 " .<X>method()\n" 386 " .aaaaaaaaaaaaaaaaaaa()\n" 387 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 388 } 389 390 TEST_F(FormatTestJava, StringConcatenation) { 391 verifyFormat("String someString = \"abc\"\n" 392 " + \"cde\";"); 393 } 394 395 TEST_F(FormatTestJava, TryCatchFinally) { 396 verifyFormat("try {\n" 397 " Something();\n" 398 "} catch (SomeException e) {\n" 399 " HandleException(e);\n" 400 "}"); 401 verifyFormat("try {\n" 402 " Something();\n" 403 "} finally {\n" 404 " AlwaysDoThis();\n" 405 "}"); 406 verifyFormat("try {\n" 407 " Something();\n" 408 "} catch (SomeException e) {\n" 409 " HandleException(e);\n" 410 "} finally {\n" 411 " AlwaysDoThis();\n" 412 "}"); 413 414 verifyFormat("try {\n" 415 " Something();\n" 416 "} catch (SomeException | OtherException e) {\n" 417 " HandleException(e);\n" 418 "}"); 419 } 420 421 TEST_F(FormatTestJava, TryWithResources) { 422 verifyFormat("try (SomeResource rs = someFunction()) {\n" 423 " Something();\n" 424 "}"); 425 verifyFormat("try (SomeResource rs = someFunction()) {\n" 426 " Something();\n" 427 "} catch (SomeException e) {\n" 428 " HandleException(e);\n" 429 "}"); 430 } 431 432 TEST_F(FormatTestJava, SynchronizedKeyword) { 433 verifyFormat("synchronized (mData) {\n" 434 " // ...\n" 435 "}"); 436 437 FormatStyle Style = getLLVMStyle(FormatStyle::LK_Java); 438 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 439 440 Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always; 441 Style.BraceWrapping.AfterFunction = false; 442 verifyFormat("synchronized (mData)\n" 443 "{\n" 444 " // ...\n" 445 "}", 446 Style); 447 448 Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Never; 449 Style.BraceWrapping.AfterFunction = true; 450 verifyFormat("synchronized (mData) {\n" 451 " // ...\n" 452 "}", 453 Style); 454 } 455 456 TEST_F(FormatTestJava, AssertKeyword) { 457 verifyFormat("assert a && b;"); 458 verifyFormat("assert (a && b);"); 459 } 460 461 TEST_F(FormatTestJava, PackageDeclarations) { 462 verifyFormat("package some.really.loooooooooooooooooooooong.package;", 463 getStyleWithColumns(50)); 464 } 465 466 TEST_F(FormatTestJava, ImportDeclarations) { 467 verifyFormat("import some.really.loooooooooooooooooooooong.imported.Class;", 468 getStyleWithColumns(50)); 469 verifyFormat("import static some.really.looooooooooooooooong.imported.Class;", 470 getStyleWithColumns(50)); 471 } 472 473 TEST_F(FormatTestJava, MethodDeclarations) { 474 verifyFormat("void methodName(Object arg1,\n" 475 " Object arg2, Object arg3) {}", 476 getStyleWithColumns(40)); 477 verifyFormat("void methodName(\n" 478 " Object arg1, Object arg2) {}", 479 getStyleWithColumns(40)); 480 } 481 482 TEST_F(FormatTestJava, MethodReference) { 483 EXPECT_EQ("private void foo() {\n" 484 " f(this::methodReference);\n" 485 " f(C.super::methodReference);\n" 486 " Consumer<String> c = System.out::println;\n" 487 " Iface<Integer> mRef = Ty::<Integer>meth;\n" 488 "}", 489 format("private void foo() {\n" 490 " f(this ::methodReference);\n" 491 " f(C.super ::methodReference);\n" 492 " Consumer<String> c = System.out ::println;\n" 493 " Iface<Integer> mRef = Ty :: <Integer> meth;\n" 494 "}")); 495 } 496 497 TEST_F(FormatTestJava, CppKeywords) { 498 verifyFormat("public void union(Type a, Type b);"); 499 verifyFormat("public void struct(Object o);"); 500 verifyFormat("public void delete(Object o);"); 501 verifyFormat("return operator && (aa);"); 502 } 503 504 TEST_F(FormatTestJava, NeverAlignAfterReturn) { 505 verifyFormat("return aaaaaaaaaaaaaaaaaaa\n" 506 " && bbbbbbbbbbbbbbbbbbb\n" 507 " && ccccccccccccccccccc;", 508 getStyleWithColumns(40)); 509 verifyFormat("return (result == null)\n" 510 " ? aaaaaaaaaaaaaaaaa\n" 511 " : bbbbbbbbbbbbbbbbb;", 512 getStyleWithColumns(40)); 513 verifyFormat("return aaaaaaaaaaaaaaaaaaa()\n" 514 " .bbbbbbbbbbbbbbbbbbb()\n" 515 " .ccccccccccccccccccc();", 516 getStyleWithColumns(40)); 517 verifyFormat("return aaaaaaaaaaaaaaaaaaa()\n" 518 " .bbbbbbbbbbbbbbbbbbb(\n" 519 " ccccccccccccccc)\n" 520 " .ccccccccccccccccccc();", 521 getStyleWithColumns(40)); 522 } 523 524 TEST_F(FormatTestJava, FormatsInnerBlocks) { 525 verifyFormat("someObject.someFunction(new Runnable() {\n" 526 " @Override\n" 527 " public void run() {\n" 528 " System.out.println(42);\n" 529 " }\n" 530 "}, someOtherParameter);"); 531 verifyFormat("someFunction(new Runnable() {\n" 532 " public void run() {\n" 533 " System.out.println(42);\n" 534 " }\n" 535 "});"); 536 verifyFormat("someObject.someFunction(\n" 537 " new Runnable() {\n" 538 " @Override\n" 539 " public void run() {\n" 540 " System.out.println(42);\n" 541 " }\n" 542 " },\n" 543 " new Runnable() {\n" 544 " @Override\n" 545 " public void run() {\n" 546 " System.out.println(43);\n" 547 " }\n" 548 " },\n" 549 " someOtherParameter);"); 550 } 551 552 TEST_F(FormatTestJava, FormatsLambdas) { 553 verifyFormat("(aaaaaaaaaa, bbbbbbbbbb) -> aaaaaaaaaa + bbbbbbbbbb;"); 554 verifyFormat("(aaaaaaaaaa, bbbbbbbbbb)\n" 555 " -> aaaaaaaaaa + bbbbbbbbbb;", 556 getStyleWithColumns(40)); 557 verifyFormat("Runnable someLambda = () -> DoSomething();"); 558 verifyFormat("Runnable someLambda = () -> {\n" 559 " DoSomething();\n" 560 "}"); 561 562 verifyFormat("Runnable someLambda =\n" 563 " (int aaaaa) -> DoSomething(aaaaa);", 564 getStyleWithColumns(40)); 565 } 566 567 TEST_F(FormatTestJava, BreaksStringLiterals) { 568 // FIXME: String literal breaking is currently disabled for Java and JS, as it 569 // requires strings to be merged using "+" which we don't support. 570 verifyFormat("\"some text other\";", getStyleWithColumns(14)); 571 } 572 573 TEST_F(FormatTestJava, AlignsBlockComments) { 574 EXPECT_EQ("/*\n" 575 " * Really multi-line\n" 576 " * comment.\n" 577 " */\n" 578 "void f() {}", 579 format(" /*\n" 580 " * Really multi-line\n" 581 " * comment.\n" 582 " */\n" 583 " void f() {}")); 584 } 585 586 TEST_F(FormatTestJava, AlignDeclarations) { 587 FormatStyle Style = getLLVMStyle(FormatStyle::LK_Java); 588 Style.AlignConsecutiveDeclarations.Enabled = true; 589 verifyFormat("private final String[] args;\n" 590 "private final A_ParserHelper parserHelper;\n" 591 "private final int numOfCmdArgs;\n" 592 "private int numOfCmdArgs;\n" 593 "private String[] args;", 594 Style); 595 } 596 597 TEST_F(FormatTestJava, KeepsDelimitersOnOwnLineInJavaDocComments) { 598 EXPECT_EQ("/**\n" 599 " * javadoc line 1\n" 600 " * javadoc line 2\n" 601 " */", 602 format("/** javadoc line 1\n" 603 " * javadoc line 2 */")); 604 } 605 606 TEST_F(FormatTestJava, RetainsLogicalShifts) { 607 verifyFormat("void f() {\n" 608 " int a = 1;\n" 609 " a >>>= 1;\n" 610 "}"); 611 verifyFormat("void f() {\n" 612 " int a = 1;\n" 613 " a = a >>> 1;\n" 614 "}"); 615 } 616 617 TEST_F(FormatTestJava, ShortFunctions) { 618 FormatStyle Style = getLLVMStyle(FormatStyle::LK_Java); 619 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; 620 verifyFormat("enum Enum {\n" 621 " E1,\n" 622 " E2;\n" 623 " void f() { return; }\n" 624 "}", 625 Style); 626 } 627 628 } // namespace format 629 } // end namespace clang 630