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