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