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 DEBUG(llvm::errs() << "---\n"); 25 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 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 } 159 160 TEST_F(FormatTestJava, AnonymousClasses) { 161 verifyFormat("return new A() {\n" 162 " public String toString() {\n" 163 " return \"NotReallyA\";\n" 164 " }\n" 165 "};"); 166 verifyFormat("A a = new A() {\n" 167 " public String toString() {\n" 168 " return \"NotReallyA\";\n" 169 " }\n" 170 "};"); 171 } 172 173 TEST_F(FormatTestJava, EnumDeclarations) { 174 verifyFormat("enum SomeThing { ABC, CDE }"); 175 verifyFormat("enum SomeThing {\n" 176 " ABC,\n" 177 " CDE,\n" 178 "}"); 179 verifyFormat("public class SomeClass {\n" 180 " enum SomeThing { ABC, CDE }\n" 181 " void f() {}\n" 182 "}"); 183 verifyFormat("public class SomeClass implements SomeInterface {\n" 184 " enum SomeThing { ABC, CDE }\n" 185 " void f() {}\n" 186 "}"); 187 verifyFormat("enum SomeThing {\n" 188 " ABC,\n" 189 " CDE;\n" 190 " void f() {}\n" 191 "}"); 192 verifyFormat("enum SomeThing {\n" 193 " ABC(1, \"ABC\"),\n" 194 " CDE(2, \"CDE\");\n" 195 " Something(int i, String s) {}\n" 196 "}"); 197 verifyFormat("enum SomeThing {\n" 198 " ABC(new int[] {1, 2}),\n" 199 " CDE(new int[] {2, 3});\n" 200 " Something(int[] i) {}\n" 201 "}"); 202 verifyFormat("public enum SomeThing {\n" 203 " ABC {\n" 204 " public String toString() {\n" 205 " return \"ABC\";\n" 206 " }\n" 207 " },\n" 208 " CDE {\n" 209 " @Override\n" 210 " public String toString() {\n" 211 " return \"CDE\";\n" 212 " }\n" 213 " };\n" 214 " public void f() {}\n" 215 "}"); 216 verifyFormat("private enum SomeEnum implements Foo<?, B> {\n" 217 " ABC {\n" 218 " @Override\n" 219 " public String toString() {\n" 220 " return \"ABC\";\n" 221 " }\n" 222 " },\n" 223 " CDE {\n" 224 " @Override\n" 225 " public String toString() {\n" 226 " return \"CDE\";\n" 227 " }\n" 228 " };\n" 229 "}"); 230 verifyFormat("public enum VeryLongEnum {\n" 231 " ENUM_WITH_MANY_PARAMETERS(\n" 232 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\", \"bbbbbbbbbbbbbbbb\", " 233 "\"cccccccccccccccccccccccc\"),\n" 234 " SECOND_ENUM(\"a\", \"b\", \"c\");\n" 235 " private VeryLongEnum(String a, String b, String c) {}\n" 236 "}\n"); 237 } 238 239 TEST_F(FormatTestJava, ArrayInitializers) { 240 verifyFormat("new int[] {1, 2, 3, 4};"); 241 verifyFormat("new int[] {\n" 242 " 1,\n" 243 " 2,\n" 244 " 3,\n" 245 " 4,\n" 246 "};"); 247 248 FormatStyle Style = getStyleWithColumns(65); 249 Style.Cpp11BracedListStyle = false; 250 verifyFormat( 251 "expected = new int[] { 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,\n" 252 " 100, 100, 100, 100, 100, 100, 100, 100, 100, 100 };", 253 Style); 254 } 255 256 TEST_F(FormatTestJava, ThrowsDeclarations) { 257 verifyFormat("public void doSooooooooooooooooooooooooooomething()\n" 258 " throws LooooooooooooooooooooooooooooongException {}"); 259 verifyFormat("public void doSooooooooooooooooooooooooooomething()\n" 260 " throws LoooooooooongException, LooooooooooongException {}"); 261 } 262 263 TEST_F(FormatTestJava, Annotations) { 264 verifyFormat("@Override\n" 265 "public String toString() {}"); 266 verifyFormat("@Override\n" 267 "@Nullable\n" 268 "public String getNameIfPresent() {}"); 269 verifyFormat("@Override // comment\n" 270 "@Nullable\n" 271 "public String getNameIfPresent() {}"); 272 verifyFormat("@java.lang.Override // comment\n" 273 "@Nullable\n" 274 "public String getNameIfPresent() {}"); 275 276 verifyFormat("@SuppressWarnings(value = \"unchecked\")\n" 277 "public void doSomething() {}"); 278 verifyFormat("@SuppressWarnings(value = \"unchecked\")\n" 279 "@Author(name = \"abc\")\n" 280 "public void doSomething() {}"); 281 282 verifyFormat("DoSomething(new A() {\n" 283 " @Override\n" 284 " public String toString() {}\n" 285 "});"); 286 287 verifyFormat("void SomeFunction(@Nullable String something) {}"); 288 verifyFormat("void SomeFunction(@org.llvm.Nullable String something) {}"); 289 290 verifyFormat("@Partial @Mock DataLoader loader;"); 291 verifyFormat("@Partial\n" 292 "@Mock\n" 293 "DataLoader loader;", 294 getChromiumStyle(FormatStyle::LK_Java)); 295 verifyFormat("@SuppressWarnings(value = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\")\n" 296 "public static int iiiiiiiiiiiiiiiiiiiiiiii;"); 297 298 verifyFormat("@SomeAnnotation(\"With some really looooooooooooooong text\")\n" 299 "private static final long something = 0L;"); 300 verifyFormat("@org.llvm.Qualified(\"With some really looooooooooong text\")\n" 301 "private static final long something = 0L;"); 302 verifyFormat("@Mock\n" 303 "DataLoader loooooooooooooooooooooooader =\n" 304 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 305 getStyleWithColumns(60)); 306 verifyFormat("@org.llvm.QualifiedMock\n" 307 "DataLoader loooooooooooooooooooooooader =\n" 308 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 309 getStyleWithColumns(60)); 310 verifyFormat("@Test(a)\n" 311 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 312 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa);"); 313 verifyFormat("@SomeAnnotation(\n" 314 " aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa)\n" 315 "int i;", 316 getStyleWithColumns(50)); 317 verifyFormat("@Test\n" 318 "ReturnType doSomething(\n" 319 " String aaaaaaaaaaaaa, String bbbbbbbbbbbbbbb) {}", 320 getStyleWithColumns(60)); 321 verifyFormat("{\n" 322 " boolean someFunction(\n" 323 " @Param(aaaaaaaaaaaaaaaa) String aaaaa,\n" 324 " String bbbbbbbbbbbbbbb) {}\n" 325 "}", 326 getStyleWithColumns(60)); 327 verifyFormat("@Annotation(\"Some\"\n" 328 " + \" text\")\n" 329 "List<Integer> list;"); 330 } 331 332 TEST_F(FormatTestJava, Generics) { 333 verifyFormat("Iterable<?> a;"); 334 verifyFormat("Iterable<?> a;"); 335 verifyFormat("Iterable<? extends SomeObject> a;"); 336 337 verifyFormat("A.<B>doSomething();"); 338 verifyFormat("A.<B<C>>doSomething();"); 339 verifyFormat("A.<B<C<D>>>doSomething();"); 340 verifyFormat("A.<B<C<D<E>>>>doSomething();"); 341 342 verifyFormat("OrderedPair<String, List<Box<Integer>>> p = null;"); 343 344 verifyFormat("@Override\n" 345 "public Map<String, ?> getAll() {}"); 346 347 verifyFormat("public <R> ArrayList<R> get() {}"); 348 verifyFormat("protected <R> ArrayList<R> get() {}"); 349 verifyFormat("private <R> ArrayList<R> get() {}"); 350 verifyFormat("public static <R> ArrayList<R> get() {}"); 351 verifyFormat("public static native <R> ArrayList<R> get();"); 352 verifyFormat("public final <X> Foo foo() {}"); 353 verifyFormat("public abstract <X> Foo foo();"); 354 verifyFormat("<T extends B> T getInstance(Class<T> type);"); 355 verifyFormat("Function<F, ? extends T> function;"); 356 357 verifyFormat("private Foo<X, Y>[] foos;"); 358 verifyFormat("Foo<X, Y>[] foos = this.foos;"); 359 verifyFormat("return (a instanceof List<?>)\n" 360 " ? aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n" 361 " : aaaaaaaaaaaaaaaaaaaaaaa;", 362 getStyleWithColumns(60)); 363 364 verifyFormat( 365 "SomeLoooooooooooooooooooooongType name =\n" 366 " SomeType.foo(someArgument)\n" 367 " .<X>method()\n" 368 " .aaaaaaaaaaaaaaaaaaa()\n" 369 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 370 } 371 372 TEST_F(FormatTestJava, StringConcatenation) { 373 verifyFormat("String someString = \"abc\"\n" 374 " + \"cde\";"); 375 } 376 377 TEST_F(FormatTestJava, TryCatchFinally) { 378 verifyFormat("try {\n" 379 " Something();\n" 380 "} catch (SomeException e) {\n" 381 " HandleException(e);\n" 382 "}"); 383 verifyFormat("try {\n" 384 " Something();\n" 385 "} finally {\n" 386 " AlwaysDoThis();\n" 387 "}"); 388 verifyFormat("try {\n" 389 " Something();\n" 390 "} catch (SomeException e) {\n" 391 " HandleException(e);\n" 392 "} finally {\n" 393 " AlwaysDoThis();\n" 394 "}"); 395 396 verifyFormat("try {\n" 397 " Something();\n" 398 "} catch (SomeException | OtherException e) {\n" 399 " HandleException(e);\n" 400 "}"); 401 } 402 403 TEST_F(FormatTestJava, TryWithResources) { 404 verifyFormat("try (SomeResource rs = someFunction()) {\n" 405 " Something();\n" 406 "}"); 407 verifyFormat("try (SomeResource rs = someFunction()) {\n" 408 " Something();\n" 409 "} catch (SomeException e) {\n" 410 " HandleException(e);\n" 411 "}"); 412 } 413 414 TEST_F(FormatTestJava, SynchronizedKeyword) { 415 verifyFormat("synchronized (mData) {\n" 416 " // ...\n" 417 "}"); 418 } 419 420 TEST_F(FormatTestJava, AssertKeyword) { 421 verifyFormat("assert a && b;"); 422 verifyFormat("assert (a && b);"); 423 } 424 425 TEST_F(FormatTestJava, PackageDeclarations) { 426 verifyFormat("package some.really.loooooooooooooooooooooong.package;", 427 getStyleWithColumns(50)); 428 } 429 430 TEST_F(FormatTestJava, ImportDeclarations) { 431 verifyFormat("import some.really.loooooooooooooooooooooong.imported.Class;", 432 getStyleWithColumns(50)); 433 verifyFormat("import static some.really.looooooooooooooooong.imported.Class;", 434 getStyleWithColumns(50)); 435 } 436 437 TEST_F(FormatTestJava, MethodDeclarations) { 438 verifyFormat("void methodName(Object arg1,\n" 439 " Object arg2, Object arg3) {}", 440 getStyleWithColumns(40)); 441 verifyFormat("void methodName(\n" 442 " Object arg1, Object arg2) {}", 443 getStyleWithColumns(40)); 444 } 445 446 TEST_F(FormatTestJava, CppKeywords) { 447 verifyFormat("public void union(Type a, Type b);"); 448 verifyFormat("public void struct(Object o);"); 449 verifyFormat("public void delete(Object o);"); 450 verifyFormat("return operator && (aa);"); 451 } 452 453 TEST_F(FormatTestJava, NeverAlignAfterReturn) { 454 verifyFormat("return aaaaaaaaaaaaaaaaaaa\n" 455 " && bbbbbbbbbbbbbbbbbbb\n" 456 " && ccccccccccccccccccc;", 457 getStyleWithColumns(40)); 458 verifyFormat("return (result == null)\n" 459 " ? aaaaaaaaaaaaaaaaa\n" 460 " : bbbbbbbbbbbbbbbbb;", 461 getStyleWithColumns(40)); 462 verifyFormat("return aaaaaaaaaaaaaaaaaaa()\n" 463 " .bbbbbbbbbbbbbbbbbbb()\n" 464 " .ccccccccccccccccccc();", 465 getStyleWithColumns(40)); 466 verifyFormat("return aaaaaaaaaaaaaaaaaaa()\n" 467 " .bbbbbbbbbbbbbbbbbbb(\n" 468 " ccccccccccccccc)\n" 469 " .ccccccccccccccccccc();", 470 getStyleWithColumns(40)); 471 } 472 473 TEST_F(FormatTestJava, FormatsInnerBlocks) { 474 verifyFormat("someObject.someFunction(new Runnable() {\n" 475 " @Override\n" 476 " public void run() {\n" 477 " System.out.println(42);\n" 478 " }\n" 479 "}, someOtherParameter);"); 480 verifyFormat("someFunction(new Runnable() {\n" 481 " public void run() {\n" 482 " System.out.println(42);\n" 483 " }\n" 484 "});"); 485 verifyFormat("someObject.someFunction(\n" 486 " new Runnable() {\n" 487 " @Override\n" 488 " public void run() {\n" 489 " System.out.println(42);\n" 490 " }\n" 491 " },\n" 492 " new Runnable() {\n" 493 " @Override\n" 494 " public void run() {\n" 495 " System.out.println(43);\n" 496 " }\n" 497 " },\n" 498 " someOtherParameter);"); 499 } 500 501 TEST_F(FormatTestJava, FormatsLambdas) { 502 verifyFormat("(aaaaaaaaaa, bbbbbbbbbb) -> aaaaaaaaaa + bbbbbbbbbb;"); 503 verifyFormat("(aaaaaaaaaa, bbbbbbbbbb)\n" 504 " -> aaaaaaaaaa + bbbbbbbbbb;", 505 getStyleWithColumns(40)); 506 verifyFormat("Runnable someLambda = () -> DoSomething();"); 507 verifyFormat("Runnable someLambda = () -> {\n" 508 " DoSomething();\n" 509 "}"); 510 511 verifyFormat("Runnable someLambda =\n" 512 " (int aaaaa) -> DoSomething(aaaaa);", 513 getStyleWithColumns(40)); 514 } 515 516 TEST_F(FormatTestJava, BreaksStringLiterals) { 517 // FIXME: String literal breaking is currently disabled for Java and JS, as it 518 // requires strings to be merged using "+" which we don't support. 519 EXPECT_EQ("\"some text other\";", 520 format("\"some text other\";", getStyleWithColumns(14))); 521 } 522 523 TEST_F(FormatTestJava, AlignsBlockComments) { 524 EXPECT_EQ("/*\n" 525 " * Really multi-line\n" 526 " * comment.\n" 527 " */\n" 528 "void f() {}", 529 format(" /*\n" 530 " * Really multi-line\n" 531 " * comment.\n" 532 " */\n" 533 " void f() {}")); 534 } 535 536 TEST_F(FormatTestJava, KeepsDelimitersOnOwnLineInJavaDocComments) { 537 EXPECT_EQ("/**\n" 538 " * javadoc line 1\n" 539 " * javadoc line 2\n" 540 " */", 541 format("/** javadoc line 1\n" 542 " * javadoc line 2 */")); 543 } 544 545 TEST_F(FormatTestJava, RetainsLogicalShifts) { 546 verifyFormat("void f() {\n" 547 " int a = 1;\n" 548 " a >>>= 1;\n" 549 "}"); 550 verifyFormat("void f() {\n" 551 " int a = 1;\n" 552 " a = a >>> 1;\n" 553 "}"); 554 } 555 556 557 } // end namespace tooling 558 } // end namespace clang 559