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 std::string Result = applyAllReplacements(Code, Replaces); 29 EXPECT_NE("", Result); 30 DEBUG(llvm::errs() << "\n" << Result << "\n\n"); 31 return Result; 32 } 33 34 static std::string format( 35 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 } 71 72 TEST_F(FormatTestJava, Chromium) { 73 verifyFormat("class SomeClass {\n" 74 " void f() {}\n" 75 " int g() {\n" 76 " return 0;\n" 77 " }\n" 78 " void h() {\n" 79 " while (true) f();\n" 80 " for (;;) f();\n" 81 " if (true) f();\n" 82 " }\n" 83 "}", 84 getChromiumStyle(FormatStyle::LK_Java)); 85 } 86 87 TEST_F(FormatTestJava, QualifiedNames) { 88 verifyFormat("public some.package.Type someFunction( // comment\n" 89 " int parameter) {}"); 90 } 91 92 TEST_F(FormatTestJava, ClassKeyword) { 93 verifyFormat("SomeClass.class.getName();"); 94 verifyFormat("Class c = SomeClass.class;"); 95 } 96 97 TEST_F(FormatTestJava, ClassDeclarations) { 98 verifyFormat("public class SomeClass {\n" 99 " private int a;\n" 100 " private int b;\n" 101 "}"); 102 verifyFormat("public class A {\n" 103 " class B {\n" 104 " int i;\n" 105 " }\n" 106 " class C {\n" 107 " int j;\n" 108 " }\n" 109 "}"); 110 verifyFormat("public class A extends B.C {}"); 111 112 verifyFormat("abstract class SomeClass\n" 113 " extends SomeOtherClass implements SomeInterface {}", 114 getStyleWithColumns(60)); 115 verifyFormat("abstract class SomeClass extends SomeOtherClass\n" 116 " implements SomeInterfaceeeeeeeeeeeee {}", 117 getStyleWithColumns(60)); 118 verifyFormat("abstract class SomeClass\n" 119 " extends SomeOtherClass\n" 120 " implements SomeInterface {}", 121 getStyleWithColumns(40)); 122 verifyFormat("abstract class SomeClass\n" 123 " extends SomeOtherClass\n" 124 " implements SomeInterface,\n" 125 " AnotherInterface {}", 126 getStyleWithColumns(40)); 127 verifyFormat("abstract class SomeClass\n" 128 " implements SomeInterface, AnotherInterface {}", 129 getStyleWithColumns(60)); 130 verifyFormat("@SomeAnnotation()\n" 131 "abstract class aaaaaaaaaaaa\n" 132 " extends bbbbbbbbbbbbbbb implements cccccccccccc {}", 133 getStyleWithColumns(76)); 134 verifyFormat("@SomeAnnotation()\n" 135 "abstract class aaaaaaaaa<a>\n" 136 " extends bbbbbbbbbbbb<b> implements cccccccccccc {}", 137 getStyleWithColumns(76)); 138 verifyFormat("interface SomeInterface<A> extends Foo, Bar {\n" 139 " void doStuff(int theStuff);\n" 140 " void doMoreStuff(int moreStuff);\n" 141 "}"); 142 verifyFormat("public interface SomeInterface {\n" 143 " void doStuff(int theStuff);\n" 144 " void doMoreStuff(int moreStuff);\n" 145 "}"); 146 verifyFormat("@interface SomeInterface {\n" 147 " void doStuff(int theStuff);\n" 148 " void doMoreStuff(int moreStuff);\n" 149 "}"); 150 verifyFormat("public @interface SomeInterface {\n" 151 " void doStuff(int theStuff);\n" 152 " void doMoreStuff(int moreStuff);\n" 153 "}"); 154 } 155 156 TEST_F(FormatTestJava, AnonymousClasses) { 157 verifyFormat("return new A() {\n" 158 " public String toString() {\n" 159 " return \"NotReallyA\";\n" 160 " }\n" 161 "};"); 162 verifyFormat("A a = new A() {\n" 163 " public String toString() {\n" 164 " return \"NotReallyA\";\n" 165 " }\n" 166 "};"); 167 } 168 169 TEST_F(FormatTestJava, EnumDeclarations) { 170 verifyFormat("enum SomeThing { ABC, CDE }"); 171 verifyFormat("enum SomeThing {\n" 172 " ABC,\n" 173 " CDE,\n" 174 "}"); 175 verifyFormat("public class SomeClass {\n" 176 " enum SomeThing { ABC, CDE }\n" 177 " void f() {}\n" 178 "}"); 179 verifyFormat("public class SomeClass implements SomeInterface {\n" 180 " enum SomeThing { ABC, CDE }\n" 181 " void f() {}\n" 182 "}"); 183 verifyFormat("enum SomeThing {\n" 184 " ABC,\n" 185 " CDE;\n" 186 " void f() {}\n" 187 "}"); 188 verifyFormat("enum SomeThing {\n" 189 " ABC(1, \"ABC\"),\n" 190 " CDE(2, \"CDE\");\n" 191 " Something(int i, String s) {}\n" 192 "}"); 193 verifyFormat("enum SomeThing {\n" 194 " ABC(new int[] {1, 2}),\n" 195 " CDE(new int[] {2, 3});\n" 196 " Something(int[] i) {}\n" 197 "}"); 198 verifyFormat("public enum SomeThing {\n" 199 " ABC {\n" 200 " public String toString() {\n" 201 " return \"ABC\";\n" 202 " }\n" 203 " },\n" 204 " CDE {\n" 205 " @Override\n" 206 " public String toString() {\n" 207 " return \"CDE\";\n" 208 " }\n" 209 " };\n" 210 " public void f() {}\n" 211 "}"); 212 verifyFormat("private enum SomeEnum implements Foo<?, B> {\n" 213 " ABC {\n" 214 " @Override\n" 215 " public String toString() {\n" 216 " return \"ABC\";\n" 217 " }\n" 218 " },\n" 219 " CDE {\n" 220 " @Override\n" 221 " public String toString() {\n" 222 " return \"CDE\";\n" 223 " }\n" 224 " };\n" 225 "}"); 226 } 227 228 TEST_F(FormatTestJava, ArrayInitializers) { 229 verifyFormat("new int[] {1, 2, 3, 4};"); 230 verifyFormat("new int[] {\n" 231 " 1, 2, 3, 4,\n" 232 "};"); 233 234 FormatStyle Style = getStyleWithColumns(65); 235 Style.Cpp11BracedListStyle = false; 236 verifyFormat( 237 "expected = new int[] { 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,\n" 238 " 100, 100, 100, 100, 100, 100, 100, 100, 100, 100 };", 239 Style); 240 } 241 242 TEST_F(FormatTestJava, ThrowsDeclarations) { 243 verifyFormat("public void doSooooooooooooooooooooooooooomething()\n" 244 " throws LooooooooooooooooooooooooooooongException {}"); 245 verifyFormat("public void doSooooooooooooooooooooooooooomething()\n" 246 " throws LoooooooooongException, LooooooooooongException {}"); 247 } 248 249 TEST_F(FormatTestJava, Annotations) { 250 verifyFormat("@Override\n" 251 "public String toString() {}"); 252 verifyFormat("@Override\n" 253 "@Nullable\n" 254 "public String getNameIfPresent() {}"); 255 verifyFormat("@Override // comment\n" 256 "@Nullable\n" 257 "public String getNameIfPresent() {}"); 258 verifyFormat("@java.lang.Override // comment\n" 259 "@Nullable\n" 260 "public String getNameIfPresent() {}"); 261 262 verifyFormat("@SuppressWarnings(value = \"unchecked\")\n" 263 "public void doSomething() {}"); 264 verifyFormat("@SuppressWarnings(value = \"unchecked\")\n" 265 "@Author(name = \"abc\")\n" 266 "public void doSomething() {}"); 267 268 verifyFormat("DoSomething(new A() {\n" 269 " @Override\n" 270 " public String toString() {}\n" 271 "});"); 272 273 verifyFormat("void SomeFunction(@Nullable String something) {}"); 274 verifyFormat("void SomeFunction(@org.llvm.Nullable String something) {}"); 275 276 verifyFormat("@Partial @Mock DataLoader loader;"); 277 verifyFormat("@SuppressWarnings(value = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\")\n" 278 "public static int iiiiiiiiiiiiiiiiiiiiiiii;"); 279 280 verifyFormat("@SomeAnnotation(\"With some really looooooooooooooong text\")\n" 281 "private static final long something = 0L;"); 282 verifyFormat("@org.llvm.Qualified(\"With some really looooooooooong text\")\n" 283 "private static final long something = 0L;"); 284 verifyFormat("@Mock\n" 285 "DataLoader loooooooooooooooooooooooader =\n" 286 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 287 getStyleWithColumns(60)); 288 verifyFormat("@org.llvm.QualifiedMock\n" 289 "DataLoader loooooooooooooooooooooooader =\n" 290 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 291 getStyleWithColumns(60)); 292 verifyFormat("@Test(a)\n" 293 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 294 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa);"); 295 verifyFormat("@SomeAnnotation(\n" 296 " aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa)\n" 297 "int i;", 298 getStyleWithColumns(50)); 299 verifyFormat("@Test\n" 300 "ReturnType doSomething(\n" 301 " String aaaaaaaaaaaaa, String bbbbbbbbbbbbbbb) {}", 302 getStyleWithColumns(60)); 303 verifyFormat("{\n" 304 " boolean someFunction(\n" 305 " @Param(aaaaaaaaaaaaaaaa) String aaaaa,\n" 306 " String bbbbbbbbbbbbbbb) {}\n" 307 "}", 308 getStyleWithColumns(60)); 309 } 310 311 TEST_F(FormatTestJava, Generics) { 312 verifyFormat("Iterable<?> a;"); 313 verifyFormat("Iterable<?> a;"); 314 verifyFormat("Iterable<? extends SomeObject> a;"); 315 316 verifyFormat("A.<B>doSomething();"); 317 318 verifyFormat("@Override\n" 319 "public Map<String, ?> getAll() {}"); 320 321 verifyFormat("public <R> ArrayList<R> get() {}"); 322 verifyFormat("protected <R> ArrayList<R> get() {}"); 323 verifyFormat("private <R> ArrayList<R> get() {}"); 324 verifyFormat("public static <R> ArrayList<R> get() {}"); 325 verifyFormat("public static native <R> ArrayList<R> get();"); 326 verifyFormat("public final <X> Foo foo() {}"); 327 verifyFormat("public abstract <X> Foo foo();"); 328 verifyFormat("<T extends B> T getInstance(Class<T> type);"); 329 verifyFormat("Function<F, ? extends T> function;"); 330 331 verifyFormat("private Foo<X, Y>[] foos;"); 332 verifyFormat("Foo<X, Y>[] foos = this.foos;"); 333 verifyFormat("return (a instanceof List<?>)\n" 334 " ? aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n" 335 " : aaaaaaaaaaaaaaaaaaaaaaa;", 336 getStyleWithColumns(60)); 337 338 verifyFormat( 339 "SomeLoooooooooooooooooooooongType name =\n" 340 " SomeType.foo(someArgument)\n" 341 " .<X>method()\n" 342 " .aaaaaaaaaaaaaaaaaaa()\n" 343 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 344 } 345 346 TEST_F(FormatTestJava, StringConcatenation) { 347 verifyFormat("String someString = \"abc\"\n" 348 " + \"cde\";"); 349 } 350 351 TEST_F(FormatTestJava, TryCatchFinally) { 352 verifyFormat("try {\n" 353 " Something();\n" 354 "} catch (SomeException e) {\n" 355 " HandleException(e);\n" 356 "}"); 357 verifyFormat("try {\n" 358 " Something();\n" 359 "} finally {\n" 360 " AlwaysDoThis();\n" 361 "}"); 362 verifyFormat("try {\n" 363 " Something();\n" 364 "} catch (SomeException e) {\n" 365 " HandleException(e);\n" 366 "} finally {\n" 367 " AlwaysDoThis();\n" 368 "}"); 369 370 verifyFormat("try {\n" 371 " Something();\n" 372 "} catch (SomeException | OtherException e) {\n" 373 " HandleException(e);\n" 374 "}"); 375 } 376 377 TEST_F(FormatTestJava, TryWithResources) { 378 verifyFormat("try (SomeResource rs = someFunction()) {\n" 379 " Something();\n" 380 "}"); 381 verifyFormat("try (SomeResource rs = someFunction()) {\n" 382 " Something();\n" 383 "} catch (SomeException e) {\n" 384 " HandleException(e);\n" 385 "}"); 386 } 387 388 TEST_F(FormatTestJava, SynchronizedKeyword) { 389 verifyFormat("synchronized (mData) {\n" 390 " // ...\n" 391 "}"); 392 } 393 394 TEST_F(FormatTestJava, PackageDeclarations) { 395 verifyFormat("package some.really.loooooooooooooooooooooong.package;", 396 getStyleWithColumns(50)); 397 } 398 399 TEST_F(FormatTestJava, ImportDeclarations) { 400 verifyFormat("import some.really.loooooooooooooooooooooong.imported.Class;", 401 getStyleWithColumns(50)); 402 verifyFormat("import static some.really.looooooooooooooooong.imported.Class;", 403 getStyleWithColumns(50)); 404 } 405 406 TEST_F(FormatTestJava, MethodDeclarations) { 407 verifyFormat("void methodName(Object arg1,\n" 408 " Object arg2, Object arg3) {}", 409 getStyleWithColumns(40)); 410 verifyFormat("void methodName(\n" 411 " Object arg1, Object arg2) {}", 412 getStyleWithColumns(40)); 413 } 414 415 TEST_F(FormatTestJava, CppKeywords) { 416 verifyFormat("public void union(Type a, Type b);"); 417 verifyFormat("public void struct(Object o);"); 418 verifyFormat("public void delete(Object o);"); 419 } 420 421 TEST_F(FormatTestJava, NeverAlignAfterReturn) { 422 verifyFormat("return aaaaaaaaaaaaaaaaaaa\n" 423 " && bbbbbbbbbbbbbbbbbbb\n" 424 " && ccccccccccccccccccc;", 425 getStyleWithColumns(40)); 426 verifyFormat("return (result == null)\n" 427 " ? aaaaaaaaaaaaaaaaa\n" 428 " : bbbbbbbbbbbbbbbbb;", 429 getStyleWithColumns(40)); 430 verifyFormat("return aaaaaaaaaaaaaaaaaaa()\n" 431 " .bbbbbbbbbbbbbbbbbbb()\n" 432 " .ccccccccccccccccccc();", 433 getStyleWithColumns(40)); 434 verifyFormat("return aaaaaaaaaaaaaaaaaaa()\n" 435 " .bbbbbbbbbbbbbbbbbbb(\n" 436 " ccccccccccccccc)\n" 437 " .ccccccccccccccccccc();", 438 getStyleWithColumns(40)); 439 } 440 441 TEST_F(FormatTestJava, FormatsInnerBlocks) { 442 verifyFormat("someObject.someFunction(new Runnable() {\n" 443 " @Override\n" 444 " public void run() {\n" 445 " System.out.println(42);\n" 446 " }\n" 447 "}, someOtherParameter);"); 448 verifyFormat("someFunction(new Runnable() {\n" 449 " public void run() {\n" 450 " System.out.println(42);\n" 451 " }\n" 452 "});"); 453 verifyFormat("someObject.someFunction(\n" 454 " new Runnable() {\n" 455 " @Override\n" 456 " public void run() {\n" 457 " System.out.println(42);\n" 458 " }\n" 459 " },\n" 460 " new Runnable() {\n" 461 " @Override\n" 462 " public void run() {\n" 463 " System.out.println(43);\n" 464 " }\n" 465 " },\n" 466 " someOtherParameter);"); 467 } 468 469 TEST_F(FormatTestJava, FormatsLambdas) { 470 verifyFormat("(aaaaaaaaaa, bbbbbbbbbb) -> aaaaaaaaaa + bbbbbbbbbb;"); 471 verifyFormat("(aaaaaaaaaa, bbbbbbbbbb)\n" 472 " -> aaaaaaaaaa + bbbbbbbbbb;", 473 getStyleWithColumns(40)); 474 verifyFormat("Runnable someLambda = () -> DoSomething();"); 475 verifyFormat("Runnable someLambda = () -> {\n" 476 " DoSomething();\n" 477 "}"); 478 479 verifyFormat("Runnable someLambda =\n" 480 " (int aaaaa) -> DoSomething(aaaaa);", 481 getStyleWithColumns(40)); 482 } 483 484 TEST_F(FormatTestJava, BreaksStringLiterals) { 485 // FIXME: String literal breaking is currently disabled for Java and JS, as it 486 // requires strings to be merged using "+" which we don't support. 487 EXPECT_EQ("\"some text other\";", 488 format("\"some text other\";", getStyleWithColumns(14))); 489 } 490 491 TEST_F(FormatTestJava, AlignsBlockComments) { 492 EXPECT_EQ("/*\n" 493 " * Really multi-line\n" 494 " * comment.\n" 495 " */\n" 496 "void f() {}", 497 format(" /*\n" 498 " * Really multi-line\n" 499 " * comment.\n" 500 " */\n" 501 " void f() {}")); 502 } 503 504 } // end namespace tooling 505 } // end namespace clang 506
