1 //===- unittest/Format/FormatTest.cpp - Formatting unit tests -------------===// 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 #define DEBUG_TYPE "format-test" 11 12 #include "clang/Format/Format.h" 13 #include "clang/Lex/Lexer.h" 14 #include "llvm/Support/Debug.h" 15 #include "gtest/gtest.h" 16 17 namespace clang { 18 namespace format { 19 20 class FormatTest : public ::testing::Test { 21 protected: 22 std::string format(llvm::StringRef Code, unsigned Offset, unsigned Length, 23 const FormatStyle &Style) { 24 DEBUG(llvm::errs() << "---\n"); 25 std::vector<tooling::Range> Ranges(1, tooling::Range(Offset, Length)); 26 tooling::Replacements Replaces = reformat(Style, Code, Ranges); 27 ReplacementCount = Replaces.size(); 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 std::string 35 format(llvm::StringRef Code, const FormatStyle &Style = getLLVMStyle()) { 36 return format(Code, 0, Code.size(), Style); 37 } 38 39 std::string messUp(llvm::StringRef Code) { 40 std::string MessedUp(Code.str()); 41 bool InComment = false; 42 bool InPreprocessorDirective = false; 43 bool JustReplacedNewline = false; 44 for (unsigned i = 0, e = MessedUp.size() - 1; i != e; ++i) { 45 if (MessedUp[i] == '/' && MessedUp[i + 1] == '/') { 46 if (JustReplacedNewline) 47 MessedUp[i - 1] = '\n'; 48 InComment = true; 49 } else if (MessedUp[i] == '#' && (JustReplacedNewline || i == 0)) { 50 if (i != 0) 51 MessedUp[i - 1] = '\n'; 52 InPreprocessorDirective = true; 53 } else if (MessedUp[i] == '\\' && MessedUp[i + 1] == '\n') { 54 MessedUp[i] = ' '; 55 MessedUp[i + 1] = ' '; 56 } else if (MessedUp[i] == '\n') { 57 if (InComment) { 58 InComment = false; 59 } else if (InPreprocessorDirective) { 60 InPreprocessorDirective = false; 61 } else { 62 JustReplacedNewline = true; 63 MessedUp[i] = ' '; 64 } 65 } else if (MessedUp[i] != ' ') { 66 JustReplacedNewline = false; 67 } 68 } 69 return MessedUp; 70 } 71 72 FormatStyle getLLVMStyleWithColumns(unsigned ColumnLimit) { 73 FormatStyle Style = getLLVMStyle(); 74 Style.ColumnLimit = ColumnLimit; 75 return Style; 76 } 77 78 FormatStyle getGoogleStyleWithColumns(unsigned ColumnLimit) { 79 FormatStyle Style = getGoogleStyle(); 80 Style.ColumnLimit = ColumnLimit; 81 return Style; 82 } 83 84 void verifyFormat(llvm::StringRef Code, 85 const FormatStyle &Style = getLLVMStyle()) { 86 EXPECT_EQ(Code.str(), format(messUp(Code), Style)); 87 } 88 89 void verifyGoogleFormat(llvm::StringRef Code) { 90 verifyFormat(Code, getGoogleStyle()); 91 } 92 93 void verifyIndependentOfContext(llvm::StringRef text) { 94 verifyFormat(text); 95 verifyFormat(llvm::Twine("void f() { " + text + " }").str()); 96 } 97 98 int ReplacementCount; 99 }; 100 101 TEST_F(FormatTest, MessUp) { 102 EXPECT_EQ("1 2 3", messUp("1 2 3")); 103 EXPECT_EQ("1 2 3\n", messUp("1\n2\n3\n")); 104 EXPECT_EQ("a\n//b\nc", messUp("a\n//b\nc")); 105 EXPECT_EQ("a\n#b\nc", messUp("a\n#b\nc")); 106 EXPECT_EQ("a\n#b c d\ne", messUp("a\n#b\\\nc\\\nd\ne")); 107 } 108 109 //===----------------------------------------------------------------------===// 110 // Basic function tests. 111 //===----------------------------------------------------------------------===// 112 113 TEST_F(FormatTest, DoesNotChangeCorrectlyFormattedCode) { 114 EXPECT_EQ(";", format(";")); 115 } 116 117 TEST_F(FormatTest, FormatsGlobalStatementsAt0) { 118 EXPECT_EQ("int i;", format(" int i;")); 119 EXPECT_EQ("\nint i;", format(" \n\t \r int i;")); 120 EXPECT_EQ("int i;\nint j;", format(" int i; int j;")); 121 EXPECT_EQ("int i;\nint j;", format(" int i;\n int j;")); 122 } 123 124 TEST_F(FormatTest, FormatsUnwrappedLinesAtFirstFormat) { 125 EXPECT_EQ("int i;", format("int\ni;")); 126 } 127 128 TEST_F(FormatTest, FormatsNestedBlockStatements) { 129 EXPECT_EQ("{\n {\n {}\n }\n}", format("{{{}}}")); 130 } 131 132 TEST_F(FormatTest, FormatsNestedCall) { 133 verifyFormat("Method(f1, f2(f3));"); 134 verifyFormat("Method(f1(f2, f3()));"); 135 verifyFormat("Method(f1(f2, (f3())));"); 136 } 137 138 TEST_F(FormatTest, NestedNameSpecifiers) { 139 verifyFormat("vector< ::Type> v;"); 140 verifyFormat("::ns::SomeFunction(::ns::SomeOtherFunction())"); 141 verifyFormat("static constexpr bool Bar = decltype(bar())::value;"); 142 } 143 144 TEST_F(FormatTest, OnlyGeneratesNecessaryReplacements) { 145 EXPECT_EQ("if (a) {\n" 146 " f();\n" 147 "}", 148 format("if(a){f();}")); 149 EXPECT_EQ(4, ReplacementCount); 150 EXPECT_EQ("if (a) {\n" 151 " f();\n" 152 "}", 153 format("if (a) {\n" 154 " f();\n" 155 "}")); 156 EXPECT_EQ(0, ReplacementCount); 157 } 158 159 TEST_F(FormatTest, RemovesTrailingWhitespaceOfFormattedLine) { 160 EXPECT_EQ("int a;\nint b;", format("int a; \nint b;", 0, 0, getLLVMStyle())); 161 EXPECT_EQ("int a;", format("int a; ")); 162 EXPECT_EQ("int a;\n", format("int a; \n \n \n ")); 163 EXPECT_EQ("int a;\nint b; ", 164 format("int a; \nint b; ", 0, 0, getLLVMStyle())); 165 } 166 167 TEST_F(FormatTest, FormatsCorrectRegionForLeadingWhitespace) { 168 EXPECT_EQ("int b;\nint a;", 169 format("int b;\n int a;", 7, 0, getLLVMStyle())); 170 EXPECT_EQ("int b;\n int a;", 171 format("int b;\n int a;", 6, 0, getLLVMStyle())); 172 173 EXPECT_EQ("#define A \\\n" 174 " int a; \\\n" 175 " int b;", 176 format("#define A \\\n" 177 " int a; \\\n" 178 " int b;", 179 26, 0, getLLVMStyleWithColumns(12))); 180 EXPECT_EQ("#define A \\\n" 181 " int a; \\\n" 182 " int b;", 183 format("#define A \\\n" 184 " int a; \\\n" 185 " int b;", 186 25, 0, getLLVMStyleWithColumns(12))); 187 } 188 189 TEST_F(FormatTest, RemovesWhitespaceWhenTriggeredOnEmptyLine) { 190 EXPECT_EQ("int a;\n\n int b;", 191 format("int a;\n \n\n int b;", 7, 0, getLLVMStyle())); 192 EXPECT_EQ("int a;\n\n int b;", 193 format("int a;\n \n\n int b;", 9, 0, getLLVMStyle())); 194 } 195 196 TEST_F(FormatTest, RemovesEmptyLines) { 197 EXPECT_EQ("class C {\n" 198 " int i;\n" 199 "};", 200 format("class C {\n" 201 " int i;\n" 202 "\n" 203 "};")); 204 205 // Don't remove empty lines in more complex control statements. 206 EXPECT_EQ("void f() {\n" 207 " if (a) {\n" 208 " f();\n" 209 "\n" 210 " } else if (b) {\n" 211 " f();\n" 212 " }\n" 213 "}", 214 format("void f() {\n" 215 " if (a) {\n" 216 " f();\n" 217 "\n" 218 " } else if (b) {\n" 219 " f();\n" 220 "\n" 221 " }\n" 222 "\n" 223 "}")); 224 225 // FIXME: This is slightly inconsistent. 226 EXPECT_EQ("namespace {\n" 227 "int i;\n" 228 "}", 229 format("namespace {\n" 230 "int i;\n" 231 "\n" 232 "}")); 233 EXPECT_EQ("namespace {\n" 234 "int i;\n" 235 "\n" 236 "} // namespace", 237 format("namespace {\n" 238 "int i;\n" 239 "\n" 240 "} // namespace")); 241 } 242 243 TEST_F(FormatTest, ReformatsMovedLines) { 244 EXPECT_EQ( 245 "template <typename T> T *getFETokenInfo() const {\n" 246 " return static_cast<T *>(FETokenInfo);\n" 247 "}\n" 248 " int a; // <- Should not be formatted", 249 format( 250 "template<typename T>\n" 251 "T *getFETokenInfo() const { return static_cast<T*>(FETokenInfo); }\n" 252 " int a; // <- Should not be formatted", 253 9, 5, getLLVMStyle())); 254 } 255 256 //===----------------------------------------------------------------------===// 257 // Tests for control statements. 258 //===----------------------------------------------------------------------===// 259 260 TEST_F(FormatTest, FormatIfWithoutCompoundStatement) { 261 verifyFormat("if (true)\n f();\ng();"); 262 verifyFormat("if (a)\n if (b)\n if (c)\n g();\nh();"); 263 verifyFormat("if (a)\n if (b) {\n f();\n }\ng();"); 264 265 FormatStyle AllowsMergedIf = getLLVMStyle(); 266 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = true; 267 verifyFormat("if (a)\n" 268 " // comment\n" 269 " f();", 270 AllowsMergedIf); 271 verifyFormat("if (a)\n" 272 " ;", 273 AllowsMergedIf); 274 verifyFormat("if (a)\n" 275 " if (b) return;", 276 AllowsMergedIf); 277 278 verifyFormat("if (a) // Can't merge this\n" 279 " f();\n", 280 AllowsMergedIf); 281 verifyFormat("if (a) /* still don't merge */\n" 282 " f();", 283 AllowsMergedIf); 284 verifyFormat("if (a) { // Never merge this\n" 285 " f();\n" 286 "}", 287 AllowsMergedIf); 288 verifyFormat("if (a) { /* Never merge this */\n" 289 " f();\n" 290 "}", 291 AllowsMergedIf); 292 293 EXPECT_EQ("if (a) return;", format("if(a)\nreturn;", 7, 1, AllowsMergedIf)); 294 EXPECT_EQ("if (a) return; // comment", 295 format("if(a)\nreturn; // comment", 20, 1, AllowsMergedIf)); 296 297 AllowsMergedIf.ColumnLimit = 14; 298 verifyFormat("if (a) return;", AllowsMergedIf); 299 verifyFormat("if (aaaaaaaaa)\n" 300 " return;", 301 AllowsMergedIf); 302 303 AllowsMergedIf.ColumnLimit = 13; 304 verifyFormat("if (a)\n return;", AllowsMergedIf); 305 } 306 307 TEST_F(FormatTest, FormatLoopsWithoutCompoundStatement) { 308 FormatStyle AllowsMergedLoops = getLLVMStyle(); 309 AllowsMergedLoops.AllowShortLoopsOnASingleLine = true; 310 verifyFormat("while (true) continue;", AllowsMergedLoops); 311 verifyFormat("for (;;) continue;", AllowsMergedLoops); 312 verifyFormat("for (int &v : vec) v *= 2;", AllowsMergedLoops); 313 verifyFormat("while (true)\n" 314 " ;", 315 AllowsMergedLoops); 316 verifyFormat("for (;;)\n" 317 " ;", 318 AllowsMergedLoops); 319 verifyFormat("for (;;)\n" 320 " for (;;) continue;", 321 AllowsMergedLoops); 322 verifyFormat("for (;;) // Can't merge this\n" 323 " continue;", 324 AllowsMergedLoops); 325 verifyFormat("for (;;) /* still don't merge */\n" 326 " continue;", 327 AllowsMergedLoops); 328 } 329 330 TEST_F(FormatTest, ParseIfElse) { 331 verifyFormat("if (true)\n" 332 " if (true)\n" 333 " if (true)\n" 334 " f();\n" 335 " else\n" 336 " g();\n" 337 " else\n" 338 " h();\n" 339 "else\n" 340 " i();"); 341 verifyFormat("if (true)\n" 342 " if (true)\n" 343 " if (true) {\n" 344 " if (true)\n" 345 " f();\n" 346 " } else {\n" 347 " g();\n" 348 " }\n" 349 " else\n" 350 " h();\n" 351 "else {\n" 352 " i();\n" 353 "}"); 354 } 355 356 TEST_F(FormatTest, ElseIf) { 357 verifyFormat("if (a) {\n} else if (b) {\n}"); 358 verifyFormat("if (a)\n" 359 " f();\n" 360 "else if (b)\n" 361 " g();\n" 362 "else\n" 363 " h();"); 364 } 365 366 TEST_F(FormatTest, FormatsForLoop) { 367 verifyFormat( 368 "for (int VeryVeryLongLoopVariable = 0; VeryVeryLongLoopVariable < 10;\n" 369 " ++VeryVeryLongLoopVariable)\n" 370 " ;"); 371 verifyFormat("for (;;)\n" 372 " f();"); 373 verifyFormat("for (;;) {\n}"); 374 verifyFormat("for (;;) {\n" 375 " f();\n" 376 "}"); 377 verifyFormat("for (int i = 0; (i < 10); ++i) {\n}"); 378 379 verifyFormat( 380 "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n" 381 " E = UnwrappedLines.end();\n" 382 " I != E; ++I) {\n}"); 383 384 verifyFormat( 385 "for (MachineFun::iterator IIII = PrevIt, EEEE = F.end(); IIII != EEEE;\n" 386 " ++IIIII) {\n}"); 387 verifyFormat("for (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaa =\n" 388 " aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa;\n" 389 " aaaaaaaaaaa != aaaaaaaaaaaaaaaaaaa; ++aaaaaaaaaaa) {\n}"); 390 verifyFormat("for (llvm::ArrayRef<NamedDecl *>::iterator\n" 391 " I = FD->getDeclsInPrototypeScope().begin(),\n" 392 " E = FD->getDeclsInPrototypeScope().end();\n" 393 " I != E; ++I) {\n}"); 394 395 // FIXME: Not sure whether we want extra identation in line 3 here: 396 verifyFormat( 397 "for (aaaaaaaaaaaaaaaaa aaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n" 398 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa !=\n" 399 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 400 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 401 " ++aaaaaaaaaaa) {\n}"); 402 verifyFormat("for (int aaaaaaaaaaa = 1; aaaaaaaaaaa <= bbbbbbbbbbbbbbb;\n" 403 " aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n" 404 "}"); 405 verifyFormat("for (some_namespace::SomeIterator iter( // force break\n" 406 " aaaaaaaaaa);\n" 407 " iter; ++iter) {\n" 408 "}"); 409 410 FormatStyle NoBinPacking = getLLVMStyle(); 411 NoBinPacking.BinPackParameters = false; 412 verifyFormat("for (int aaaaaaaaaaa = 1;\n" 413 " aaaaaaaaaaa <= aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa,\n" 414 " aaaaaaaaaaaaaaaa,\n" 415 " aaaaaaaaaaaaaaaa,\n" 416 " aaaaaaaaaaaaaaaa);\n" 417 " aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n" 418 "}", 419 NoBinPacking); 420 verifyFormat( 421 "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n" 422 " E = UnwrappedLines.end();\n" 423 " I != E;\n" 424 " ++I) {\n}", 425 NoBinPacking); 426 } 427 428 TEST_F(FormatTest, RangeBasedForLoops) { 429 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 430 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 431 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaa :\n" 432 " aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa, aaaaaaaaaaaaa)) {\n}"); 433 verifyFormat("for (const aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaa :\n" 434 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 435 } 436 437 TEST_F(FormatTest, FormatsWhileLoop) { 438 verifyFormat("while (true) {\n}"); 439 verifyFormat("while (true)\n" 440 " f();"); 441 verifyFormat("while () {\n}"); 442 verifyFormat("while () {\n" 443 " f();\n" 444 "}"); 445 } 446 447 TEST_F(FormatTest, FormatsDoWhile) { 448 verifyFormat("do {\n" 449 " do_something();\n" 450 "} while (something());"); 451 verifyFormat("do\n" 452 " do_something();\n" 453 "while (something());"); 454 } 455 456 TEST_F(FormatTest, FormatsSwitchStatement) { 457 verifyFormat("switch (x) {\n" 458 "case 1:\n" 459 " f();\n" 460 " break;\n" 461 "case kFoo:\n" 462 "case ns::kBar:\n" 463 "case kBaz:\n" 464 " break;\n" 465 "default:\n" 466 " g();\n" 467 " break;\n" 468 "}"); 469 verifyFormat("switch (x) {\n" 470 "case 1: {\n" 471 " f();\n" 472 " break;\n" 473 "}\n" 474 "}"); 475 verifyFormat("switch (x) {\n" 476 "case 1: {\n" 477 " f();\n" 478 " {\n" 479 " g();\n" 480 " h();\n" 481 " }\n" 482 " break;\n" 483 "}\n" 484 "}"); 485 verifyFormat("switch (x) {\n" 486 "case 1: {\n" 487 " f();\n" 488 " if (foo) {\n" 489 " g();\n" 490 " h();\n" 491 " }\n" 492 " break;\n" 493 "}\n" 494 "}"); 495 verifyFormat("switch (x) {\n" 496 "case 1: {\n" 497 " f();\n" 498 " g();\n" 499 "} break;\n" 500 "}"); 501 verifyFormat("switch (test)\n" 502 " ;"); 503 verifyFormat("switch (x) {\n" 504 "default: {\n" 505 " // Do nothing.\n" 506 "}\n" 507 "}"); 508 verifyFormat("switch (x) {\n" 509 "// comment\n" 510 "// if 1, do f()\n" 511 "case 1:\n" 512 " f();\n" 513 "}"); 514 verifyFormat("switch (x) {\n" 515 "case 1:\n" 516 " // Do amazing stuff\n" 517 " {\n" 518 " f();\n" 519 " g();\n" 520 " }\n" 521 " break;\n" 522 "}"); 523 verifyFormat("#define A \\\n" 524 " switch (x) { \\\n" 525 " case a: \\\n" 526 " foo = b; \\\n" 527 " }", getLLVMStyleWithColumns(20)); 528 verifyFormat("#define OPERATION_CASE(name) \\\n" 529 " case OP_name: \\\n" 530 " return operations::Operation##name\n", 531 getLLVMStyleWithColumns(40)); 532 533 verifyGoogleFormat("switch (x) {\n" 534 " case 1:\n" 535 " f();\n" 536 " break;\n" 537 " case kFoo:\n" 538 " case ns::kBar:\n" 539 " case kBaz:\n" 540 " break;\n" 541 " default:\n" 542 " g();\n" 543 " break;\n" 544 "}"); 545 verifyGoogleFormat("switch (x) {\n" 546 " case 1: {\n" 547 " f();\n" 548 " break;\n" 549 " }\n" 550 "}"); 551 verifyGoogleFormat("switch (test)\n" 552 " ;"); 553 554 verifyGoogleFormat("#define OPERATION_CASE(name) \\\n" 555 " case OP_name: \\\n" 556 " return operations::Operation##name\n"); 557 verifyGoogleFormat("Operation codeToOperation(OperationCode OpCode) {\n" 558 " // Get the correction operation class.\n" 559 " switch (OpCode) {\n" 560 " CASE(Add);\n" 561 " CASE(Subtract);\n" 562 " default:\n" 563 " return operations::Unknown;\n" 564 " }\n" 565 "#undef OPERATION_CASE\n" 566 "}"); 567 verifyFormat("DEBUG({\n" 568 " switch (x) {\n" 569 " case A:\n" 570 " f();\n" 571 " break;\n" 572 " // On B:\n" 573 " case B:\n" 574 " g();\n" 575 " break;\n" 576 " }\n" 577 "});"); 578 } 579 580 TEST_F(FormatTest, FormatsLabels) { 581 verifyFormat("void f() {\n" 582 " some_code();\n" 583 "test_label:\n" 584 " some_other_code();\n" 585 " {\n" 586 " some_more_code();\n" 587 " another_label:\n" 588 " some_more_code();\n" 589 " }\n" 590 "}"); 591 verifyFormat("some_code();\n" 592 "test_label:\n" 593 "some_other_code();"); 594 } 595 596 //===----------------------------------------------------------------------===// 597 // Tests for comments. 598 //===----------------------------------------------------------------------===// 599 600 TEST_F(FormatTest, UnderstandsSingleLineComments) { 601 verifyFormat("//* */"); 602 verifyFormat("// line 1\n" 603 "// line 2\n" 604 "void f() {}\n"); 605 606 verifyFormat("void f() {\n" 607 " // Doesn't do anything\n" 608 "}"); 609 verifyFormat("SomeObject\n" 610 " // Calling someFunction on SomeObject\n" 611 " .someFunction();"); 612 verifyFormat("void f(int i, // some comment (probably for i)\n" 613 " int j, // some comment (probably for j)\n" 614 " int k); // some comment (probably for k)"); 615 verifyFormat("void f(int i,\n" 616 " // some comment (probably for j)\n" 617 " int j,\n" 618 " // some comment (probably for k)\n" 619 " int k);"); 620 621 verifyFormat("int i // This is a fancy variable\n" 622 " = 5; // with nicely aligned comment."); 623 624 verifyFormat("// Leading comment.\n" 625 "int a; // Trailing comment."); 626 verifyFormat("int a; // Trailing comment\n" 627 " // on 2\n" 628 " // or 3 lines.\n" 629 "int b;"); 630 verifyFormat("int a; // Trailing comment\n" 631 "\n" 632 "// Leading comment.\n" 633 "int b;"); 634 verifyFormat("int a; // Comment.\n" 635 " // More details.\n" 636 "int bbbb; // Another comment."); 637 verifyFormat( 638 "int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa; // comment\n" 639 "int bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb; // comment\n" 640 "int cccccccccccccccccccccccccccccc; // comment\n" 641 "int ddd; // looooooooooooooooooooooooong comment\n" 642 "int aaaaaaaaaaaaaaaaaaaaaaa; // comment\n" 643 "int bbbbbbbbbbbbbbbbbbbbb; // comment\n" 644 "int ccccccccccccccccccc; // comment"); 645 646 verifyFormat("#include \"a\" // comment\n" 647 "#include \"a/b/c\" // comment"); 648 verifyFormat("#include <a> // comment\n" 649 "#include <a/b/c> // comment"); 650 EXPECT_EQ("#include \\\n" 651 " \"a\" // comment\n" 652 "#include \"a/b/c\" // comment", 653 format("#include \\\n" 654 " \"a\" // comment\n" 655 "#include \"a/b/c\" // comment")); 656 657 verifyFormat("enum E {\n" 658 " // comment\n" 659 " VAL_A, // comment\n" 660 " VAL_B\n" 661 "};"); 662 663 verifyFormat( 664 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 665 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb; // Trailing comment"); 666 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 667 " // Comment inside a statement.\n" 668 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 669 verifyFormat( 670 "bool aaaaaaaaaaaaa = // comment\n" 671 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 672 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 673 674 verifyFormat("int aaaa; // aaaaa\n" 675 "int aa; // aaaaaaa", 676 getLLVMStyleWithColumns(20)); 677 678 EXPECT_EQ("void f() { // This does something ..\n" 679 "}\n" 680 "int a; // This is unrelated", 681 format("void f() { // This does something ..\n" 682 " }\n" 683 "int a; // This is unrelated")); 684 EXPECT_EQ("class C {\n" 685 " void f() { // This does something ..\n" 686 " } // awesome..\n" 687 "\n" 688 " int a; // This is unrelated\n" 689 "};", 690 format("class C{void f() { // This does something ..\n" 691 " } // awesome..\n" 692 " \n" 693 "int a; // This is unrelated\n" 694 "};")); 695 696 EXPECT_EQ("int i; // single line trailing comment", 697 format("int i;\\\n// single line trailing comment")); 698 699 verifyGoogleFormat("int a; // Trailing comment."); 700 701 verifyFormat("someFunction(anotherFunction( // Force break.\n" 702 " parameter));"); 703 704 verifyGoogleFormat("#endif // HEADER_GUARD"); 705 706 verifyFormat("const char *test[] = {\n" 707 " // A\n" 708 " \"aaaa\",\n" 709 " // B\n" 710 " \"aaaaa\",\n" 711 "};"); 712 verifyGoogleFormat( 713 "aaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 714 " aaaaaaaaaaaaaaaaaaaaaa); // 81_cols_with_this_comment"); 715 EXPECT_EQ("D(a, {\n" 716 " // test\n" 717 " int a;\n" 718 "});", 719 format("D(a, {\n" 720 "// test\n" 721 "int a;\n" 722 "});")); 723 724 EXPECT_EQ("lineWith(); // comment\n" 725 "// at start\n" 726 "otherLine();", 727 format("lineWith(); // comment\n" 728 "// at start\n" 729 "otherLine();")); 730 EXPECT_EQ("lineWith(); // comment\n" 731 " // at start\n" 732 "otherLine();", 733 format("lineWith(); // comment\n" 734 " // at start\n" 735 "otherLine();")); 736 737 EXPECT_EQ("lineWith(); // comment\n" 738 "// at start\n" 739 "otherLine(); // comment", 740 format("lineWith(); // comment\n" 741 "// at start\n" 742 "otherLine(); // comment")); 743 EXPECT_EQ("lineWith();\n" 744 "// at start\n" 745 "otherLine(); // comment", 746 format("lineWith();\n" 747 " // at start\n" 748 "otherLine(); // comment")); 749 EXPECT_EQ("// first\n" 750 "// at start\n" 751 "otherLine(); // comment", 752 format("// first\n" 753 " // at start\n" 754 "otherLine(); // comment")); 755 EXPECT_EQ("f();\n" 756 "// first\n" 757 "// at start\n" 758 "otherLine(); // comment", 759 format("f();\n" 760 "// first\n" 761 " // at start\n" 762 "otherLine(); // comment")); 763 } 764 765 TEST_F(FormatTest, CanFormatCommentsLocally) { 766 EXPECT_EQ("int a; // comment\n" 767 "int b; // comment", 768 format("int a; // comment\n" 769 "int b; // comment", 770 0, 0, getLLVMStyle())); 771 EXPECT_EQ("int a; // comment\n" 772 " // line 2\n" 773 "int b;", 774 format("int a; // comment\n" 775 " // line 2\n" 776 "int b;", 777 28, 0, getLLVMStyle())); 778 EXPECT_EQ("int aaaaaa; // comment\n" 779 "int b;\n" 780 "int c; // unrelated comment", 781 format("int aaaaaa; // comment\n" 782 "int b;\n" 783 "int c; // unrelated comment", 784 31, 0, getLLVMStyle())); 785 } 786 787 TEST_F(FormatTest, RemovesTrailingWhitespaceOfComments) { 788 EXPECT_EQ("// comment", format("// comment ")); 789 EXPECT_EQ("int aaaaaaa, bbbbbbb; // comment", 790 format("int aaaaaaa, bbbbbbb; // comment ", 791 getLLVMStyleWithColumns(33))); 792 EXPECT_EQ("// comment\\\n", format("// comment\\\n \t \v \f ")); 793 EXPECT_EQ("// comment \\\n", format("// comment \\\n \t \v \f ")); 794 } 795 796 TEST_F(FormatTest, UnderstandsBlockComments) { 797 verifyFormat("f(/*noSpaceAfterParameterNamingComment=*/true);"); 798 EXPECT_EQ( 799 "f(aaaaaaaaaaaaaaaaaaaaaaaaa, /* Trailing comment for aa... */\n" 800 " bbbbbbbbbbbbbbbbbbbbbbbbb);", 801 format("f(aaaaaaaaaaaaaaaaaaaaaaaaa , \\\n/* Trailing comment for aa... */\n" 802 " bbbbbbbbbbbbbbbbbbbbbbbbb);")); 803 EXPECT_EQ( 804 "f(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 805 " /* Leading comment for bb... */ bbbbbbbbbbbbbbbbbbbbbbbbb);", 806 format("f(aaaaaaaaaaaaaaaaaaaaaaaaa , \n" 807 "/* Leading comment for bb... */ bbbbbbbbbbbbbbbbbbbbbbbbb);")); 808 EXPECT_EQ( 809 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 810 " aaaaaaaaaaaaaaaaaa,\n" 811 " aaaaaaaaaaaaaaaaaa) { /*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*/\n" 812 "}", 813 format("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 814 " aaaaaaaaaaaaaaaaaa ,\n" 815 " aaaaaaaaaaaaaaaaaa) { /*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*/\n" 816 "}")); 817 818 FormatStyle NoBinPacking = getLLVMStyle(); 819 NoBinPacking.BinPackParameters = false; 820 verifyFormat("aaaaaaaa(/* parameter 1 */ aaaaaa,\n" 821 " /* parameter 2 */ aaaaaa,\n" 822 " /* parameter 3 */ aaaaaa,\n" 823 " /* parameter 4 */ aaaaaa);", 824 NoBinPacking); 825 } 826 827 TEST_F(FormatTest, AlignsBlockComments) { 828 EXPECT_EQ("/*\n" 829 " * Really multi-line\n" 830 " * comment.\n" 831 " */\n" 832 "void f() {}", 833 format(" /*\n" 834 " * Really multi-line\n" 835 " * comment.\n" 836 " */\n" 837 " void f() {}")); 838 EXPECT_EQ("class C {\n" 839 " /*\n" 840 " * Another multi-line\n" 841 " * comment.\n" 842 " */\n" 843 " void f() {}\n" 844 "};", 845 format("class C {\n" 846 "/*\n" 847 " * Another multi-line\n" 848 " * comment.\n" 849 " */\n" 850 "void f() {}\n" 851 "};")); 852 EXPECT_EQ("/*\n" 853 " 1. This is a comment with non-trivial formatting.\n" 854 " 1.1. We have to indent/outdent all lines equally\n" 855 " 1.1.1. to keep the formatting.\n" 856 " */", 857 format(" /*\n" 858 " 1. This is a comment with non-trivial formatting.\n" 859 " 1.1. We have to indent/outdent all lines equally\n" 860 " 1.1.1. to keep the formatting.\n" 861 " */")); 862 EXPECT_EQ("/*\n" 863 "Don't try to outdent if there's not enough indentation.\n" 864 "*/", 865 format(" /*\n" 866 " Don't try to outdent if there's not enough indentation.\n" 867 " */")); 868 869 EXPECT_EQ("int i; /* Comment with empty...\n" 870 " *\n" 871 " * line. */", 872 format("int i; /* Comment with empty...\n" 873 " *\n" 874 " * line. */")); 875 } 876 877 TEST_F(FormatTest, CorrectlyHandlesLengthOfBlockComments) { 878 EXPECT_EQ("double *x; /* aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 879 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa */", 880 format("double *x; /* aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 881 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa */")); 882 EXPECT_EQ( 883 "void ffffffffffff(\n" 884 " int aaaaaaaa, int bbbbbbbb,\n" 885 " int cccccccccccc) { /*\n" 886 " aaaaaaaaaa\n" 887 " aaaaaaaaaaaaa\n" 888 " bbbbbbbbbbbbbb\n" 889 " bbbbbbbbbb\n" 890 " */\n" 891 "}", 892 format("void ffffffffffff(int aaaaaaaa, int bbbbbbbb, int cccccccccccc)\n" 893 "{ /*\n" 894 " aaaaaaaaaa aaaaaaaaaaaaa\n" 895 " bbbbbbbbbbbbbb bbbbbbbbbb\n" 896 " */\n" 897 "}", 898 getLLVMStyleWithColumns(40))); 899 } 900 901 TEST_F(FormatTest, DontBreakNonTrailingBlockComments) { 902 EXPECT_EQ("void\n" 903 "ffffffffff(int aaaaa /* test */);", 904 format("void ffffffffff(int aaaaa /* test */);", 905 getLLVMStyleWithColumns(35))); 906 } 907 908 TEST_F(FormatTest, SplitsLongCxxComments) { 909 EXPECT_EQ("// A comment that\n" 910 "// doesn't fit on\n" 911 "// one line", 912 format("// A comment that doesn't fit on one line", 913 getLLVMStyleWithColumns(20))); 914 EXPECT_EQ("// a b c d\n" 915 "// e f g\n" 916 "// h i j k", 917 format("// a b c d e f g h i j k", 918 getLLVMStyleWithColumns(10))); 919 EXPECT_EQ("// a b c d\n" 920 "// e f g\n" 921 "// h i j k", 922 format("\\\n// a b c d e f g h i j k", 923 getLLVMStyleWithColumns(10))); 924 EXPECT_EQ("if (true) // A comment that\n" 925 " // doesn't fit on\n" 926 " // one line", 927 format("if (true) // A comment that doesn't fit on one line ", 928 getLLVMStyleWithColumns(30))); 929 EXPECT_EQ("// Don't_touch_leading_whitespace", 930 format("// Don't_touch_leading_whitespace", 931 getLLVMStyleWithColumns(20))); 932 EXPECT_EQ("// Add leading\n" 933 "// whitespace", 934 format("//Add leading whitespace", getLLVMStyleWithColumns(20))); 935 EXPECT_EQ("// whitespace", format("//whitespace", getLLVMStyle())); 936 EXPECT_EQ("// Even if it makes the line exceed the column\n" 937 "// limit", 938 format("//Even if it makes the line exceed the column limit", 939 getLLVMStyleWithColumns(51))); 940 EXPECT_EQ("//--But not here", format("//--But not here", getLLVMStyle())); 941 EXPECT_EQ("// A comment before\n" 942 "// a macro\n" 943 "// definition\n" 944 "#define a b", 945 format("// A comment before a macro definition\n" 946 "#define a b", 947 getLLVMStyleWithColumns(20))); 948 EXPECT_EQ("void ffffff(int aaaaaaaaa, // wwww\n" 949 " int a, int bbb, // xxxxxxx\n" 950 " // yyyyyyyyy\n" 951 " int c, int d, int e) {}", 952 format("void ffffff(\n" 953 " int aaaaaaaaa, // wwww\n" 954 " int a,\n" 955 " int bbb, // xxxxxxx yyyyyyyyy\n" 956 " int c, int d, int e) {}", 957 getLLVMStyleWithColumns(40))); 958 EXPECT_EQ("//\t aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 959 format("//\t aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 960 getLLVMStyleWithColumns(20))); 961 } 962 963 TEST_F(FormatTest, DontSplitLineCommentsWithEscapedNewlines) { 964 EXPECT_EQ("// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 965 "// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 966 "// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 967 format("// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 968 "// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 969 "// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")); 970 EXPECT_EQ("int a; // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n" 971 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n" 972 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", 973 format("int a; // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n" 974 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n" 975 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", 976 getLLVMStyleWithColumns(50))); 977 // FIXME: One day we might want to implement adjustment of leading whitespace 978 // of the consecutive lines in this kind of comment: 979 EXPECT_EQ("int\n" 980 "a; // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n" 981 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n" 982 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", 983 format("int a; // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n" 984 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n" 985 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", 986 getLLVMStyleWithColumns(49))); 987 } 988 989 TEST_F(FormatTest, PriorityOfCommentBreaking) { 990 EXPECT_EQ("if (xxx ==\n" 991 " yyy && // aaaaaaaaaaaa bbbbbbbbb\n" 992 " zzz)\n" 993 " q();", 994 format("if (xxx == yyy && // aaaaaaaaaaaa bbbbbbbbb\n" 995 " zzz) q();", 996 getLLVMStyleWithColumns(40))); 997 EXPECT_EQ("if (xxxxxxxxxx ==\n" 998 " yyy && // aaaaaa bbbbbbbb cccc\n" 999 " zzz)\n" 1000 " q();", 1001 format("if (xxxxxxxxxx == yyy && // aaaaaa bbbbbbbb cccc\n" 1002 " zzz) q();", 1003 getLLVMStyleWithColumns(40))); 1004 EXPECT_EQ("if (xxxxxxxxxx &&\n" 1005 " yyy || // aaaaaa bbbbbbbb cccc\n" 1006 " zzz)\n" 1007 " q();", 1008 format("if (xxxxxxxxxx && yyy || // aaaaaa bbbbbbbb cccc\n" 1009 " zzz) q();", 1010 getLLVMStyleWithColumns(40))); 1011 EXPECT_EQ("fffffffff(&xxx, // aaaaaaaaaaaa\n" 1012 " // bbbbbbbbbbb\n" 1013 " zzz);", 1014 format("fffffffff(&xxx, // aaaaaaaaaaaa bbbbbbbbbbb\n" 1015 " zzz);", 1016 getLLVMStyleWithColumns(40))); 1017 } 1018 1019 TEST_F(FormatTest, MultiLineCommentsInDefines) { 1020 EXPECT_EQ("#define A(x) /* \\\n" 1021 " a comment \\\n" 1022 " inside */ \\\n" 1023 " f();", 1024 format("#define A(x) /* \\\n" 1025 " a comment \\\n" 1026 " inside */ \\\n" 1027 " f();", 1028 getLLVMStyleWithColumns(17))); 1029 EXPECT_EQ("#define A( \\\n" 1030 " x) /* \\\n" 1031 " a comment \\\n" 1032 " inside */ \\\n" 1033 " f();", 1034 format("#define A( \\\n" 1035 " x) /* \\\n" 1036 " a comment \\\n" 1037 " inside */ \\\n" 1038 " f();", 1039 getLLVMStyleWithColumns(17))); 1040 } 1041 1042 TEST_F(FormatTest, ParsesCommentsAdjacentToPPDirectives) { 1043 EXPECT_EQ("namespace {}\n// Test\n#define A", 1044 format("namespace {}\n // Test\n#define A")); 1045 EXPECT_EQ("namespace {}\n/* Test */\n#define A", 1046 format("namespace {}\n /* Test */\n#define A")); 1047 EXPECT_EQ("namespace {}\n/* Test */ #define A", 1048 format("namespace {}\n /* Test */ #define A")); 1049 } 1050 1051 TEST_F(FormatTest, SplitsLongLinesInComments) { 1052 EXPECT_EQ("/* This is a long\n" 1053 " * comment that\n" 1054 " * doesn't\n" 1055 " * fit on one line.\n" 1056 " */", 1057 format("/* " 1058 "This is a long " 1059 "comment that " 1060 "doesn't " 1061 "fit on one line. */", 1062 getLLVMStyleWithColumns(20))); 1063 EXPECT_EQ("/* a b c d\n" 1064 " * e f g\n" 1065 " * h i j k\n" 1066 " */", 1067 format("/* a b c d e f g h i j k */", 1068 getLLVMStyleWithColumns(10))); 1069 EXPECT_EQ("/* a b c d\n" 1070 " * e f g\n" 1071 " * h i j k\n" 1072 " */", 1073 format("\\\n/* a b c d e f g h i j k */", 1074 getLLVMStyleWithColumns(10))); 1075 EXPECT_EQ("/*\n" 1076 "This is a long\n" 1077 "comment that doesn't\n" 1078 "fit on one line.\n" 1079 "*/", 1080 format("/*\n" 1081 "This is a long " 1082 "comment that doesn't " 1083 "fit on one line. \n" 1084 "*/", getLLVMStyleWithColumns(20))); 1085 EXPECT_EQ("/*\n" 1086 " * This is a long\n" 1087 " * comment that\n" 1088 " * doesn't fit on\n" 1089 " * one line.\n" 1090 " */", 1091 format("/* \n" 1092 " * This is a long " 1093 " comment that " 1094 " doesn't fit on " 1095 " one line. \n" 1096 " */", getLLVMStyleWithColumns(20))); 1097 EXPECT_EQ("/*\n" 1098 " * This_is_a_comment_with_words_that_dont_fit_on_one_line\n" 1099 " * so_it_should_be_broken\n" 1100 " * wherever_a_space_occurs\n" 1101 " */", 1102 format("/*\n" 1103 " * This_is_a_comment_with_words_that_dont_fit_on_one_line " 1104 " so_it_should_be_broken " 1105 " wherever_a_space_occurs \n" 1106 " */", 1107 getLLVMStyleWithColumns(20))); 1108 EXPECT_EQ("/*\n" 1109 " * This_comment_can_not_be_broken_into_lines\n" 1110 " */", 1111 format("/*\n" 1112 " * This_comment_can_not_be_broken_into_lines\n" 1113 " */", 1114 getLLVMStyleWithColumns(20))); 1115 EXPECT_EQ("{\n" 1116 " /*\n" 1117 " This is another\n" 1118 " long comment that\n" 1119 " doesn't fit on one\n" 1120 " line 1234567890\n" 1121 " */\n" 1122 "}", 1123 format("{\n" 1124 "/*\n" 1125 "This is another " 1126 " long comment that " 1127 " doesn't fit on one" 1128 " line 1234567890\n" 1129 "*/\n" 1130 "}", getLLVMStyleWithColumns(20))); 1131 EXPECT_EQ("{\n" 1132 " /*\n" 1133 " * This i s\n" 1134 " * another comment\n" 1135 " * t hat doesn' t\n" 1136 " * fit on one l i\n" 1137 " * n e\n" 1138 " */\n" 1139 "}", 1140 format("{\n" 1141 "/*\n" 1142 " * This i s" 1143 " another comment" 1144 " t hat doesn' t" 1145 " fit on one l i" 1146 " n e\n" 1147 " */\n" 1148 "}", getLLVMStyleWithColumns(20))); 1149 EXPECT_EQ("/*\n" 1150 " * This is a long\n" 1151 " * comment that\n" 1152 " * doesn't fit on\n" 1153 " * one line\n" 1154 " */", 1155 format(" /*\n" 1156 " * This is a long comment that doesn't fit on one line\n" 1157 " */", getLLVMStyleWithColumns(20))); 1158 EXPECT_EQ("{\n" 1159 " if (something) /* This is a\n" 1160 " long\n" 1161 " comment */\n" 1162 " ;\n" 1163 "}", 1164 format("{\n" 1165 " if (something) /* This is a long comment */\n" 1166 " ;\n" 1167 "}", 1168 getLLVMStyleWithColumns(30))); 1169 1170 EXPECT_EQ("/* A comment before\n" 1171 " * a macro\n" 1172 " * definition */\n" 1173 "#define a b", 1174 format("/* A comment before a macro definition */\n" 1175 "#define a b", 1176 getLLVMStyleWithColumns(20))); 1177 1178 EXPECT_EQ("/* some comment\n" 1179 " * a comment\n" 1180 "* that we break\n" 1181 " * another comment\n" 1182 "* we have to break\n" 1183 "* a left comment\n" 1184 " */", 1185 format(" /* some comment\n" 1186 " * a comment that we break\n" 1187 " * another comment we have to break\n" 1188 "* a left comment\n" 1189 " */", 1190 getLLVMStyleWithColumns(20))); 1191 1192 EXPECT_EQ("/*\n" 1193 "\n" 1194 "\n" 1195 " */\n", 1196 format(" /* \n" 1197 " \n" 1198 " \n" 1199 " */\n")); 1200 } 1201 1202 TEST_F(FormatTest, SplitsLongLinesInCommentsInPreprocessor) { 1203 EXPECT_EQ("#define X \\\n" 1204 " /* \\\n" 1205 " Test \\\n" 1206 " Macro comment \\\n" 1207 " with a long \\\n" 1208 " line \\\n" 1209 " */ \\\n" 1210 " A + B", 1211 format("#define X \\\n" 1212 " /*\n" 1213 " Test\n" 1214 " Macro comment with a long line\n" 1215 " */ \\\n" 1216 " A + B", 1217 getLLVMStyleWithColumns(20))); 1218 EXPECT_EQ("#define X \\\n" 1219 " /* Macro comment \\\n" 1220 " with a long \\\n" 1221 " line */ \\\n" 1222 " A + B", 1223 format("#define X \\\n" 1224 " /* Macro comment with a long\n" 1225 " line */ \\\n" 1226 " A + B", 1227 getLLVMStyleWithColumns(20))); 1228 EXPECT_EQ("#define X \\\n" 1229 " /* Macro comment \\\n" 1230 " * with a long \\\n" 1231 " * line */ \\\n" 1232 " A + B", 1233 format("#define X \\\n" 1234 " /* Macro comment with a long line */ \\\n" 1235 " A + B", 1236 getLLVMStyleWithColumns(20))); 1237 } 1238 1239 TEST_F(FormatTest, CommentsInStaticInitializers) { 1240 EXPECT_EQ( 1241 "static SomeType type = { aaaaaaaaaaaaaaaaaaaa, /* comment */\n" 1242 " aaaaaaaaaaaaaaaaaaaa /* comment */,\n" 1243 " /* comment */ aaaaaaaaaaaaaaaaaaaa,\n" 1244 " aaaaaaaaaaaaaaaaaaaa, // comment\n" 1245 " aaaaaaaaaaaaaaaaaaaa };", 1246 format("static SomeType type = { aaaaaaaaaaaaaaaaaaaa , /* comment */\n" 1247 " aaaaaaaaaaaaaaaaaaaa /* comment */ ,\n" 1248 " /* comment */ aaaaaaaaaaaaaaaaaaaa ,\n" 1249 " aaaaaaaaaaaaaaaaaaaa , // comment\n" 1250 " aaaaaaaaaaaaaaaaaaaa };")); 1251 verifyFormat("static SomeType type = { aaaaaaaaaaa, // comment for aa...\n" 1252 " bbbbbbbbbbb, ccccccccccc };"); 1253 verifyFormat("static SomeType type = { aaaaaaaaaaa,\n" 1254 " // comment for bb....\n" 1255 " bbbbbbbbbbb, ccccccccccc };"); 1256 verifyGoogleFormat( 1257 "static SomeType type = {aaaaaaaaaaa, // comment for aa...\n" 1258 " bbbbbbbbbbb, ccccccccccc};"); 1259 verifyGoogleFormat("static SomeType type = {aaaaaaaaaaa,\n" 1260 " // comment for bb....\n" 1261 " bbbbbbbbbbb, ccccccccccc};"); 1262 1263 verifyFormat("S s = { { a, b, c }, // Group #1\n" 1264 " { d, e, f }, // Group #2\n" 1265 " { g, h, i } }; // Group #3"); 1266 verifyFormat("S s = { { // Group #1\n" 1267 " a, b, c },\n" 1268 " { // Group #2\n" 1269 " d, e, f },\n" 1270 " { // Group #3\n" 1271 " g, h, i } };"); 1272 1273 EXPECT_EQ("S s = {\n" 1274 " // Some comment\n" 1275 " a,\n" 1276 "\n" 1277 " // Comment after empty line\n" 1278 " b\n" 1279 "}", 1280 format("S s = {\n" 1281 " // Some comment\n" 1282 " a,\n" 1283 " \n" 1284 " // Comment after empty line\n" 1285 " b\n" 1286 "}")); 1287 EXPECT_EQ("S s = {\n" 1288 " /* Some comment */\n" 1289 " a,\n" 1290 "\n" 1291 " /* Comment after empty line */\n" 1292 " b\n" 1293 "}", 1294 format("S s = {\n" 1295 " /* Some comment */\n" 1296 " a,\n" 1297 " \n" 1298 " /* Comment after empty line */\n" 1299 " b\n" 1300 "}")); 1301 verifyFormat("const uint8_t aaaaaaaaaaaaaaaaaaaaaa[0] = {\n" 1302 " 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // comment\n" 1303 " 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // comment\n" 1304 " 0x00, 0x00, 0x00, 0x00 // comment\n" 1305 "};"); 1306 } 1307 1308 TEST_F(FormatTest, IgnoresIf0Contents) { 1309 EXPECT_EQ("#if 0\n" 1310 "}{)(&*(^%%#%@! fsadj f;ldjs ,:;| <<<>>>][)(][\n" 1311 "#endif\n" 1312 "void f() {}", 1313 format("#if 0\n" 1314 "}{)(&*(^%%#%@! fsadj f;ldjs ,:;| <<<>>>][)(][\n" 1315 "#endif\n" 1316 "void f( ) { }")); 1317 EXPECT_EQ("#if false\n" 1318 "void f( ) { }\n" 1319 "#endif\n" 1320 "void g() {}\n", 1321 format("#if false\n" 1322 "void f( ) { }\n" 1323 "#endif\n" 1324 "void g( ) { }\n")); 1325 EXPECT_EQ("enum E {\n" 1326 " One,\n" 1327 " Two,\n" 1328 "#if 0\n" 1329 "Three,\n" 1330 " Four,\n" 1331 "#endif\n" 1332 " Five\n" 1333 "};", 1334 format("enum E {\n" 1335 " One,Two,\n" 1336 "#if 0\n" 1337 "Three,\n" 1338 " Four,\n" 1339 "#endif\n" 1340 " Five};")); 1341 EXPECT_EQ("enum F {\n" 1342 " One,\n" 1343 "#if 1\n" 1344 " Two,\n" 1345 "#if 0\n" 1346 "Three,\n" 1347 " Four,\n" 1348 "#endif\n" 1349 " Five\n" 1350 "#endif\n" 1351 "};", 1352 format("enum F {\n" 1353 "One,\n" 1354 "#if 1\n" 1355 "Two,\n" 1356 "#if 0\n" 1357 "Three,\n" 1358 " Four,\n" 1359 "#endif\n" 1360 "Five\n" 1361 "#endif\n" 1362 "};")); 1363 EXPECT_EQ("enum G {\n" 1364 " One,\n" 1365 "#if 0\n" 1366 "Two,\n" 1367 "#else\n" 1368 " Three,\n" 1369 "#endif\n" 1370 " Four\n" 1371 "};", 1372 format("enum G {\n" 1373 "One,\n" 1374 "#if 0\n" 1375 "Two,\n" 1376 "#else\n" 1377 "Three,\n" 1378 "#endif\n" 1379 "Four\n" 1380 "};")); 1381 EXPECT_EQ("enum H {\n" 1382 " One,\n" 1383 "#if 0\n" 1384 "#ifdef Q\n" 1385 "Two,\n" 1386 "#else\n" 1387 "Three,\n" 1388 "#endif\n" 1389 "#endif\n" 1390 " Four\n" 1391 "};", 1392 format("enum H {\n" 1393 "One,\n" 1394 "#if 0\n" 1395 "#ifdef Q\n" 1396 "Two,\n" 1397 "#else\n" 1398 "Three,\n" 1399 "#endif\n" 1400 "#endif\n" 1401 "Four\n" 1402 "};")); 1403 EXPECT_EQ("enum I {\n" 1404 " One,\n" 1405 "#if /* test */ 0 || 1\n" 1406 "Two,\n" 1407 "Three,\n" 1408 "#endif\n" 1409 " Four\n" 1410 "};", 1411 format("enum I {\n" 1412 "One,\n" 1413 "#if /* test */ 0 || 1\n" 1414 "Two,\n" 1415 "Three,\n" 1416 "#endif\n" 1417 "Four\n" 1418 "};")); 1419 EXPECT_EQ("enum J {\n" 1420 " One,\n" 1421 "#if 0\n" 1422 "#if 0\n" 1423 "Two,\n" 1424 "#else\n" 1425 "Three,\n" 1426 "#endif\n" 1427 "Four,\n" 1428 "#endif\n" 1429 " Five\n" 1430 "};", 1431 format("enum J {\n" 1432 "One,\n" 1433 "#if 0\n" 1434 "#if 0\n" 1435 "Two,\n" 1436 "#else\n" 1437 "Three,\n" 1438 "#endif\n" 1439 "Four,\n" 1440 "#endif\n" 1441 "Five\n" 1442 "};")); 1443 1444 } 1445 1446 //===----------------------------------------------------------------------===// 1447 // Tests for classes, namespaces, etc. 1448 //===----------------------------------------------------------------------===// 1449 1450 TEST_F(FormatTest, DoesNotBreakSemiAfterClassDecl) { 1451 verifyFormat("class A {};"); 1452 } 1453 1454 TEST_F(FormatTest, UnderstandsAccessSpecifiers) { 1455 verifyFormat("class A {\n" 1456 "public:\n" 1457 "public: // comment\n" 1458 "protected:\n" 1459 "private:\n" 1460 " void f() {}\n" 1461 "};"); 1462 verifyGoogleFormat("class A {\n" 1463 " public:\n" 1464 " protected:\n" 1465 " private:\n" 1466 " void f() {}\n" 1467 "};"); 1468 } 1469 1470 TEST_F(FormatTest, SeparatesLogicalBlocks) { 1471 EXPECT_EQ("class A {\n" 1472 "public:\n" 1473 " void f();\n" 1474 "\n" 1475 "private:\n" 1476 " void g() {}\n" 1477 " // test\n" 1478 "protected:\n" 1479 " int h;\n" 1480 "};", 1481 format("class A {\n" 1482 "public:\n" 1483 "void f();\n" 1484 "private:\n" 1485 "void g() {}\n" 1486 "// test\n" 1487 "protected:\n" 1488 "int h;\n" 1489 "};")); 1490 } 1491 1492 TEST_F(FormatTest, FormatsClasses) { 1493 verifyFormat("class A : public B {};"); 1494 verifyFormat("class A : public ::B {};"); 1495 1496 verifyFormat( 1497 "class AAAAAAAAAAAAAAAAAAAA : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n" 1498 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};"); 1499 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n" 1500 " : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n" 1501 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};"); 1502 verifyFormat( 1503 "class A : public B, public C, public D, public E, public F {};"); 1504 verifyFormat("class AAAAAAAAAAAA : public B,\n" 1505 " public C,\n" 1506 " public D,\n" 1507 " public E,\n" 1508 " public F,\n" 1509 " public G {};"); 1510 1511 verifyFormat("class\n" 1512 " ReallyReallyLongClassName {\n" 1513 " int i;\n" 1514 "};", 1515 getLLVMStyleWithColumns(32)); 1516 } 1517 1518 TEST_F(FormatTest, FormatsVariableDeclarationsAfterStructOrClass) { 1519 verifyFormat("class A {\n} a, b;"); 1520 verifyFormat("struct A {\n} a, b;"); 1521 verifyFormat("union A {\n} a;"); 1522 } 1523 1524 TEST_F(FormatTest, FormatsEnum) { 1525 verifyFormat("enum {\n" 1526 " Zero,\n" 1527 " One = 1,\n" 1528 " Two = One + 1,\n" 1529 " Three = (One + Two),\n" 1530 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1531 " Five = (One, Two, Three, Four, 5)\n" 1532 "};"); 1533 verifyFormat("enum Enum {};"); 1534 verifyFormat("enum {};"); 1535 verifyFormat("enum X E {\n} d;"); 1536 verifyFormat("enum __attribute__((...)) E {\n} d;"); 1537 verifyFormat("enum __declspec__((...)) E {\n} d;"); 1538 verifyFormat("enum X f() {\n a();\n return 42;\n}"); 1539 } 1540 1541 TEST_F(FormatTest, FormatsEnumsWithErrors) { 1542 verifyFormat("enum Type {\n" 1543 " One = 0;\n" // These semicolons should be commas. 1544 " Two = 1;\n" 1545 "};"); 1546 verifyFormat("namespace n {\n" 1547 "enum Type {\n" 1548 " One,\n" 1549 " Two,\n" // missing }; 1550 " int i;\n" 1551 "}\n" 1552 "void g() {}"); 1553 } 1554 1555 TEST_F(FormatTest, FormatsEnumStruct) { 1556 verifyFormat("enum struct {\n" 1557 " Zero,\n" 1558 " One = 1,\n" 1559 " Two = One + 1,\n" 1560 " Three = (One + Two),\n" 1561 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1562 " Five = (One, Two, Three, Four, 5)\n" 1563 "};"); 1564 verifyFormat("enum struct Enum {};"); 1565 verifyFormat("enum struct {};"); 1566 verifyFormat("enum struct X E {\n} d;"); 1567 verifyFormat("enum struct __attribute__((...)) E {\n} d;"); 1568 verifyFormat("enum struct __declspec__((...)) E {\n} d;"); 1569 verifyFormat("enum struct X f() {\n a();\n return 42;\n}"); 1570 } 1571 1572 TEST_F(FormatTest, FormatsEnumClass) { 1573 verifyFormat("enum class {\n" 1574 " Zero,\n" 1575 " One = 1,\n" 1576 " Two = One + 1,\n" 1577 " Three = (One + Two),\n" 1578 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1579 " Five = (One, Two, Three, Four, 5)\n" 1580 "};"); 1581 verifyFormat("enum class Enum {};"); 1582 verifyFormat("enum class {};"); 1583 verifyFormat("enum class X E {\n} d;"); 1584 verifyFormat("enum class __attribute__((...)) E {\n} d;"); 1585 verifyFormat("enum class __declspec__((...)) E {\n} d;"); 1586 verifyFormat("enum class X f() {\n a();\n return 42;\n}"); 1587 } 1588 1589 TEST_F(FormatTest, FormatsEnumTypes) { 1590 verifyFormat("enum X : int {\n" 1591 " A,\n" 1592 " B\n" 1593 "};"); 1594 verifyFormat("enum X : std::uint32_t {\n" 1595 " A,\n" 1596 " B\n" 1597 "};"); 1598 } 1599 1600 TEST_F(FormatTest, FormatsBitfields) { 1601 verifyFormat("struct Bitfields {\n" 1602 " unsigned sClass : 8;\n" 1603 " unsigned ValueKind : 2;\n" 1604 "};"); 1605 } 1606 1607 TEST_F(FormatTest, FormatsNamespaces) { 1608 verifyFormat("namespace some_namespace {\n" 1609 "class A {};\n" 1610 "void f() { f(); }\n" 1611 "}"); 1612 verifyFormat("namespace {\n" 1613 "class A {};\n" 1614 "void f() { f(); }\n" 1615 "}"); 1616 verifyFormat("inline namespace X {\n" 1617 "class A {};\n" 1618 "void f() { f(); }\n" 1619 "}"); 1620 verifyFormat("using namespace some_namespace;\n" 1621 "class A {};\n" 1622 "void f() { f(); }"); 1623 1624 // This code is more common than we thought; if we 1625 // layout this correctly the semicolon will go into 1626 // its own line, which is undesireable. 1627 verifyFormat("namespace {};"); 1628 verifyFormat("namespace {\n" 1629 "class A {};\n" 1630 "};"); 1631 1632 verifyFormat("namespace {\n" 1633 "int SomeVariable = 0; // comment\n" 1634 "} // namespace"); 1635 EXPECT_EQ("#ifndef HEADER_GUARD\n" 1636 "#define HEADER_GUARD\n" 1637 "namespace my_namespace {\n" 1638 "int i;\n" 1639 "} // my_namespace\n" 1640 "#endif // HEADER_GUARD", 1641 format("#ifndef HEADER_GUARD\n" 1642 " #define HEADER_GUARD\n" 1643 " namespace my_namespace {\n" 1644 "int i;\n" 1645 "} // my_namespace\n" 1646 "#endif // HEADER_GUARD")); 1647 1648 FormatStyle Style = getLLVMStyle(); 1649 Style.NamespaceIndentation = FormatStyle::NI_All; 1650 EXPECT_EQ("namespace out {\n" 1651 " int i;\n" 1652 " namespace in {\n" 1653 " int i;\n" 1654 " } // namespace\n" 1655 "} // namespace", 1656 format("namespace out {\n" 1657 "int i;\n" 1658 "namespace in {\n" 1659 "int i;\n" 1660 "} // namespace\n" 1661 "} // namespace", 1662 Style)); 1663 1664 Style.NamespaceIndentation = FormatStyle::NI_Inner; 1665 EXPECT_EQ("namespace out {\n" 1666 "int i;\n" 1667 "namespace in {\n" 1668 " int i;\n" 1669 "} // namespace\n" 1670 "} // namespace", 1671 format("namespace out {\n" 1672 "int i;\n" 1673 "namespace in {\n" 1674 "int i;\n" 1675 "} // namespace\n" 1676 "} // namespace", 1677 Style)); 1678 } 1679 1680 TEST_F(FormatTest, FormatsExternC) { verifyFormat("extern \"C\" {\nint a;"); } 1681 1682 TEST_F(FormatTest, FormatsInlineASM) { 1683 verifyFormat("asm(\"xyz\" : \"=a\"(a), \"=d\"(b) : \"a\"(data));"); 1684 verifyFormat( 1685 "asm(\"movq\\t%%rbx, %%rsi\\n\\t\"\n" 1686 " \"cpuid\\n\\t\"\n" 1687 " \"xchgq\\t%%rbx, %%rsi\\n\\t\"\n" 1688 " : \"=a\"(*rEAX), \"=S\"(*rEBX), \"=c\"(*rECX), \"=d\"(*rEDX)\n" 1689 " : \"a\"(value));"); 1690 } 1691 1692 TEST_F(FormatTest, FormatTryCatch) { 1693 // FIXME: Handle try-catch explicitly in the UnwrappedLineParser, then we'll 1694 // also not create single-line-blocks. 1695 verifyFormat("try {\n" 1696 " throw a * b;\n" 1697 "}\n" 1698 "catch (int a) {\n" 1699 " // Do nothing.\n" 1700 "}\n" 1701 "catch (...) {\n" 1702 " exit(42);\n" 1703 "}"); 1704 1705 // Function-level try statements. 1706 verifyFormat("int f() try { return 4; }\n" 1707 "catch (...) {\n" 1708 " return 5;\n" 1709 "}"); 1710 verifyFormat("class A {\n" 1711 " int a;\n" 1712 " A() try : a(0) {}\n" 1713 " catch (...) {\n" 1714 " throw;\n" 1715 " }\n" 1716 "};\n"); 1717 } 1718 1719 TEST_F(FormatTest, FormatObjCTryCatch) { 1720 verifyFormat("@try {\n" 1721 " f();\n" 1722 "}\n" 1723 "@catch (NSException e) {\n" 1724 " @throw;\n" 1725 "}\n" 1726 "@finally {\n" 1727 " exit(42);\n" 1728 "}"); 1729 } 1730 1731 TEST_F(FormatTest, StaticInitializers) { 1732 verifyFormat("static SomeClass SC = { 1, 'a' };"); 1733 1734 verifyFormat( 1735 "static SomeClass WithALoooooooooooooooooooongName = {\n" 1736 " 100000000, \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"\n" 1737 "};"); 1738 1739 // Here, everything other than the "}" would fit on a line. 1740 verifyFormat("static int LooooooooooooooooooooooooongVariable[1] = {\n" 1741 " 100000000000000000000000\n" 1742 "};"); 1743 EXPECT_EQ("S s = { a, b };", format("S s = {\n" 1744 " a,\n" 1745 "\n" 1746 " b\n" 1747 "};")); 1748 1749 // FIXME: This would fit into the column limit if we'd fit "{ {" on the first 1750 // line. However, the formatting looks a bit off and this probably doesn't 1751 // happen often in practice. 1752 verifyFormat("static int Variable[1] = {\n" 1753 " { 1000000000000000000000000000000000000 }\n" 1754 "};", 1755 getLLVMStyleWithColumns(40)); 1756 } 1757 1758 TEST_F(FormatTest, DesignatedInitializers) { 1759 verifyFormat("const struct A a = { .a = 1, .b = 2 };"); 1760 verifyFormat("const struct A a = { .aaaaaaaaaa = 1,\n" 1761 " .bbbbbbbbbb = 2,\n" 1762 " .cccccccccc = 3,\n" 1763 " .dddddddddd = 4,\n" 1764 " .eeeeeeeeee = 5 };"); 1765 verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n" 1766 " .aaaaaaaaaaaaaaaaaaaaaaaaaaa = 1,\n" 1767 " .bbbbbbbbbbbbbbbbbbbbbbbbbbb = 2,\n" 1768 " .ccccccccccccccccccccccccccc = 3,\n" 1769 " .ddddddddddddddddddddddddddd = 4,\n" 1770 " .eeeeeeeeeeeeeeeeeeeeeeeeeee = 5\n" 1771 "};"); 1772 1773 verifyGoogleFormat("const struct A a = {.a = 1, .b = 2};"); 1774 } 1775 1776 TEST_F(FormatTest, NestedStaticInitializers) { 1777 verifyFormat("static A x = { { {} } };\n"); 1778 verifyFormat("static A x = { { { init1, init2, init3, init4 },\n" 1779 " { init1, init2, init3, init4 } } };"); 1780 1781 verifyFormat("somes Status::global_reps[3] = {\n" 1782 " { kGlobalRef, OK_CODE, NULL, NULL, NULL },\n" 1783 " { kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL },\n" 1784 " { kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL }\n" 1785 "};"); 1786 verifyGoogleFormat("SomeType Status::global_reps[3] = {\n" 1787 " {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n" 1788 " {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n" 1789 " {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};"); 1790 verifyFormat( 1791 "CGRect cg_rect = { { rect.fLeft, rect.fTop },\n" 1792 " { rect.fRight - rect.fLeft, rect.fBottom - rect.fTop" 1793 " } };"); 1794 1795 verifyFormat( 1796 "SomeArrayOfSomeType a = { { { 1, 2, 3 }, { 1, 2, 3 },\n" 1797 " { 111111111111111111111111111111,\n" 1798 " 222222222222222222222222222222,\n" 1799 " 333333333333333333333333333333 },\n" 1800 " { 1, 2, 3 }, { 1, 2, 3 } } };"); 1801 verifyFormat( 1802 "SomeArrayOfSomeType a = { { { 1, 2, 3 } }, { { 1, 2, 3 } },\n" 1803 " { { 111111111111111111111111111111,\n" 1804 " 222222222222222222222222222222,\n" 1805 " 333333333333333333333333333333 } },\n" 1806 " { { 1, 2, 3 } }, { { 1, 2, 3 } } };"); 1807 verifyGoogleFormat( 1808 "SomeArrayOfSomeType a = {\n" 1809 " {{1, 2, 3}}, {{1, 2, 3}},\n" 1810 " {{111111111111111111111111111111, 222222222222222222222222222222,\n" 1811 " 333333333333333333333333333333}},\n" 1812 " {{1, 2, 3}}, {{1, 2, 3}}};"); 1813 1814 // FIXME: We might at some point want to handle this similar to parameter 1815 // lists, where we have an option to put each on a single line. 1816 verifyFormat( 1817 "struct {\n" 1818 " unsigned bit;\n" 1819 " const char *const name;\n" 1820 "} kBitsToOs[] = { { kOsMac, \"Mac\" }, { kOsWin, \"Windows\" },\n" 1821 " { kOsLinux, \"Linux\" }, { kOsCrOS, \"Chrome OS\" } };"); 1822 } 1823 1824 TEST_F(FormatTest, FormatsSmallMacroDefinitionsInSingleLine) { 1825 verifyFormat("#define ALooooooooooooooooooooooooooooooooooooooongMacro(" 1826 " \\\n" 1827 " aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)"); 1828 } 1829 1830 TEST_F(FormatTest, DoesNotBreakPureVirtualFunctionDefinition) { 1831 verifyFormat( 1832 "virtual void write(ELFWriter *writerrr,\n" 1833 " OwningPtr<FileOutputBuffer> &buffer) = 0;"); 1834 } 1835 1836 TEST_F(FormatTest, LayoutUnknownPPDirective) { 1837 EXPECT_EQ("#123 \"A string literal\"", 1838 format(" # 123 \"A string literal\"")); 1839 EXPECT_EQ("#;", format("#;")); 1840 verifyFormat("#\n;\n;\n;"); 1841 } 1842 1843 TEST_F(FormatTest, UnescapedEndOfLineEndsPPDirective) { 1844 EXPECT_EQ("#line 42 \"test\"\n", 1845 format("# \\\n line \\\n 42 \\\n \"test\"\n")); 1846 EXPECT_EQ("#define A B\n", format("# \\\n define \\\n A \\\n B\n", 1847 getLLVMStyleWithColumns(12))); 1848 } 1849 1850 TEST_F(FormatTest, EndOfFileEndsPPDirective) { 1851 EXPECT_EQ("#line 42 \"test\"", 1852 format("# \\\n line \\\n 42 \\\n \"test\"")); 1853 EXPECT_EQ("#define A B", format("# \\\n define \\\n A \\\n B")); 1854 } 1855 1856 TEST_F(FormatTest, IndentsPPDirectiveInReducedSpace) { 1857 verifyFormat("#define A(BB)", getLLVMStyleWithColumns(13)); 1858 verifyFormat("#define A( \\\n BB)", getLLVMStyleWithColumns(12)); 1859 verifyFormat("#define A( \\\n A, B)", getLLVMStyleWithColumns(12)); 1860 // FIXME: We never break before the macro name. 1861 verifyFormat("#define AA( \\\n B)", getLLVMStyleWithColumns(12)); 1862 1863 verifyFormat("#define A A\n#define A A"); 1864 verifyFormat("#define A(X) A\n#define A A"); 1865 1866 verifyFormat("#define Something Other", getLLVMStyleWithColumns(23)); 1867 verifyFormat("#define Something \\\n Other", getLLVMStyleWithColumns(22)); 1868 } 1869 1870 TEST_F(FormatTest, HandlePreprocessorDirectiveContext) { 1871 EXPECT_EQ("// somecomment\n" 1872 "#include \"a.h\"\n" 1873 "#define A( \\\n" 1874 " A, B)\n" 1875 "#include \"b.h\"\n" 1876 "// somecomment\n", 1877 format(" // somecomment\n" 1878 " #include \"a.h\"\n" 1879 "#define A(A,\\\n" 1880 " B)\n" 1881 " #include \"b.h\"\n" 1882 " // somecomment\n", 1883 getLLVMStyleWithColumns(13))); 1884 } 1885 1886 TEST_F(FormatTest, LayoutSingleHash) { EXPECT_EQ("#\na;", format("#\na;")); } 1887 1888 TEST_F(FormatTest, LayoutCodeInMacroDefinitions) { 1889 EXPECT_EQ("#define A \\\n" 1890 " c; \\\n" 1891 " e;\n" 1892 "f;", 1893 format("#define A c; e;\n" 1894 "f;", 1895 getLLVMStyleWithColumns(14))); 1896 } 1897 1898 TEST_F(FormatTest, LayoutRemainingTokens) { EXPECT_EQ("{}", format("{}")); } 1899 1900 TEST_F(FormatTest, AlwaysFormatsEntireMacroDefinitions) { 1901 EXPECT_EQ("int i;\n" 1902 "#define A \\\n" 1903 " int i; \\\n" 1904 " int j\n" 1905 "int k;", 1906 format("int i;\n" 1907 "#define A \\\n" 1908 " int i ; \\\n" 1909 " int j\n" 1910 "int k;", 1911 8, 0, getGoogleStyle())); // 8: position of "#define". 1912 EXPECT_EQ("int i;\n" 1913 "#define A \\\n" 1914 " int i; \\\n" 1915 " int j\n" 1916 "int k;", 1917 format("int i;\n" 1918 "#define A \\\n" 1919 " int i ; \\\n" 1920 " int j\n" 1921 "int k;", 1922 45, 0, getGoogleStyle())); // 45: position of "j". 1923 } 1924 1925 TEST_F(FormatTest, MacroDefinitionInsideStatement) { 1926 EXPECT_EQ("int x,\n" 1927 "#define A\n" 1928 " y;", 1929 format("int x,\n#define A\ny;")); 1930 } 1931 1932 TEST_F(FormatTest, HashInMacroDefinition) { 1933 verifyFormat("#define A \\\n b #c;", getLLVMStyleWithColumns(11)); 1934 verifyFormat("#define A \\\n" 1935 " { \\\n" 1936 " f(#c); \\\n" 1937 " }", 1938 getLLVMStyleWithColumns(11)); 1939 1940 verifyFormat("#define A(X) \\\n" 1941 " void function##X()", 1942 getLLVMStyleWithColumns(22)); 1943 1944 verifyFormat("#define A(a, b, c) \\\n" 1945 " void a##b##c()", 1946 getLLVMStyleWithColumns(22)); 1947 1948 verifyFormat("#define A void # ## #", getLLVMStyleWithColumns(22)); 1949 } 1950 1951 TEST_F(FormatTest, RespectWhitespaceInMacroDefinitions) { 1952 verifyFormat("#define A (1)"); 1953 } 1954 1955 TEST_F(FormatTest, EmptyLinesInMacroDefinitions) { 1956 EXPECT_EQ("#define A b;", format("#define A \\\n" 1957 " \\\n" 1958 " b;", 1959 getLLVMStyleWithColumns(25))); 1960 EXPECT_EQ("#define A \\\n" 1961 " \\\n" 1962 " a; \\\n" 1963 " b;", 1964 format("#define A \\\n" 1965 " \\\n" 1966 " a; \\\n" 1967 " b;", 1968 getLLVMStyleWithColumns(11))); 1969 EXPECT_EQ("#define A \\\n" 1970 " a; \\\n" 1971 " \\\n" 1972 " b;", 1973 format("#define A \\\n" 1974 " a; \\\n" 1975 " \\\n" 1976 " b;", 1977 getLLVMStyleWithColumns(11))); 1978 } 1979 1980 TEST_F(FormatTest, MacroDefinitionsWithIncompleteCode) { 1981 verifyFormat("#define A :"); 1982 verifyFormat("#define SOMECASES \\\n" 1983 " case 1: \\\n" 1984 " case 2\n", 1985 getLLVMStyleWithColumns(20)); 1986 verifyFormat("#define A template <typename T>"); 1987 verifyFormat("#define STR(x) #x\n" 1988 "f(STR(this_is_a_string_literal{));"); 1989 verifyFormat("#pragma omp threadprivate( \\\n" 1990 " y)), // expected-warning", 1991 getLLVMStyleWithColumns(28)); 1992 } 1993 1994 TEST_F(FormatTest, MacrosWithoutTrailingSemicolon) { 1995 verifyFormat("SOME_TYPE_NAME abc;"); // Gated on the newline. 1996 EXPECT_EQ("class A : public QObject {\n" 1997 " Q_OBJECT\n" 1998 "\n" 1999 " A() {}\n" 2000 "};", 2001 format("class A : public QObject {\n" 2002 " Q_OBJECT\n" 2003 "\n" 2004 " A() {\n}\n" 2005 "} ;")); 2006 EXPECT_EQ("SOME_MACRO\n" 2007 "namespace {\n" 2008 "void f();\n" 2009 "}", 2010 format("SOME_MACRO\n" 2011 " namespace {\n" 2012 "void f( );\n" 2013 "}")); 2014 // Only if the identifier contains at least 5 characters. 2015 EXPECT_EQ("HTTP f();", 2016 format("HTTP\nf();")); 2017 EXPECT_EQ("MACRO\nf();", 2018 format("MACRO\nf();")); 2019 // Only if everything is upper case. 2020 EXPECT_EQ("class A : public QObject {\n" 2021 " Q_Object A() {}\n" 2022 "};", 2023 format("class A : public QObject {\n" 2024 " Q_Object\n" 2025 "\n" 2026 " A() {\n}\n" 2027 "} ;")); 2028 } 2029 2030 TEST_F(FormatTest, MacroCallsWithoutTrailingSemicolon) { 2031 EXPECT_EQ("INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n" 2032 "INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n" 2033 "INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n" 2034 "class X {};\n" 2035 "INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n" 2036 "int *createScopDetectionPass() { return 0; }", 2037 format(" INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n" 2038 " INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n" 2039 " INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n" 2040 " class X {};\n" 2041 " INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n" 2042 " int *createScopDetectionPass() { return 0; }")); 2043 // FIXME: We could probably treat IPC_BEGIN_MESSAGE_MAP/IPC_END_MESSAGE_MAP as 2044 // braces, so that inner block is indented one level more. 2045 EXPECT_EQ("int q() {\n" 2046 " IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n" 2047 " IPC_MESSAGE_HANDLER(xxx, qqq)\n" 2048 " IPC_END_MESSAGE_MAP()\n" 2049 "}", 2050 format("int q() {\n" 2051 " IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n" 2052 " IPC_MESSAGE_HANDLER(xxx, qqq)\n" 2053 " IPC_END_MESSAGE_MAP()\n" 2054 "}")); 2055 EXPECT_EQ("int q() {\n" 2056 " f(x);\n" 2057 " f(x) {}\n" 2058 " f(x)->g();\n" 2059 " f(x)->*g();\n" 2060 " f(x).g();\n" 2061 " f(x) = x;\n" 2062 " f(x) += x;\n" 2063 " f(x) -= x;\n" 2064 " f(x) *= x;\n" 2065 " f(x) /= x;\n" 2066 " f(x) %= x;\n" 2067 " f(x) &= x;\n" 2068 " f(x) |= x;\n" 2069 " f(x) ^= x;\n" 2070 " f(x) >>= x;\n" 2071 " f(x) <<= x;\n" 2072 " f(x)[y].z();\n" 2073 " LOG(INFO) << x;\n" 2074 " ifstream(x) >> x;\n" 2075 "}\n", 2076 format("int q() {\n" 2077 " f(x)\n;\n" 2078 " f(x)\n {}\n" 2079 " f(x)\n->g();\n" 2080 " f(x)\n->*g();\n" 2081 " f(x)\n.g();\n" 2082 " f(x)\n = x;\n" 2083 " f(x)\n += x;\n" 2084 " f(x)\n -= x;\n" 2085 " f(x)\n *= x;\n" 2086 " f(x)\n /= x;\n" 2087 " f(x)\n %= x;\n" 2088 " f(x)\n &= x;\n" 2089 " f(x)\n |= x;\n" 2090 " f(x)\n ^= x;\n" 2091 " f(x)\n >>= x;\n" 2092 " f(x)\n <<= x;\n" 2093 " f(x)\n[y].z();\n" 2094 " LOG(INFO)\n << x;\n" 2095 " ifstream(x)\n >> x;\n" 2096 "}\n")); 2097 EXPECT_EQ("int q() {\n" 2098 " f(x)\n" 2099 " if (1) {\n" 2100 " }\n" 2101 " f(x)\n" 2102 " while (1) {\n" 2103 " }\n" 2104 " f(x)\n" 2105 " g(x);\n" 2106 " f(x)\n" 2107 " try {\n" 2108 " q();\n" 2109 " }\n" 2110 " catch (...) {\n" 2111 " }\n" 2112 "}\n", 2113 format("int q() {\n" 2114 "f(x)\n" 2115 "if (1) {}\n" 2116 "f(x)\n" 2117 "while (1) {}\n" 2118 "f(x)\n" 2119 "g(x);\n" 2120 "f(x)\n" 2121 "try { q(); } catch (...) {}\n" 2122 "}\n")); 2123 EXPECT_EQ("class A {\n" 2124 " A() : t(0) {}\n" 2125 " A(X x)\n" // FIXME: function-level try blocks are broken. 2126 " try : t(0) {\n" 2127 " }\n" 2128 " catch (...) {\n" 2129 " }\n" 2130 "};", 2131 format("class A {\n" 2132 " A()\n : t(0) {}\n" 2133 " A(X x)\n" 2134 " try : t(0) {} catch (...) {}\n" 2135 "};")); 2136 } 2137 2138 TEST_F(FormatTest, LayoutMacroDefinitionsStatementsSpanningBlocks) { 2139 verifyFormat("#define A \\\n" 2140 " f({ \\\n" 2141 " g(); \\\n" 2142 " });", getLLVMStyleWithColumns(11)); 2143 } 2144 2145 TEST_F(FormatTest, IndentPreprocessorDirectivesAtZero) { 2146 EXPECT_EQ("{\n {\n#define A\n }\n}", format("{{\n#define A\n}}")); 2147 } 2148 2149 TEST_F(FormatTest, FormatHashIfNotAtStartOfLine) { 2150 verifyFormat("{\n { a #c; }\n}"); 2151 } 2152 2153 TEST_F(FormatTest, FormatUnbalancedStructuralElements) { 2154 EXPECT_EQ("#define A \\\n { \\\n {\nint i;", 2155 format("#define A { {\nint i;", getLLVMStyleWithColumns(11))); 2156 EXPECT_EQ("#define A \\\n } \\\n }\nint i;", 2157 format("#define A } }\nint i;", getLLVMStyleWithColumns(11))); 2158 } 2159 2160 TEST_F(FormatTest, EscapedNewlineAtStartOfToken) { 2161 EXPECT_EQ( 2162 "#define A \\\n int i; \\\n int j;", 2163 format("#define A \\\nint i;\\\n int j;", getLLVMStyleWithColumns(11))); 2164 EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();")); 2165 } 2166 2167 TEST_F(FormatTest, NoEscapedNewlineHandlingInBlockComments) { 2168 EXPECT_EQ("/* \\ \\ \\\n*/", format("\\\n/* \\ \\ \\\n*/")); 2169 } 2170 2171 TEST_F(FormatTest, CalculateSpaceOnConsecutiveLinesInMacro) { 2172 verifyFormat("#define A \\\n" 2173 " int v( \\\n" 2174 " a); \\\n" 2175 " int i;", 2176 getLLVMStyleWithColumns(11)); 2177 } 2178 2179 TEST_F(FormatTest, MixingPreprocessorDirectivesAndNormalCode) { 2180 EXPECT_EQ( 2181 "#define ALooooooooooooooooooooooooooooooooooooooongMacro(" 2182 " \\\n" 2183 " aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n" 2184 "\n" 2185 "AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n" 2186 " aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n", 2187 format(" #define ALooooooooooooooooooooooooooooooooooooooongMacro(" 2188 "\\\n" 2189 "aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n" 2190 " \n" 2191 " AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n" 2192 " aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n")); 2193 } 2194 2195 TEST_F(FormatTest, LayoutStatementsAroundPreprocessorDirectives) { 2196 EXPECT_EQ("int\n" 2197 "#define A\n" 2198 " a;", 2199 format("int\n#define A\na;", getGoogleStyle())); 2200 verifyFormat("functionCallTo(\n" 2201 " someOtherFunction(\n" 2202 " withSomeParameters, whichInSequence,\n" 2203 " areLongerThanALine(andAnotherCall,\n" 2204 "#define A B\n" 2205 " withMoreParamters,\n" 2206 " whichStronglyInfluenceTheLayout),\n" 2207 " andMoreParameters),\n" 2208 " trailing);", 2209 getLLVMStyleWithColumns(69)); 2210 } 2211 2212 TEST_F(FormatTest, LayoutBlockInsideParens) { 2213 EXPECT_EQ("functionCall({ int i; });", format(" functionCall ( {int i;} );")); 2214 EXPECT_EQ("functionCall({\n" 2215 " int i;\n" 2216 " int j;\n" 2217 "});", 2218 format(" functionCall ( {int i;int j;} );")); 2219 EXPECT_EQ("functionCall({\n" 2220 " int i;\n" 2221 " int j;\n" 2222 " },\n" 2223 " aaaa, bbbb, cccc);", 2224 format(" functionCall ( {int i;int j;}, aaaa, bbbb, cccc);")); 2225 EXPECT_EQ("functionCall(aaaa, bbbb, { int i; });", 2226 format(" functionCall (aaaa, bbbb, {int i;});")); 2227 EXPECT_EQ("functionCall(aaaa, bbbb, {\n" 2228 " int i;\n" 2229 " int j;\n" 2230 "});", 2231 format(" functionCall (aaaa, bbbb, {int i;int j;});")); 2232 EXPECT_EQ("functionCall(aaaa, bbbb, { int i; });", 2233 format(" functionCall (aaaa, bbbb, {int i;});")); 2234 verifyFormat( 2235 "Aaa({\n" 2236 " int i; // break\n" 2237 " },\n" 2238 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" 2239 " ccccccccccccccccc));"); 2240 verifyFormat("DEBUG({\n" 2241 " if (a)\n" 2242 " f();\n" 2243 "});"); 2244 } 2245 2246 TEST_F(FormatTest, LayoutBlockInsideStatement) { 2247 EXPECT_EQ("SOME_MACRO { int i; }\n" 2248 "int i;", 2249 format(" SOME_MACRO {int i;} int i;")); 2250 } 2251 2252 TEST_F(FormatTest, LayoutNestedBlocks) { 2253 verifyFormat("void AddOsStrings(unsigned bitmask) {\n" 2254 " struct s {\n" 2255 " int i;\n" 2256 " };\n" 2257 " s kBitsToOs[] = { { 10 } };\n" 2258 " for (int i = 0; i < 10; ++i)\n" 2259 " return;\n" 2260 "}"); 2261 verifyFormat("call(parameter, {\n" 2262 " something();\n" 2263 " // Comment using all columns.\n" 2264 " somethingelse();\n" 2265 "});", 2266 getLLVMStyleWithColumns(40)); 2267 EXPECT_EQ("call(parameter, {\n" 2268 " something();\n" 2269 " // Comment too\n" 2270 " // looooooooooong.\n" 2271 " somethingElse();\n" 2272 "});", 2273 format("call(parameter, {\n" 2274 " something();\n" 2275 " // Comment too looooooooooong.\n" 2276 " somethingElse();\n" 2277 "});", 2278 getLLVMStyleWithColumns(29))); 2279 EXPECT_EQ("DEBUG({ int i; });", format("DEBUG({ int i; });")); 2280 EXPECT_EQ("DEBUG({\n" 2281 " int i;\n" 2282 "\n" 2283 " // comment\n" 2284 " int j;\n" 2285 "});", 2286 format("DEBUG({\n" 2287 " int i;\n" 2288 "\n" 2289 " // comment\n" 2290 " int j;\n" 2291 "});")); 2292 } 2293 2294 TEST_F(FormatTest, PutEmptyBlocksIntoOneLine) { 2295 EXPECT_EQ("{}", format("{}")); 2296 verifyFormat("enum E {};"); 2297 verifyFormat("enum E {}"); 2298 } 2299 2300 //===----------------------------------------------------------------------===// 2301 // Line break tests. 2302 //===----------------------------------------------------------------------===// 2303 2304 TEST_F(FormatTest, PreventConfusingIndents) { 2305 verifyFormat( 2306 "SomeLongMethodName(SomeReallyLongMethod(CallOtherReallyLongMethod(\n" 2307 " parameter, parameter, parameter)),\n" 2308 " SecondLongCall(parameter));"); 2309 verifyFormat( 2310 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 2311 " aaaaaaaaaaaaaaaaaaaaaaaa(\n" 2312 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 2313 " aaaaaaaaaaaaaaaaaaaaaaaa);"); 2314 verifyFormat( 2315 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2316 " [aaaaaaaaaaaaaaaaaaaaaaaa\n" 2317 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n" 2318 " [aaaaaaaaaaaaaaaaaaaaaaaa]];"); 2319 verifyFormat( 2320 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n" 2321 " aaaaaaaaaaaaaaaaaaaaaaaa<\n" 2322 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>,\n" 2323 " aaaaaaaaaaaaaaaaaaaaaaaa>;"); 2324 verifyFormat("int a = bbbb && ccc && fffff(\n" 2325 "#define A Just forcing a new line\n" 2326 " ddd);"); 2327 } 2328 2329 TEST_F(FormatTest, LineBreakingInBinaryExpressions) { 2330 verifyFormat( 2331 "bool aaaaaaa =\n" 2332 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() ||\n" 2333 " bbbbbbbb();"); 2334 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n" 2335 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb &&\n" 2336 " ccccccccc == ddddddddddd;"); 2337 2338 verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n" 2339 " aaaaaa) &&\n" 2340 " bbbbbb && cccccc;"); 2341 verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n" 2342 " aaaaaa) >>\n" 2343 " bbbbbb;"); 2344 verifyFormat("Whitespaces.addUntouchableComment(\n" 2345 " SourceMgr.getSpellingColumnNumber(\n" 2346 " TheLine.Last->FormatTok.Tok.getLocation()) -\n" 2347 " 1);"); 2348 2349 verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 2350 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaaaaaaa\n" 2351 " cccccc) {\n}"); 2352 2353 // If the LHS of a comparison is not a binary expression itself, the 2354 // additional linebreak confuses many people. 2355 verifyFormat( 2356 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 2357 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) > 5) {\n" 2358 "}"); 2359 verifyFormat( 2360 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 2361 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n" 2362 "}"); 2363 verifyFormat( 2364 "if (aaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaa(\n" 2365 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n" 2366 "}"); 2367 // Even explicit parentheses stress the precedence enough to make the 2368 // additional break unnecessary. 2369 verifyFormat( 2370 "if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 2371 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n" 2372 "}"); 2373 // This cases is borderline, but with the indentation it is still readable. 2374 verifyFormat( 2375 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 2376 " aaaaaaaaaaaaaaa) > aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 2377 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 2378 "}", 2379 getLLVMStyleWithColumns(75)); 2380 2381 // If the LHS is a binary expression, we should still use the additional break 2382 // as otherwise the formatting hides the operator precedence. 2383 verifyFormat( 2384 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 2385 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 2386 " 5) {\n" 2387 "}"); 2388 2389 FormatStyle OnePerLine = getLLVMStyle(); 2390 OnePerLine.BinPackParameters = false; 2391 verifyFormat( 2392 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 2393 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 2394 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}", 2395 OnePerLine); 2396 } 2397 2398 TEST_F(FormatTest, ExpressionIndentation) { 2399 verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 2400 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 2401 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 2402 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 2403 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb +\n" 2404 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb &&\n" 2405 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 2406 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >\n" 2407 " ccccccccccccccccccccccccccccccccccccccccc;"); 2408 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 2409 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 2410 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 2411 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); 2412 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 2413 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 2414 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 2415 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); 2416 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 2417 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 2418 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 2419 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); 2420 verifyFormat("if () {\n" 2421 "} else if (aaaaa && bbbbb > // break\n" 2422 " ccccc) {\n" 2423 "}"); 2424 2425 // Presence of a trailing comment used to change indentation of b. 2426 verifyFormat("return aaaaaaaaaaaaaaaaaaa +\n" 2427 " b;\n" 2428 "return aaaaaaaaaaaaaaaaaaa +\n" 2429 " b; //", 2430 getLLVMStyleWithColumns(30)); 2431 } 2432 2433 TEST_F(FormatTest, ExpressionIndentationBreakingBeforeOperators) { 2434 // Not sure what the best system is here. Like this, the LHS can be found 2435 // immediately above an operator (everything with the same or a higher 2436 // indent). The RHS is aligned right of the operator and so compasses 2437 // everything until something with the same indent as the operator is found. 2438 // FIXME: Is this a good system? 2439 FormatStyle Style = getLLVMStyle(); 2440 Style.BreakBeforeBinaryOperators = true; 2441 verifyFormat( 2442 "bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2443 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2444 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2445 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2446 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 2447 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 2448 " && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2449 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2450 " > ccccccccccccccccccccccccccccccccccccccccc;", 2451 Style); 2452 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2453 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2454 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2455 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 2456 Style); 2457 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2458 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2459 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2460 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 2461 Style); 2462 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2463 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2464 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2465 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 2466 Style); 2467 verifyFormat("if () {\n" 2468 "} else if (aaaaa && bbbbb // break\n" 2469 " > ccccc) {\n" 2470 "}", 2471 Style); 2472 } 2473 2474 TEST_F(FormatTest, ConstructorInitializers) { 2475 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}"); 2476 verifyFormat("Constructor() : Inttializer(FitsOnTheLine) {}", 2477 getLLVMStyleWithColumns(45)); 2478 verifyFormat("Constructor()\n" 2479 " : Inttializer(FitsOnTheLine) {}", 2480 getLLVMStyleWithColumns(44)); 2481 verifyFormat("Constructor()\n" 2482 " : Inttializer(FitsOnTheLine) {}", 2483 getLLVMStyleWithColumns(43)); 2484 2485 verifyFormat( 2486 "SomeClass::Constructor()\n" 2487 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}"); 2488 2489 verifyFormat( 2490 "SomeClass::Constructor()\n" 2491 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 2492 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}"); 2493 verifyFormat( 2494 "SomeClass::Constructor()\n" 2495 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 2496 " aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}"); 2497 2498 verifyFormat("Constructor()\n" 2499 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 2500 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 2501 " aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 2502 " aaaaaaaaaaaaaaaaaaaaaaa() {}"); 2503 2504 verifyFormat("Constructor()\n" 2505 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 2506 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); 2507 2508 verifyFormat("Constructor(int Parameter = 0)\n" 2509 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n" 2510 " aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}"); 2511 verifyFormat("Constructor()\n" 2512 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n" 2513 "}", 2514 getLLVMStyleWithColumns(60)); 2515 2516 // Here a line could be saved by splitting the second initializer onto two 2517 // lines, but that is not desireable. 2518 verifyFormat("Constructor()\n" 2519 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n" 2520 " aaaaaaaaaaa(aaaaaaaaaaa),\n" 2521 " aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); 2522 2523 FormatStyle OnePerLine = getLLVMStyle(); 2524 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 2525 verifyFormat("SomeClass::Constructor()\n" 2526 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 2527 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 2528 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 2529 OnePerLine); 2530 verifyFormat("SomeClass::Constructor()\n" 2531 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n" 2532 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 2533 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 2534 OnePerLine); 2535 verifyFormat("MyClass::MyClass(int var)\n" 2536 " : some_var_(var), // 4 space indent\n" 2537 " some_other_var_(var + 1) { // lined up\n" 2538 "}", 2539 OnePerLine); 2540 verifyFormat("Constructor()\n" 2541 " : aaaaa(aaaaaa),\n" 2542 " aaaaa(aaaaaa),\n" 2543 " aaaaa(aaaaaa),\n" 2544 " aaaaa(aaaaaa),\n" 2545 " aaaaa(aaaaaa) {}", 2546 OnePerLine); 2547 verifyFormat("Constructor()\n" 2548 " : aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n" 2549 " aaaaaaaaaaaaaaaaaaaaaa) {}", 2550 OnePerLine); 2551 } 2552 2553 TEST_F(FormatTest, MemoizationTests) { 2554 // This breaks if the memoization lookup does not take \c Indent and 2555 // \c LastSpace into account. 2556 verifyFormat( 2557 "extern CFRunLoopTimerRef\n" 2558 "CFRunLoopTimerCreate(CFAllocatorRef allocato, CFAbsoluteTime fireDate,\n" 2559 " CFTimeInterval interval, CFOptionFlags flags,\n" 2560 " CFIndex order, CFRunLoopTimerCallBack callout,\n" 2561 " CFRunLoopTimerContext *context) {}"); 2562 2563 // Deep nesting somewhat works around our memoization. 2564 verifyFormat( 2565 "aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 2566 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 2567 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 2568 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 2569 " aaaaa())))))))))))))))))))))))))))))))))))))));", 2570 getLLVMStyleWithColumns(65)); 2571 verifyFormat( 2572 "aaaaa(\n" 2573 " aaaaa,\n" 2574 " aaaaa(\n" 2575 " aaaaa,\n" 2576 " aaaaa(\n" 2577 " aaaaa,\n" 2578 " aaaaa(\n" 2579 " aaaaa,\n" 2580 " aaaaa(\n" 2581 " aaaaa,\n" 2582 " aaaaa(\n" 2583 " aaaaa,\n" 2584 " aaaaa(\n" 2585 " aaaaa,\n" 2586 " aaaaa(\n" 2587 " aaaaa,\n" 2588 " aaaaa(\n" 2589 " aaaaa,\n" 2590 " aaaaa(\n" 2591 " aaaaa,\n" 2592 " aaaaa(\n" 2593 " aaaaa,\n" 2594 " aaaaa(\n" 2595 " aaaaa,\n" 2596 " aaaaa))))))))))));", 2597 getLLVMStyleWithColumns(65)); 2598 verifyFormat( 2599 "a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(), a), a), a), a),\n" 2600 " a),\n" 2601 " a),\n" 2602 " a),\n" 2603 " a),\n" 2604 " a),\n" 2605 " a),\n" 2606 " a),\n" 2607 " a),\n" 2608 " a),\n" 2609 " a),\n" 2610 " a),\n" 2611 " a),\n" 2612 " a),\n" 2613 " a),\n" 2614 " a),\n" 2615 " a),\n" 2616 " a)", 2617 getLLVMStyleWithColumns(65)); 2618 2619 // This test takes VERY long when memoization is broken. 2620 FormatStyle OnePerLine = getLLVMStyle(); 2621 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 2622 OnePerLine.BinPackParameters = false; 2623 std::string input = "Constructor()\n" 2624 " : aaaa(a,\n"; 2625 for (unsigned i = 0, e = 80; i != e; ++i) { 2626 input += " a,\n"; 2627 } 2628 input += " a) {}"; 2629 verifyFormat(input, OnePerLine); 2630 } 2631 2632 TEST_F(FormatTest, BreaksAsHighAsPossible) { 2633 verifyFormat( 2634 "void f() {\n" 2635 " if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaaaaaaaa) ||\n" 2636 " (bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb && bbbbbbbbbbbbbbbbbbbbbbbbbb))\n" 2637 " f();\n" 2638 "}"); 2639 verifyFormat("if (Intervals[i].getRange().getFirst() <\n" 2640 " Intervals[i - 1].getRange().getLast()) {\n}"); 2641 } 2642 2643 TEST_F(FormatTest, BreaksFunctionDeclarations) { 2644 // Principially, we break function declarations in a certain order: 2645 // 1) break amongst arguments. 2646 verifyFormat("Aaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccc,\n" 2647 " Cccccccccccccc cccccccccccccc);"); 2648 verifyFormat( 2649 "template <class TemplateIt>\n" 2650 "SomeReturnType SomeFunction(TemplateIt begin, TemplateIt end,\n" 2651 " TemplateIt *stop) {}"); 2652 2653 // 2) break after return type. 2654 verifyFormat( 2655 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2656 " bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccccccccccccccc);", 2657 getGoogleStyle()); 2658 2659 // 3) break after (. 2660 verifyFormat( 2661 "Aaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbb(\n" 2662 " Cccccccccccccccccccccccccccccc cccccccccccccccccccccccccccccccc);", 2663 getGoogleStyle()); 2664 2665 // 4) break before after nested name specifiers. 2666 verifyFormat( 2667 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2668 " SomeClasssssssssssssssssssssssssssssssssssssss::\n" 2669 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc);", 2670 getGoogleStyle()); 2671 2672 // However, there are exceptions, if a sufficient amount of lines can be 2673 // saved. 2674 // FIXME: The precise cut-offs wrt. the number of saved lines might need some 2675 // more adjusting. 2676 verifyFormat("Aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n" 2677 " Cccccccccccccc cccccccccc,\n" 2678 " Cccccccccccccc cccccccccc,\n" 2679 " Cccccccccccccc cccccccccc,\n" 2680 " Cccccccccccccc cccccccccc);"); 2681 verifyFormat( 2682 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2683 " bbbbbbbbbbb(Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 2684 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 2685 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);", 2686 getGoogleStyle()); 2687 verifyFormat( 2688 "Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n" 2689 " Cccccccccccccc cccccccccc,\n" 2690 " Cccccccccccccc cccccccccc,\n" 2691 " Cccccccccccccc cccccccccc,\n" 2692 " Cccccccccccccc cccccccccc,\n" 2693 " Cccccccccccccc cccccccccc,\n" 2694 " Cccccccccccccc cccccccccc);"); 2695 verifyFormat("Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 2696 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 2697 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 2698 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 2699 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);"); 2700 2701 // Break after multi-line parameters. 2702 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 2703 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2704 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 2705 " bbbb bbbb);"); 2706 2707 // Treat overloaded operators like other functions. 2708 verifyFormat("SomeLoooooooooooooooooooooooooogType\n" 2709 "operator>(const SomeLoooooooooooooooooooooooooogType &other);"); 2710 verifyFormat("SomeLoooooooooooooooooooooooooogType\n" 2711 "operator>>(const SomeLooooooooooooooooooooooooogType &other);"); 2712 verifyGoogleFormat( 2713 "SomeLoooooooooooooooooooooooooooooogType operator<<(\n" 2714 " const SomeLooooooooogType &a, const SomeLooooooooogType &b);"); 2715 } 2716 2717 TEST_F(FormatTest, TrailingReturnType) { 2718 verifyFormat("auto foo() -> int;\n"); 2719 verifyFormat("struct S {\n" 2720 " auto bar() const -> int;\n" 2721 "};"); 2722 verifyFormat("template <size_t Order, typename T>\n" 2723 "auto load_img(const std::string &filename)\n" 2724 " -> alias::tensor<Order, T, mem::tag::cpu> {}"); 2725 2726 // Not trailing return types. 2727 verifyFormat("void f() { auto a = b->c(); }"); 2728 } 2729 2730 TEST_F(FormatTest, BreaksFunctionDeclarationsWithTrailingTokens) { 2731 // Avoid breaking before trailing 'const'. 2732 verifyFormat("void someLongFunction(\n" 2733 " int someLongParameter) const {}", 2734 getLLVMStyleWithColumns(46)); 2735 FormatStyle Style = getGoogleStyle(); 2736 Style.ColumnLimit = 47; 2737 verifyFormat("void\n" 2738 "someLongFunction(int someLongParameter) const {\n}", 2739 getLLVMStyleWithColumns(47)); 2740 verifyFormat("void someLongFunction(\n" 2741 " int someLongParameter) const {}", 2742 Style); 2743 verifyFormat("LoooooongReturnType\n" 2744 "someLoooooooongFunction() const {}", 2745 getLLVMStyleWithColumns(47)); 2746 verifyFormat("LoooooongReturnType someLoooooooongFunction()\n" 2747 " const {}", 2748 Style); 2749 2750 // Avoid breaking before other trailing annotations, if they are not 2751 // function-like. 2752 verifyFormat("void SomeFunction(aaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 2753 " aaaaaaaaaaaaaaaaaaaaaaaaaa) OVERRIDE;"); 2754 2755 // Breaking before function-like trailing annotations is fine to keep them 2756 // close to their arguments. 2757 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 2758 " LOCKS_EXCLUDED(aaaaaaaaaaaaa);"); 2759 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n" 2760 " LOCKS_EXCLUDED(aaaaaaaaaaaaa);"); 2761 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n" 2762 " LOCKS_EXCLUDED(aaaaaaaaaaaaa) {}"); 2763 2764 verifyFormat( 2765 "void aaaaaaaaaaaaaaaaaa()\n" 2766 " __attribute__((aaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaa,\n" 2767 " aaaaaaaaaaaaaaaaaaaaaaaaa));"); 2768 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2769 " __attribute__((unused));"); 2770 verifyFormat( 2771 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2772 " GUARDED_BY(aaaaaaaaaaaa);", 2773 getGoogleStyle()); 2774 verifyFormat( 2775 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2776 " GUARDED_BY(aaaaaaaaaaaa);", 2777 getGoogleStyle()); 2778 } 2779 2780 TEST_F(FormatTest, BreaksDesireably) { 2781 verifyFormat("if (aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n" 2782 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n" 2783 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa)) {\n}"); 2784 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 2785 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n" 2786 "}"); 2787 2788 verifyFormat( 2789 "aaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 2790 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); 2791 2792 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 2793 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 2794 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 2795 2796 verifyFormat( 2797 "aaaaaaaa(aaaaaaaaaaaaa, aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 2798 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n" 2799 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 2800 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));"); 2801 2802 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 2803 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 2804 2805 verifyFormat( 2806 "void f() {\n" 2807 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&\n" 2808 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 2809 "}"); 2810 verifyFormat( 2811 "aaaaaa(new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 2812 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 2813 verifyFormat( 2814 "aaaaaa(aaa, new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 2815 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 2816 verifyFormat( 2817 "aaaaaaaaaaaaaaaaa(\n" 2818 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 2819 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 2820 2821 // Indent consistently indenpendent of call expression. 2822 verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbb.ccccccccccccccccc(\n" 2823 " dddddddddddddddddddddddddddddd));\n" 2824 "aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 2825 " dddddddddddddddddddddddddddddd));"); 2826 2827 // This test case breaks on an incorrect memoization, i.e. an optimization not 2828 // taking into account the StopAt value. 2829 verifyFormat( 2830 "return aaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 2831 " aaaaaaaaaaa(aaaaaaaaa) || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 2832 " aaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 2833 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 2834 2835 verifyFormat("{\n {\n {\n" 2836 " Annotation.SpaceRequiredBefore =\n" 2837 " Line.Tokens[i - 1].Tok.isNot(tok::l_paren) &&\n" 2838 " Line.Tokens[i - 1].Tok.isNot(tok::l_square);\n" 2839 " }\n }\n}"); 2840 2841 // Break on an outer level if there was a break on an inner level. 2842 EXPECT_EQ("f(g(h(a, // comment\n" 2843 " b, c),\n" 2844 " d, e),\n" 2845 " x, y);", 2846 format("f(g(h(a, // comment\n" 2847 " b, c), d, e), x, y);")); 2848 2849 // Prefer breaking similar line breaks. 2850 verifyFormat( 2851 "const int kTrackingOptions = NSTrackingMouseMoved |\n" 2852 " NSTrackingMouseEnteredAndExited |\n" 2853 " NSTrackingActiveAlways;"); 2854 } 2855 2856 TEST_F(FormatTest, FormatsOneParameterPerLineIfNecessary) { 2857 FormatStyle NoBinPacking = getGoogleStyle(); 2858 NoBinPacking.BinPackParameters = false; 2859 verifyFormat("f(aaaaaaaaaaaaaaaaaaaa,\n" 2860 " aaaaaaaaaaaaaaaaaaaa,\n" 2861 " aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaa);", 2862 NoBinPacking); 2863 verifyFormat("aaaaaaa(aaaaaaaaaaaaa,\n" 2864 " aaaaaaaaaaaaa,\n" 2865 " aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));", 2866 NoBinPacking); 2867 verifyFormat( 2868 "aaaaaaaa(aaaaaaaaaaaaa,\n" 2869 " aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 2870 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n" 2871 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 2872 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));", 2873 NoBinPacking); 2874 verifyFormat("aaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n" 2875 " .aaaaaaaaaaaaaaaaaa();", 2876 NoBinPacking); 2877 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 2878 " aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaa);", 2879 NoBinPacking); 2880 2881 verifyFormat( 2882 "aaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 2883 " aaaaaaaaaaaa,\n" 2884 " aaaaaaaaaaaa);", 2885 NoBinPacking); 2886 verifyFormat( 2887 "somefunction(someotherFunction(ddddddddddddddddddddddddddddddddddd,\n" 2888 " ddddddddddddddddddddddddddddd),\n" 2889 " test);", 2890 NoBinPacking); 2891 2892 verifyFormat("std::vector<aaaaaaaaaaaaaaaaaaaaaaa,\n" 2893 " aaaaaaaaaaaaaaaaaaaaaaa,\n" 2894 " aaaaaaaaaaaaaaaaaaaaaaa> aaaaaaaaaaaaaaaaaa;", 2895 NoBinPacking); 2896 verifyFormat("a(\"a\"\n" 2897 " \"a\",\n" 2898 " a);"); 2899 2900 NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false; 2901 verifyFormat("void aaaaaaaaaa(aaaaaaaaa,\n" 2902 " aaaaaaaaa,\n" 2903 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 2904 NoBinPacking); 2905 verifyFormat( 2906 "void f() {\n" 2907 " aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n" 2908 " .aaaaaaa();\n" 2909 "}", 2910 NoBinPacking); 2911 verifyFormat( 2912 "template <class SomeType, class SomeOtherType>\n" 2913 "SomeType SomeFunction(SomeType Type, SomeOtherType OtherType) {}", 2914 NoBinPacking); 2915 } 2916 2917 TEST_F(FormatTest, AdaptiveOnePerLineFormatting) { 2918 FormatStyle Style = getLLVMStyleWithColumns(15); 2919 Style.ExperimentalAutoDetectBinPacking = true; 2920 EXPECT_EQ("aaa(aaaa,\n" 2921 " aaaa,\n" 2922 " aaaa);\n" 2923 "aaa(aaaa,\n" 2924 " aaaa,\n" 2925 " aaaa);", 2926 format("aaa(aaaa,\n" // one-per-line 2927 " aaaa,\n" 2928 " aaaa );\n" 2929 "aaa(aaaa, aaaa, aaaa);", // inconclusive 2930 Style)); 2931 EXPECT_EQ("aaa(aaaa, aaaa,\n" 2932 " aaaa);\n" 2933 "aaa(aaaa, aaaa,\n" 2934 " aaaa);", 2935 format("aaa(aaaa, aaaa,\n" // bin-packed 2936 " aaaa );\n" 2937 "aaa(aaaa, aaaa, aaaa);", // inconclusive 2938 Style)); 2939 } 2940 2941 TEST_F(FormatTest, FormatsBuilderPattern) { 2942 verifyFormat( 2943 "return llvm::StringSwitch<Reference::Kind>(name)\n" 2944 " .StartsWith(\".eh_frame_hdr\", ORDER_EH_FRAMEHDR)\n" 2945 " .StartsWith(\".eh_frame\", ORDER_EH_FRAME)\n" 2946 " .StartsWith(\".init\", ORDER_INIT)\n" 2947 " .StartsWith(\".fini\", ORDER_FINI)\n" 2948 " .StartsWith(\".hash\", ORDER_HASH)\n" 2949 " .Default(ORDER_TEXT);\n"); 2950 2951 verifyFormat("return aaaaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa() <\n" 2952 " aaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa();"); 2953 verifyFormat( 2954 "aaaaaaa->aaaaaaa->aaaaaaaaaaaaaaaa(\n" 2955 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 2956 " ->aaaaaaaa(aaaaaaaaaaaaaaa);"); 2957 verifyFormat( 2958 "aaaaaaaaaaaaaaaaaaa()->aaaaaa(bbbbb)->aaaaaaaaaaaaaaaaaaa( // break\n" 2959 " aaaaaaaaaaaaaa);"); 2960 verifyFormat( 2961 "aaaaaaaaaaaaaaaaaaaaaaa *aaaaaaaaa =\n" 2962 " aaaaaa->aaaaaaaaaaaa()\n" 2963 " ->aaaaaaaaaaaaaaaa(\n" 2964 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 2965 " ->aaaaaaaaaaaaaaaaa();"); 2966 verifyFormat( 2967 "someobj->Add((new util::filetools::Handler(dir))\n" 2968 " ->OnEvent1(NewPermanentCallback(\n" 2969 " this, &HandlerHolderClass::EventHandlerCBA))\n" 2970 " ->OnEvent2(NewPermanentCallback(\n" 2971 " this, &HandlerHolderClass::EventHandlerCBB))\n" 2972 " ->OnEvent3(NewPermanentCallback(\n" 2973 " this, &HandlerHolderClass::EventHandlerCBC))\n" 2974 " ->OnEvent5(NewPermanentCallback(\n" 2975 " this, &HandlerHolderClass::EventHandlerCBD))\n" 2976 " ->OnEvent6(NewPermanentCallback(\n" 2977 " this, &HandlerHolderClass::EventHandlerCBE)));"); 2978 2979 verifyFormat( 2980 "aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa();"); 2981 verifyFormat("aaaaaaaaaaaaaaa()\n" 2982 " .aaaaaaaaaaaaaaa()\n" 2983 " .aaaaaaaaaaaaaaa()\n" 2984 " .aaaaaaaaaaaaaaa()\n" 2985 " .aaaaaaaaaaaaaaa();"); 2986 verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n" 2987 " .aaaaaaaaaaaaaaa()\n" 2988 " .aaaaaaaaaaaaaaa()\n" 2989 " .aaaaaaaaaaaaaaa();"); 2990 verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n" 2991 " .aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n" 2992 " .aaaaaaaaaaaaaaa();"); 2993 verifyFormat("aaaaaaaaaaaaa->aaaaaaaaaaaaaaaaaaaaaaaa()\n" 2994 " ->aaaaaaaaaaaaaae(0)\n" 2995 " ->aaaaaaaaaaaaaaa();"); 2996 2997 // Prefer not to break after empty parentheses. 2998 verifyFormat("FirstToken->WhitespaceRange.getBegin().getLocWithOffset(\n" 2999 " First->LastNewlineOffset);"); 3000 } 3001 3002 TEST_F(FormatTest, BreaksAccordingToOperatorPrecedence) { 3003 verifyFormat( 3004 "if (aaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 3005 " bbbbbbbbbbbbbbbbbbbbbbbbb && ccccccccccccccccccccccccc) {\n}"); 3006 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa && bbbbbbbbbbbbbbbbbbbbbbbbb ||\n" 3007 " ccccccccccccccccccccccccc) {\n}"); 3008 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb ||\n" 3009 " ccccccccccccccccccccccccc) {\n}"); 3010 verifyFormat( 3011 "if ((aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb) &&\n" 3012 " ccccccccccccccccccccccccc) {\n}"); 3013 verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA ||\n" 3014 " bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB ||\n" 3015 " cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC ||\n" 3016 " dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;"); 3017 verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa ||\n" 3018 " aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) &&\n" 3019 " aaaaaaaaaaaaaaa != aa) {\n}"); 3020 } 3021 3022 TEST_F(FormatTest, BreaksAfterAssignments) { 3023 verifyFormat( 3024 "unsigned Cost =\n" 3025 " TTI.getMemoryOpCost(I->getOpcode(), VectorTy, SI->getAlignment(),\n" 3026 " SI->getPointerAddressSpaceee());\n"); 3027 verifyFormat( 3028 "CharSourceRange LineRange = CharSourceRange::getTokenRange(\n" 3029 " Line.Tokens.front().Tok.getLo(), Line.Tokens.back().Tok.getLoc());"); 3030 3031 verifyFormat( 3032 "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa = aaaaaaaaaaaaaa(0).aaaa().aaaaaaaaa(\n" 3033 " aaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaa);"); 3034 verifyFormat("unsigned OriginalStartColumn =\n" 3035 " SourceMgr.getSpellingColumnNumber(\n" 3036 " Current.FormatTok.getStartOfNonWhitespace()) -\n" 3037 " 1;"); 3038 } 3039 3040 TEST_F(FormatTest, AlignsAfterAssignments) { 3041 verifyFormat( 3042 "int Result = aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3043 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 3044 verifyFormat( 3045 "Result += aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3046 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 3047 verifyFormat( 3048 "Result >>= aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3049 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 3050 verifyFormat( 3051 "int Result = (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3052 " aaaaaaaaaaaaaaaaaaaaaaaaa);"); 3053 verifyFormat( 3054 "double LooooooooooooooooooooooooongResult = aaaaaaaaaaaaaaaaaaaaaaaa +\n" 3055 " aaaaaaaaaaaaaaaaaaaaaaaa +\n" 3056 " aaaaaaaaaaaaaaaaaaaaaaaa;"); 3057 } 3058 3059 TEST_F(FormatTest, AlignsAfterReturn) { 3060 verifyFormat( 3061 "return aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3062 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 3063 verifyFormat( 3064 "return (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3065 " aaaaaaaaaaaaaaaaaaaaaaaaa);"); 3066 verifyFormat( 3067 "return aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n" 3068 " aaaaaaaaaaaaaaaaaaaaaa();"); 3069 verifyFormat( 3070 "return (aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n" 3071 " aaaaaaaaaaaaaaaaaaaaaa());"); 3072 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3073 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 3074 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3075 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) &&\n" 3076 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 3077 } 3078 3079 TEST_F(FormatTest, BreaksConditionalExpressions) { 3080 verifyFormat( 3081 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3082 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3083 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 3084 verifyFormat( 3085 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3086 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 3087 verifyFormat( 3088 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa)\n" 3089 " : aaaaaaaaaaaaa);"); 3090 verifyFormat( 3091 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 3092 " aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3093 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 3094 " aaaaaaaaaaaaa);"); 3095 verifyFormat( 3096 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 3097 " aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 3098 " aaaaaaaaaaaaa);"); 3099 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3100 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3101 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 3102 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3103 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 3104 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 3105 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3106 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3107 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 3108 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3109 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 3110 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 3111 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 3112 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3113 " ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3114 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 3115 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 3116 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3117 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3118 " : aaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 3119 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n" 3120 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3121 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3122 " : aaaaaaaaaaaaaaaa;"); 3123 verifyFormat( 3124 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3125 " ? aaaaaaaaaaaaaaa\n" 3126 " : aaaaaaaaaaaaaaa;"); 3127 verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n" 3128 " aaaaaaaaa\n" 3129 " ? b\n" 3130 " : c);"); 3131 verifyFormat( 3132 "unsigned Indent =\n" 3133 " format(TheLine.First, IndentForLevel[TheLine.Level] >= 0\n" 3134 " ? IndentForLevel[TheLine.Level]\n" 3135 " : TheLine * 2,\n" 3136 " TheLine.InPPDirective, PreviousEndOfLineColumn);", 3137 getLLVMStyleWithColumns(70)); 3138 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n" 3139 " ? aaaaaaaaaaaaaaa\n" 3140 " : bbbbbbbbbbbbbbb //\n" 3141 " ? ccccccccccccccc\n" 3142 " : ddddddddddddddd;"); 3143 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n" 3144 " ? aaaaaaaaaaaaaaa\n" 3145 " : (bbbbbbbbbbbbbbb //\n" 3146 " ? ccccccccccccccc\n" 3147 " : ddddddddddddddd);"); 3148 3149 FormatStyle NoBinPacking = getLLVMStyle(); 3150 NoBinPacking.BinPackParameters = false; 3151 verifyFormat( 3152 "void f() {\n" 3153 " g(aaa,\n" 3154 " aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n" 3155 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3156 " ? aaaaaaaaaaaaaaa\n" 3157 " : aaaaaaaaaaaaaaa);\n" 3158 "}", 3159 NoBinPacking); 3160 verifyFormat( 3161 "void f() {\n" 3162 " g(aaa,\n" 3163 " aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n" 3164 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3165 " ?: aaaaaaaaaaaaaaa);\n" 3166 "}", 3167 NoBinPacking); 3168 } 3169 3170 TEST_F(FormatTest, DeclarationsOfMultipleVariables) { 3171 verifyFormat("bool aaaaaaaaaaaaaaaaa = aaaaaa->aaaaaaaaaaaaaaaaa(),\n" 3172 " aaaaaaaaaaa = aaaaaa->aaaaaaaaaaa();"); 3173 verifyFormat("bool a = true, b = false;"); 3174 3175 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaa =\n" 3176 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa),\n" 3177 " bbbbbbbbbbbbbbbbbbbbbbbbb =\n" 3178 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(bbbbbbbbbbbbbbbb);"); 3179 verifyFormat( 3180 "bool aaaaaaaaaaaaaaaaaaaaa =\n" 3181 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb && cccccccccccccccccccccccccccc,\n" 3182 " d = e && f;"); 3183 verifyFormat("aaaaaaaaa a = aaaaaaaaaaaaaaaaaaaa, b = bbbbbbbbbbbbbbbbbbbb,\n" 3184 " c = cccccccccccccccccccc, d = dddddddddddddddddddd;"); 3185 verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n" 3186 " *c = ccccccccccccccccccc, *d = ddddddddddddddddddd;"); 3187 verifyFormat("aaaaaaaaa ***a = aaaaaaaaaaaaaaaaaaa, ***b = bbbbbbbbbbbbbbb,\n" 3188 " ***c = ccccccccccccccccccc, ***d = ddddddddddddddd;"); 3189 // FIXME: If multiple variables are defined, the "*" needs to move to the new 3190 // line. Also fix indent for breaking after the type, this looks bad. 3191 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*\n" 3192 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaa,\n" 3193 " *b = bbbbbbbbbbbbbbbbbbb;", 3194 getGoogleStyle()); 3195 3196 // Not ideal, but pointer-with-type does not allow much here. 3197 verifyGoogleFormat( 3198 "aaaaaaaaa* a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n" 3199 " *b = bbbbbbbbbbbbbbbbbbb, *d = ddddddddddddddddddd;"); 3200 } 3201 3202 TEST_F(FormatTest, ConditionalExpressionsInBrackets) { 3203 verifyFormat("arr[foo ? bar : baz];"); 3204 verifyFormat("f()[foo ? bar : baz];"); 3205 verifyFormat("(a + b)[foo ? bar : baz];"); 3206 verifyFormat("arr[foo ? (4 > 5 ? 4 : 5) : 5 < 5 ? 5 : 7];"); 3207 } 3208 3209 TEST_F(FormatTest, AlignsStringLiterals) { 3210 verifyFormat("loooooooooooooooooooooooooongFunction(\"short literal \"\n" 3211 " \"short literal\");"); 3212 verifyFormat( 3213 "looooooooooooooooooooooooongFunction(\n" 3214 " \"short literal\"\n" 3215 " \"looooooooooooooooooooooooooooooooooooooooooooooooong literal\");"); 3216 verifyFormat("someFunction(\"Always break between multi-line\"\n" 3217 " \" string literals\",\n" 3218 " and, other, parameters);"); 3219 EXPECT_EQ("fun + \"1243\" /* comment */\n" 3220 " \"5678\";", 3221 format("fun + \"1243\" /* comment */\n" 3222 " \"5678\";", 3223 getLLVMStyleWithColumns(28))); 3224 EXPECT_EQ( 3225 "aaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 3226 " \"aaaaaaaaaaaaaaaaaaaaa\"\n" 3227 " \"aaaaaaaaaaaaaaaa\";", 3228 format("aaaaaa =" 3229 "\"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa " 3230 "aaaaaaaaaaaaaaaaaaaaa\" " 3231 "\"aaaaaaaaaaaaaaaa\";")); 3232 verifyFormat("a = a + \"a\"\n" 3233 " \"a\"\n" 3234 " \"a\";"); 3235 verifyFormat("f(\"a\", \"b\"\n" 3236 " \"c\");"); 3237 3238 verifyFormat( 3239 "#define LL_FORMAT \"ll\"\n" 3240 "printf(\"aaaaa: %d, bbbbbb: %\" LL_FORMAT \"d, cccccccc: %\" LL_FORMAT\n" 3241 " \"d, ddddddddd: %\" LL_FORMAT \"d\");"); 3242 3243 verifyFormat("#define A(X) \\\n" 3244 " \"aaaaa\" #X \"bbbbbb\" \\\n" 3245 " \"ccccc\"", 3246 getLLVMStyleWithColumns(23)); 3247 verifyFormat("#define A \"def\"\n" 3248 "f(\"abc\" A \"ghi\"\n" 3249 " \"jkl\");"); 3250 } 3251 3252 TEST_F(FormatTest, AlwaysBreakBeforeMultilineStrings) { 3253 FormatStyle NoBreak = getLLVMStyle(); 3254 NoBreak.AlwaysBreakBeforeMultilineStrings = false; 3255 FormatStyle Break = getLLVMStyle(); 3256 Break.AlwaysBreakBeforeMultilineStrings = true; 3257 verifyFormat("aaaa = \"bbbb\"\n" 3258 " \"cccc\";", 3259 NoBreak); 3260 verifyFormat("aaaa =\n" 3261 " \"bbbb\"\n" 3262 " \"cccc\";", 3263 Break); 3264 verifyFormat("aaaa(\"bbbb\"\n" 3265 " \"cccc\");", 3266 NoBreak); 3267 verifyFormat("aaaa(\n" 3268 " \"bbbb\"\n" 3269 " \"cccc\");", 3270 Break); 3271 verifyFormat("aaaa(qqq, \"bbbb\"\n" 3272 " \"cccc\");", 3273 NoBreak); 3274 verifyFormat("aaaa(qqq,\n" 3275 " \"bbbb\"\n" 3276 " \"cccc\");", 3277 Break); 3278 3279 // Don't break if there is no column gain. 3280 verifyFormat("f(\"aaaa\"\n" 3281 " \"bbbb\");", 3282 Break); 3283 3284 // Treat literals with escaped newlines like multi-line string literals. 3285 EXPECT_EQ("x = \"a\\\n" 3286 "b\\\n" 3287 "c\";", 3288 format("x = \"a\\\n" 3289 "b\\\n" 3290 "c\";", 3291 NoBreak)); 3292 EXPECT_EQ("x =\n" 3293 " \"a\\\n" 3294 "b\\\n" 3295 "c\";", 3296 format("x = \"a\\\n" 3297 "b\\\n" 3298 "c\";", 3299 Break)); 3300 } 3301 3302 TEST_F(FormatTest, AlignsPipes) { 3303 verifyFormat( 3304 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3305 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3306 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 3307 verifyFormat( 3308 "aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa\n" 3309 " << aaaaaaaaaaaaaaaaaaaa;"); 3310 verifyFormat( 3311 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3312 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 3313 verifyFormat( 3314 "llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"\n" 3315 " \"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\"\n" 3316 " << \"ccccccccccccccccccccccccccccccccccccccccccccccccc\";"); 3317 verifyFormat( 3318 "aaaaaaaa << (aaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3319 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 3320 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 3321 3322 verifyFormat("return out << \"somepacket = {\\n\"\n" 3323 " << \" aaaaaa = \" << pkt.aaaaaa << \"\\n\"\n" 3324 " << \" bbbb = \" << pkt.bbbb << \"\\n\"\n" 3325 " << \" cccccc = \" << pkt.cccccc << \"\\n\"\n" 3326 " << \" ddd = [\" << pkt.ddd << \"]\\n\"\n" 3327 " << \"}\";"); 3328 3329 verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n" 3330 " << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n" 3331 " << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa;"); 3332 verifyFormat( 3333 "llvm::outs() << \"aaaaaaaaaaaaaaaaa = \" << aaaaaaaaaaaaaaaaa\n" 3334 " << \"bbbbbbbbbbbbbbbbb = \" << bbbbbbbbbbbbbbbbb\n" 3335 " << \"ccccccccccccccccc = \" << ccccccccccccccccc\n" 3336 " << \"ddddddddddddddddd = \" << ddddddddddddddddd\n" 3337 " << \"eeeeeeeeeeeeeeeee = \" << eeeeeeeeeeeeeeeee;"); 3338 verifyFormat("llvm::outs() << aaaaaaaaaaaaaaaaaaaaaaaa << \"=\"\n" 3339 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 3340 verifyFormat( 3341 "void f() {\n" 3342 " llvm::outs() << \"aaaaaaaaaaaaaaaaaaaa: \"\n" 3343 " << aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 3344 "}"); 3345 3346 // Breaking before the first "<<" is generally not desirable. 3347 verifyFormat( 3348 "llvm::errs()\n" 3349 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3350 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3351 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3352 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 3353 getLLVMStyleWithColumns(70)); 3354 verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaa: \"\n" 3355 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3356 " << \"aaaaaaaaaaaaaaaaaaa: \"\n" 3357 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3358 " << \"aaaaaaaaaaaaaaaaaaa: \"\n" 3359 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 3360 getLLVMStyleWithColumns(70)); 3361 3362 // But sometimes, breaking before the first "<<" is desirable. 3363 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbb)\n" 3364 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3365 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 3366 verifyFormat("SemaRef.Diag(Loc, diag::note_for_range_begin_end)\n" 3367 " << BEF << IsTemplate << Description << E->getType();"); 3368 3369 verifyFormat( 3370 "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3371 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 3372 } 3373 3374 TEST_F(FormatTest, UnderstandsEquals) { 3375 verifyFormat( 3376 "aaaaaaaaaaaaaaaaa =\n" 3377 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 3378 verifyFormat( 3379 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 3380 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 3381 verifyFormat( 3382 "if (a) {\n" 3383 " f();\n" 3384 "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 3385 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 3386 "}"); 3387 3388 verifyFormat("if (int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 3389 " 100000000 + 10000000) {\n}"); 3390 } 3391 3392 TEST_F(FormatTest, WrapsAtFunctionCallsIfNecessary) { 3393 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n" 3394 " .looooooooooooooooooooooooooooooooooooooongFunction();"); 3395 3396 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n" 3397 " ->looooooooooooooooooooooooooooooooooooooongFunction();"); 3398 3399 verifyFormat( 3400 "LooooooooooooooooooooooooooooooooongObject->shortFunction(Parameter1,\n" 3401 " Parameter2);"); 3402 3403 verifyFormat( 3404 "ShortObject->shortFunction(\n" 3405 " LooooooooooooooooooooooooooooooooooooooooooooooongParameter1,\n" 3406 " LooooooooooooooooooooooooooooooooooooooooooooooongParameter2);"); 3407 3408 verifyFormat("loooooooooooooongFunction(\n" 3409 " LoooooooooooooongObject->looooooooooooooooongFunction());"); 3410 3411 verifyFormat( 3412 "function(LoooooooooooooooooooooooooooooooooooongObject\n" 3413 " ->loooooooooooooooooooooooooooooooooooooooongFunction());"); 3414 3415 verifyFormat("EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n" 3416 " .WillRepeatedly(Return(SomeValue));"); 3417 verifyFormat("SomeMap[std::pair(aaaaaaaaaaaa, bbbbbbbbbbbbbbb)]\n" 3418 " .insert(ccccccccccccccccccccccc);"); 3419 verifyFormat("aaaaa(aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 3420 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa).aaaaa(aaaaa),\n" 3421 " aaaaaaaaaaaaaaaaaaaaa);"); 3422 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3423 " aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa)->aaaaaaaaa());"); 3424 verifyFormat( 3425 "aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 3426 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 3427 " .aaaaaaaaaaaaaaa(aa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 3428 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 3429 " aaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 3430 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3431 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3432 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3433 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()) {\n" 3434 "}"); 3435 3436 // Here, it is not necessary to wrap at "." or "->". 3437 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaa) ||\n" 3438 " aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 3439 verifyFormat( 3440 "aaaaaaaaaaa->aaaaaaaaa(\n" 3441 " aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 3442 " aaaaaaaaaaaaaaaaaa->aaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa));\n"); 3443 3444 verifyFormat( 3445 "aaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3446 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa().aaaaaaaaaaaaaaaaa());"); 3447 verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() *\n" 3448 " aaaaaaaaa()->aaaaaa()->aaaaa());"); 3449 verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() ||\n" 3450 " aaaaaaaaa()->aaaaaa()->aaaaa());"); 3451 3452 // FIXME: Should we break before .a()? 3453 verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 3454 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa).a();"); 3455 3456 FormatStyle NoBinPacking = getLLVMStyle(); 3457 NoBinPacking.BinPackParameters = false; 3458 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n" 3459 " .aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n" 3460 " .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa,\n" 3461 " aaaaaaaaaaaaaaaaaaa,\n" 3462 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 3463 NoBinPacking); 3464 3465 // If there is a subsequent call, change to hanging indentation. 3466 verifyFormat( 3467 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3468 " aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa))\n" 3469 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 3470 verifyFormat( 3471 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3472 " aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa));"); 3473 } 3474 3475 TEST_F(FormatTest, WrapsTemplateDeclarations) { 3476 verifyFormat("template <typename T>\n" 3477 "virtual void loooooooooooongFunction(int Param1, int Param2);"); 3478 verifyFormat( 3479 "template <typename T>\n" 3480 "using comment_to_xml_conversion = comment_to_xml_conversion<T, int>;"); 3481 verifyFormat("template <typename T>\n" 3482 "void f(int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram1,\n" 3483 " int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram2);"); 3484 verifyFormat( 3485 "template <typename T>\n" 3486 "void looooooooooooooooooooongFunction(int Paaaaaaaaaaaaaaaaaaaaram1,\n" 3487 " int Paaaaaaaaaaaaaaaaaaaaram2);"); 3488 verifyFormat( 3489 "template <typename T>\n" 3490 "aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaa,\n" 3491 " aaaaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaa,\n" 3492 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 3493 verifyFormat("template <typename T>\n" 3494 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3495 " int aaaaaaaaaaaaaaaaaaaaaa);"); 3496 verifyFormat( 3497 "template <typename T1, typename T2 = char, typename T3 = char,\n" 3498 " typename T4 = char>\n" 3499 "void f();"); 3500 verifyFormat( 3501 "aaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>(\n" 3502 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 3503 3504 verifyFormat("a<aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaa>(\n" 3505 " a(aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));"); 3506 3507 verifyFormat("template <typename T> class C {};"); 3508 verifyFormat("template <typename T> void f();"); 3509 verifyFormat("template <typename T> void f() {}"); 3510 3511 FormatStyle AlwaysBreak = getLLVMStyle(); 3512 AlwaysBreak.AlwaysBreakTemplateDeclarations = true; 3513 verifyFormat("template <typename T>\nclass C {};", AlwaysBreak); 3514 verifyFormat("template <typename T>\nvoid f();", AlwaysBreak); 3515 verifyFormat("template <typename T>\nvoid f() {}", AlwaysBreak); 3516 verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 3517 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n" 3518 " ccccccccccccccccccccccccccccccccccccccccccccccc);"); 3519 verifyFormat( 3520 "aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n" 3521 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 3522 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> *aaaa =\n" 3523 " new aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n" 3524 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 3525 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>(\n" 3526 " bbbbbbbbbbbbbbbbbbbbbbbb);", 3527 getLLVMStyleWithColumns(72)); 3528 } 3529 3530 TEST_F(FormatTest, WrapsAtNestedNameSpecifiers) { 3531 verifyFormat( 3532 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 3533 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 3534 verifyFormat( 3535 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 3536 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3537 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());"); 3538 3539 // FIXME: Should we have the extra indent after the second break? 3540 verifyFormat( 3541 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 3542 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 3543 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 3544 3545 verifyFormat( 3546 "aaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb::\n" 3547 " cccccccccccccccccccccccccccccccccccccccccccccc());"); 3548 3549 // Breaking at nested name specifiers is generally not desirable. 3550 verifyFormat( 3551 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3552 " aaaaaaaaaaaaaaaaaaaaaaa);"); 3553 3554 verifyFormat( 3555 "aaaaaaaaaaaaaaaaaa(aaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 3556 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 3557 " aaaaaaaaaaaaaaaaaaaaa);", 3558 getLLVMStyleWithColumns(74)); 3559 3560 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 3561 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3562 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 3563 } 3564 3565 TEST_F(FormatTest, UnderstandsTemplateParameters) { 3566 verifyFormat("A<int> a;"); 3567 verifyFormat("A<A<A<int> > > a;"); 3568 verifyFormat("A<A<A<int, 2>, 3>, 4> a;"); 3569 verifyFormat("bool x = a < 1 || 2 > a;"); 3570 verifyFormat("bool x = 5 < f<int>();"); 3571 verifyFormat("bool x = f<int>() > 5;"); 3572 verifyFormat("bool x = 5 < a<int>::x;"); 3573 verifyFormat("bool x = a < 4 ? a > 2 : false;"); 3574 verifyFormat("bool x = f() ? a < 2 : a > 2;"); 3575 3576 verifyGoogleFormat("A<A<int>> a;"); 3577 verifyGoogleFormat("A<A<A<int>>> a;"); 3578 verifyGoogleFormat("A<A<A<A<int>>>> a;"); 3579 verifyGoogleFormat("A<A<int> > a;"); 3580 verifyGoogleFormat("A<A<A<int> > > a;"); 3581 verifyGoogleFormat("A<A<A<A<int> > > > a;"); 3582 EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A> >> a;", getGoogleStyle())); 3583 EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A>> > a;", getGoogleStyle())); 3584 3585 verifyFormat("test >> a >> b;"); 3586 verifyFormat("test << a >> b;"); 3587 3588 verifyFormat("f<int>();"); 3589 verifyFormat("template <typename T> void f() {}"); 3590 3591 // Not template parameters. 3592 verifyFormat("return a < b && c > d;"); 3593 verifyFormat("void f() {\n" 3594 " while (a < b && c > d) {\n" 3595 " }\n" 3596 "}"); 3597 verifyFormat("template <typename... Types>\n" 3598 "typename enable_if<0 < sizeof...(Types)>::type Foo() {}"); 3599 } 3600 3601 TEST_F(FormatTest, UnderstandsBinaryOperators) { 3602 verifyFormat("COMPARE(a, ==, b);"); 3603 } 3604 3605 TEST_F(FormatTest, UnderstandsPointersToMembers) { 3606 verifyFormat("int A::*x;"); 3607 verifyFormat("int (S::*func)(void *);"); 3608 verifyFormat("void f() { int (S::*func)(void *); }"); 3609 verifyFormat("typedef bool *(Class::*Member)() const;"); 3610 verifyFormat("void f() {\n" 3611 " (a->*f)();\n" 3612 " a->*x;\n" 3613 " (a.*f)();\n" 3614 " ((*a).*f)();\n" 3615 " a.*x;\n" 3616 "}"); 3617 verifyFormat("void f() {\n" 3618 " (a->*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n" 3619 " aaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);\n" 3620 "}"); 3621 FormatStyle Style = getLLVMStyle(); 3622 Style.PointerBindsToType = true; 3623 verifyFormat("typedef bool* (Class::*Member)() const;", Style); 3624 } 3625 3626 TEST_F(FormatTest, UnderstandsUnaryOperators) { 3627 verifyFormat("int a = -2;"); 3628 verifyFormat("f(-1, -2, -3);"); 3629 verifyFormat("a[-1] = 5;"); 3630 verifyFormat("int a = 5 + -2;"); 3631 verifyFormat("if (i == -1) {\n}"); 3632 verifyFormat("if (i != -1) {\n}"); 3633 verifyFormat("if (i > -1) {\n}"); 3634 verifyFormat("if (i < -1) {\n}"); 3635 verifyFormat("++(a->f());"); 3636 verifyFormat("--(a->f());"); 3637 verifyFormat("(a->f())++;"); 3638 verifyFormat("a[42]++;"); 3639 verifyFormat("if (!(a->f())) {\n}"); 3640 3641 verifyFormat("a-- > b;"); 3642 verifyFormat("b ? -a : c;"); 3643 verifyFormat("n * sizeof char16;"); 3644 verifyFormat("n * alignof char16;", getGoogleStyle()); 3645 verifyFormat("sizeof(char);"); 3646 verifyFormat("alignof(char);", getGoogleStyle()); 3647 3648 verifyFormat("return -1;"); 3649 verifyFormat("switch (a) {\n" 3650 "case -1:\n" 3651 " break;\n" 3652 "}"); 3653 verifyFormat("#define X -1"); 3654 verifyFormat("#define X -kConstant"); 3655 3656 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = { -5, +3 };"); 3657 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = { +5, -3 };"); 3658 3659 verifyFormat("int a = /* confusing comment */ -1;"); 3660 // FIXME: The space after 'i' is wrong, but hopefully, this is a rare case. 3661 verifyFormat("int a = i /* confusing comment */++;"); 3662 } 3663 3664 TEST_F(FormatTest, IndentsRelativeToUnaryOperators) { 3665 verifyFormat("if (!aaaaaaaaaa( // break\n" 3666 " aaaaa)) {\n" 3667 "}"); 3668 verifyFormat("aaaaaaaaaa(!aaaaaaaaaa( // break\n" 3669 " aaaaa));"); 3670 3671 // Only indent relative to unary operators if the expression is nested. 3672 verifyFormat("*aaa = aaaaaaa( // break\n" 3673 " bbbbbb);"); 3674 } 3675 3676 TEST_F(FormatTest, UnderstandsOverloadedOperators) { 3677 verifyFormat("bool operator<();"); 3678 verifyFormat("bool operator>();"); 3679 verifyFormat("bool operator=();"); 3680 verifyFormat("bool operator==();"); 3681 verifyFormat("bool operator!=();"); 3682 verifyFormat("int operator+();"); 3683 verifyFormat("int operator++();"); 3684 verifyFormat("bool operator();"); 3685 verifyFormat("bool operator()();"); 3686 verifyFormat("bool operator[]();"); 3687 verifyFormat("operator bool();"); 3688 verifyFormat("operator int();"); 3689 verifyFormat("operator void *();"); 3690 verifyFormat("operator SomeType<int>();"); 3691 verifyFormat("operator SomeType<int, int>();"); 3692 verifyFormat("operator SomeType<SomeType<int> >();"); 3693 verifyFormat("void *operator new(std::size_t size);"); 3694 verifyFormat("void *operator new[](std::size_t size);"); 3695 verifyFormat("void operator delete(void *ptr);"); 3696 verifyFormat("void operator delete[](void *ptr);"); 3697 verifyFormat("template <typename AAAAAAA, typename BBBBBBB>\n" 3698 "AAAAAAA operator/(const AAAAAAA &a, BBBBBBB &b);"); 3699 3700 verifyFormat( 3701 "ostream &operator<<(ostream &OutputStream,\n" 3702 " SomeReallyLongType WithSomeReallyLongValue);"); 3703 verifyFormat("bool operator<(const aaaaaaaaaaaaaaaaaaaaa &left,\n" 3704 " const aaaaaaaaaaaaaaaaaaaaa &right) {\n" 3705 " return left.group < right.group;\n" 3706 "}"); 3707 verifyFormat("SomeType &operator=(const SomeType &S);"); 3708 3709 verifyGoogleFormat("operator void*();"); 3710 verifyGoogleFormat("operator SomeType<SomeType<int>>();"); 3711 3712 verifyFormat("using A::operator+;"); 3713 } 3714 3715 TEST_F(FormatTest, UnderstandsNewAndDelete) { 3716 verifyFormat("void f() {\n" 3717 " A *a = new A;\n" 3718 " A *a = new (placement) A;\n" 3719 " delete a;\n" 3720 " delete (A *)a;\n" 3721 "}"); 3722 } 3723 3724 TEST_F(FormatTest, UnderstandsUsesOfStarAndAmp) { 3725 verifyFormat("int *f(int *a) {}"); 3726 verifyFormat("int main(int argc, char **argv) {}"); 3727 verifyFormat("Test::Test(int b) : a(b * b) {}"); 3728 verifyIndependentOfContext("f(a, *a);"); 3729 verifyFormat("void g() { f(*a); }"); 3730 verifyIndependentOfContext("int a = b * 10;"); 3731 verifyIndependentOfContext("int a = 10 * b;"); 3732 verifyIndependentOfContext("int a = b * c;"); 3733 verifyIndependentOfContext("int a += b * c;"); 3734 verifyIndependentOfContext("int a -= b * c;"); 3735 verifyIndependentOfContext("int a *= b * c;"); 3736 verifyIndependentOfContext("int a /= b * c;"); 3737 verifyIndependentOfContext("int a = *b;"); 3738 verifyIndependentOfContext("int a = *b * c;"); 3739 verifyIndependentOfContext("int a = b * *c;"); 3740 verifyIndependentOfContext("return 10 * b;"); 3741 verifyIndependentOfContext("return *b * *c;"); 3742 verifyIndependentOfContext("return a & ~b;"); 3743 verifyIndependentOfContext("f(b ? *c : *d);"); 3744 verifyIndependentOfContext("int a = b ? *c : *d;"); 3745 verifyIndependentOfContext("*b = a;"); 3746 verifyIndependentOfContext("a * ~b;"); 3747 verifyIndependentOfContext("a * !b;"); 3748 verifyIndependentOfContext("a * +b;"); 3749 verifyIndependentOfContext("a * -b;"); 3750 verifyIndependentOfContext("a * ++b;"); 3751 verifyIndependentOfContext("a * --b;"); 3752 verifyIndependentOfContext("a[4] * b;"); 3753 verifyIndependentOfContext("a[a * a] = 1;"); 3754 verifyIndependentOfContext("f() * b;"); 3755 verifyIndependentOfContext("a * [self dostuff];"); 3756 verifyIndependentOfContext("int x = a * (a + b);"); 3757 verifyIndependentOfContext("(a *)(a + b);"); 3758 verifyIndependentOfContext("int *pa = (int *)&a;"); 3759 verifyIndependentOfContext("return sizeof(int **);"); 3760 verifyIndependentOfContext("return sizeof(int ******);"); 3761 verifyIndependentOfContext("return (int **&)a;"); 3762 verifyIndependentOfContext("f((*PointerToArray)[10]);"); 3763 verifyFormat("void f(Type (*parameter)[10]) {}"); 3764 verifyGoogleFormat("return sizeof(int**);"); 3765 verifyIndependentOfContext("Type **A = static_cast<Type **>(P);"); 3766 verifyGoogleFormat("Type** A = static_cast<Type**>(P);"); 3767 verifyFormat("auto a = [](int **&, int ***) {};"); 3768 3769 verifyIndependentOfContext("InvalidRegions[*R] = 0;"); 3770 3771 verifyIndependentOfContext("A<int *> a;"); 3772 verifyIndependentOfContext("A<int **> a;"); 3773 verifyIndependentOfContext("A<int *, int *> a;"); 3774 verifyIndependentOfContext( 3775 "const char *const p = reinterpret_cast<const char *const>(q);"); 3776 verifyIndependentOfContext("A<int **, int **> a;"); 3777 verifyIndependentOfContext("void f(int *a = d * e, int *b = c * d);"); 3778 verifyFormat("for (char **a = b; *a; ++a) {\n}"); 3779 verifyFormat("for (; a && b;) {\n}"); 3780 3781 verifyFormat( 3782 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3783 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa, *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 3784 3785 verifyGoogleFormat("int main(int argc, char** argv) {}"); 3786 verifyGoogleFormat("A<int*> a;"); 3787 verifyGoogleFormat("A<int**> a;"); 3788 verifyGoogleFormat("A<int*, int*> a;"); 3789 verifyGoogleFormat("A<int**, int**> a;"); 3790 verifyGoogleFormat("f(b ? *c : *d);"); 3791 verifyGoogleFormat("int a = b ? *c : *d;"); 3792 verifyGoogleFormat("Type* t = **x;"); 3793 verifyGoogleFormat("Type* t = *++*x;"); 3794 verifyGoogleFormat("*++*x;"); 3795 verifyGoogleFormat("Type* t = const_cast<T*>(&*x);"); 3796 verifyGoogleFormat("Type* t = x++ * y;"); 3797 verifyGoogleFormat( 3798 "const char* const p = reinterpret_cast<const char* const>(q);"); 3799 3800 verifyIndependentOfContext("a = *(x + y);"); 3801 verifyIndependentOfContext("a = &(x + y);"); 3802 verifyIndependentOfContext("*(x + y).call();"); 3803 verifyIndependentOfContext("&(x + y)->call();"); 3804 verifyFormat("void f() { &(*I).first; }"); 3805 3806 verifyIndependentOfContext("f(b * /* confusing comment */ ++c);"); 3807 verifyFormat( 3808 "int *MyValues = {\n" 3809 " *A, // Operator detection might be confused by the '{'\n" 3810 " *BB // Operator detection might be confused by previous comment\n" 3811 "};"); 3812 3813 verifyIndependentOfContext("if (int *a = &b)"); 3814 verifyIndependentOfContext("if (int &a = *b)"); 3815 verifyIndependentOfContext("if (a & b[i])"); 3816 verifyIndependentOfContext("if (a::b::c::d & b[i])"); 3817 verifyIndependentOfContext("if (*b[i])"); 3818 verifyIndependentOfContext("if (int *a = (&b))"); 3819 verifyIndependentOfContext("while (int *a = &b)"); 3820 verifyFormat("void f() {\n" 3821 " for (const int &v : Values) {\n" 3822 " }\n" 3823 "}"); 3824 verifyFormat("for (int i = a * a; i < 10; ++i) {\n}"); 3825 verifyFormat("for (int i = 0; i < a * a; ++i) {\n}"); 3826 3827 verifyFormat("#define MACRO \\\n" 3828 " int *i = a * b; \\\n" 3829 " void f(a *b);", 3830 getLLVMStyleWithColumns(19)); 3831 3832 verifyIndependentOfContext("A = new SomeType *[Length];"); 3833 verifyIndependentOfContext("A = new SomeType *[Length]();"); 3834 verifyIndependentOfContext("T **t = new T *;"); 3835 verifyIndependentOfContext("T **t = new T *();"); 3836 verifyGoogleFormat("A = new SomeType* [Length]();"); 3837 verifyGoogleFormat("A = new SomeType* [Length];"); 3838 verifyGoogleFormat("T** t = new T*;"); 3839 verifyGoogleFormat("T** t = new T*();"); 3840 3841 FormatStyle PointerLeft = getLLVMStyle(); 3842 PointerLeft.PointerBindsToType = true; 3843 verifyFormat("delete *x;", PointerLeft); 3844 } 3845 3846 TEST_F(FormatTest, UnderstandsAttributes) { 3847 verifyFormat("SomeType s __attribute__((unused)) (InitValue);"); 3848 } 3849 3850 TEST_F(FormatTest, UnderstandsEllipsis) { 3851 verifyFormat("int printf(const char *fmt, ...);"); 3852 verifyFormat("template <class... Ts> void Foo(Ts... ts) { Foo(ts...); }"); 3853 verifyFormat("template <class... Ts> void Foo(Ts *... ts) {}"); 3854 3855 FormatStyle PointersLeft = getLLVMStyle(); 3856 PointersLeft.PointerBindsToType = true; 3857 verifyFormat("template <class... Ts> void Foo(Ts*... ts) {}", PointersLeft); 3858 } 3859 3860 TEST_F(FormatTest, AdaptivelyFormatsPointersAndReferences) { 3861 EXPECT_EQ("int *a;\n" 3862 "int *a;\n" 3863 "int *a;", 3864 format("int *a;\n" 3865 "int* a;\n" 3866 "int *a;", 3867 getGoogleStyle())); 3868 EXPECT_EQ("int* a;\n" 3869 "int* a;\n" 3870 "int* a;", 3871 format("int* a;\n" 3872 "int* a;\n" 3873 "int *a;", 3874 getGoogleStyle())); 3875 EXPECT_EQ("int *a;\n" 3876 "int *a;\n" 3877 "int *a;", 3878 format("int *a;\n" 3879 "int * a;\n" 3880 "int * a;", 3881 getGoogleStyle())); 3882 } 3883 3884 TEST_F(FormatTest, UnderstandsRvalueReferences) { 3885 verifyFormat("int f(int &&a) {}"); 3886 verifyFormat("int f(int a, char &&b) {}"); 3887 verifyFormat("void f() { int &&a = b; }"); 3888 verifyGoogleFormat("int f(int a, char&& b) {}"); 3889 verifyGoogleFormat("void f() { int&& a = b; }"); 3890 3891 verifyIndependentOfContext("A<int &&> a;"); 3892 verifyIndependentOfContext("A<int &&, int &&> a;"); 3893 verifyGoogleFormat("A<int&&> a;"); 3894 verifyGoogleFormat("A<int&&, int&&> a;"); 3895 3896 // Not rvalue references: 3897 verifyFormat("template <bool B, bool C> class A {\n" 3898 " static_assert(B && C, \"Something is wrong\");\n" 3899 "};"); 3900 verifyGoogleFormat("#define IF(a, b, c) if (a && (b == c))"); 3901 verifyGoogleFormat("#define WHILE(a, b, c) while (a && (b == c))"); 3902 } 3903 3904 TEST_F(FormatTest, FormatsBinaryOperatorsPrecedingEquals) { 3905 verifyFormat("void f() {\n" 3906 " x[aaaaaaaaa -\n" 3907 " b] = 23;\n" 3908 "}", 3909 getLLVMStyleWithColumns(15)); 3910 } 3911 3912 TEST_F(FormatTest, FormatsCasts) { 3913 verifyFormat("Type *A = static_cast<Type *>(P);"); 3914 verifyFormat("Type *A = (Type *)P;"); 3915 verifyFormat("Type *A = (vector<Type *, int *>)P;"); 3916 verifyFormat("int a = (int)(2.0f);"); 3917 verifyFormat("int a = (int)2.0f;"); 3918 verifyFormat("x[(int32)y];"); 3919 verifyFormat("x = (int32)y;"); 3920 verifyFormat("#define AA(X) sizeof(((X *)NULL)->a)"); 3921 verifyFormat("int a = (int)*b;"); 3922 verifyFormat("int a = (int)2.0f;"); 3923 verifyFormat("int a = (int)~0;"); 3924 verifyFormat("int a = (int)++a;"); 3925 verifyFormat("int a = (int)sizeof(int);"); 3926 verifyFormat("int a = (int)+2;"); 3927 verifyFormat("my_int a = (my_int)2.0f;"); 3928 verifyFormat("my_int a = (my_int)sizeof(int);"); 3929 verifyFormat("return (my_int)aaa;"); 3930 verifyFormat("#define x ((int)-1)"); 3931 verifyFormat("#define p(q) ((int *)&q)"); 3932 3933 // FIXME: Without type knowledge, this can still fall apart miserably. 3934 verifyFormat("void f() { my_int a = (my_int) * b; }"); 3935 verifyFormat("void f() { return P ? (my_int) * P : (my_int)0; }"); 3936 verifyFormat("my_int a = (my_int) ~0;"); 3937 verifyFormat("my_int a = (my_int)++ a;"); 3938 verifyFormat("my_int a = (my_int) + 2;"); 3939 3940 // Don't break after a cast's 3941 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 3942 " (aaaaaaaaaaaaaaaaaaaaaaaaaa *)(aaaaaaaaaaaaaaaaaaaaaa +\n" 3943 " bbbbbbbbbbbbbbbbbbbbbb);"); 3944 3945 // These are not casts. 3946 verifyFormat("void f(int *) {}"); 3947 verifyFormat("f(foo)->b;"); 3948 verifyFormat("f(foo).b;"); 3949 verifyFormat("f(foo)(b);"); 3950 verifyFormat("f(foo)[b];"); 3951 verifyFormat("[](foo) { return 4; }(bar);"); 3952 verifyFormat("(*funptr)(foo)[4];"); 3953 verifyFormat("funptrs[4](foo)[4];"); 3954 verifyFormat("void f(int *);"); 3955 verifyFormat("void f(int *) = 0;"); 3956 verifyFormat("void f(SmallVector<int>) {}"); 3957 verifyFormat("void f(SmallVector<int>);"); 3958 verifyFormat("void f(SmallVector<int>) = 0;"); 3959 verifyFormat("void f(int i = (kValue) * kMask) {}"); 3960 verifyFormat("void f(int i = (kA * kB) & kMask) {}"); 3961 verifyFormat("int a = sizeof(int) * b;"); 3962 verifyFormat("int a = alignof(int) * b;", getGoogleStyle()); 3963 verifyFormat("template <> void f<int>(int i) SOME_ANNOTATION;"); 3964 verifyFormat("f(\"%\" SOME_MACRO(ll) \"d\");"); 3965 verifyFormat("aaaaa &operator=(const aaaaa &) LLVM_DELETED_FUNCTION;"); 3966 3967 // These are not casts, but at some point were confused with casts. 3968 verifyFormat("virtual void foo(int *) override;"); 3969 verifyFormat("virtual void foo(char &) const;"); 3970 verifyFormat("virtual void foo(int *a, char *) const;"); 3971 verifyFormat("int a = sizeof(int *) + b;"); 3972 verifyFormat("int a = alignof(int *) + b;", getGoogleStyle()); 3973 3974 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *foo = (aaaaaaaaaaaaaaaaa *)\n" 3975 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 3976 // FIXME: The indentation here is not ideal. 3977 verifyFormat( 3978 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3979 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = (*cccccccccccccccc)\n" 3980 " [dddddddddddddddddddddddddddddddddddddddddddddddddddddddd];"); 3981 } 3982 3983 TEST_F(FormatTest, FormatsFunctionTypes) { 3984 verifyFormat("A<bool()> a;"); 3985 verifyFormat("A<SomeType()> a;"); 3986 verifyFormat("A<void (*)(int, std::string)> a;"); 3987 verifyFormat("A<void *(int)>;"); 3988 verifyFormat("void *(*a)(int *, SomeType *);"); 3989 verifyFormat("int (*func)(void *);"); 3990 verifyFormat("void f() { int (*func)(void *); }"); 3991 verifyFormat("template <class CallbackClass>\n" 3992 "using MyCallback = void (CallbackClass::*)(SomeObject *Data);"); 3993 3994 verifyGoogleFormat("A<void*(int*, SomeType*)>;"); 3995 verifyGoogleFormat("void* (*a)(int);"); 3996 verifyGoogleFormat( 3997 "template <class CallbackClass>\n" 3998 "using MyCallback = void (CallbackClass::*)(SomeObject* Data);"); 3999 4000 // Other constructs can look somewhat like function types: 4001 verifyFormat("A<sizeof(*x)> a;"); 4002 verifyFormat("#define DEREF_AND_CALL_F(x) f(*x)"); 4003 verifyFormat("some_var = function(*some_pointer_var)[0];"); 4004 verifyFormat("void f() { function(*some_pointer_var)[0] = 10; }"); 4005 } 4006 4007 TEST_F(FormatTest, BreaksLongDeclarations) { 4008 verifyFormat("typedef LoooooooooooooooooooooooooooooooooooooooongType\n" 4009 " AnotherNameForTheLongType;", 4010 getGoogleStyle()); 4011 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 4012 " LoooooooooooooooooooooooooooooooooooooooongVariable;", 4013 getGoogleStyle()); 4014 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType const\n" 4015 " LoooooooooooooooooooooooooooooooooooooooongVariable;", 4016 getGoogleStyle()); 4017 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 4018 " LoooooooooooooooooooooooooooooooongFunctionDeclaration();", 4019 getGoogleStyle()); 4020 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 4021 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 4022 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType const\n" 4023 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 4024 4025 // FIXME: Without the comment, this breaks after "(". 4026 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType // break\n" 4027 " (*LoooooooooooooooooooooooooooongFunctionTypeVarialbe)();", 4028 getGoogleStyle()); 4029 4030 verifyFormat("int *someFunction(int LoooooooooooooooooooongParam1,\n" 4031 " int LoooooooooooooooooooongParam2) {}"); 4032 verifyFormat( 4033 "TypeSpecDecl *TypeSpecDecl::Create(ASTContext &C, DeclContext *DC,\n" 4034 " SourceLocation L, IdentifierIn *II,\n" 4035 " Type *T) {}"); 4036 verifyFormat("ReallyLongReturnType<TemplateParam1, TemplateParam2>\n" 4037 "ReallyReallyLongFunctionName(\n" 4038 " const std::string &SomeParameter,\n" 4039 " const SomeType<string, SomeOtherTemplateParameter> &\n" 4040 " ReallyReallyLongParameterName,\n" 4041 " const SomeType<string, SomeOtherTemplateParameter> &\n" 4042 " AnotherLongParameterName) {}"); 4043 verifyFormat("template <typename A>\n" 4044 "SomeLoooooooooooooooooooooongType<\n" 4045 " typename some_namespace::SomeOtherType<A>::Type>\n" 4046 "Function() {}"); 4047 4048 verifyGoogleFormat( 4049 "aaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaa<aaaaaaaaaaaaa, aaaaaaaaaaaa>\n" 4050 " aaaaaaaaaaaaaaaaaaaaaaa;"); 4051 verifyGoogleFormat( 4052 "TypeSpecDecl* TypeSpecDecl::Create(ASTContext& C, DeclContext* DC,\n" 4053 " SourceLocation L) {}"); 4054 verifyGoogleFormat( 4055 "some_namespace::LongReturnType\n" 4056 "long_namespace::SomeVeryLongClass::SomeVeryLongFunction(\n" 4057 " int first_long_parameter, int second_parameter) {}"); 4058 4059 verifyGoogleFormat("template <typename T>\n" 4060 "aaaaaaaa::aaaaa::aaaaaa<T, aaaaaaaaaaaaaaaaaaaaaaaaa>\n" 4061 "aaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaa() {}"); 4062 verifyGoogleFormat("A<A<A>> aaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4063 " int aaaaaaaaaaaaaaaaaaaaaaa);"); 4064 } 4065 4066 TEST_F(FormatTest, FormatsArrays) { 4067 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaaaaaaaaaa]\n" 4068 " [bbbbbbbbbbbbbbbbbbbbbbbbb] = c;"); 4069 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4070 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;"); 4071 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4072 " [a][bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = cccccccc;"); 4073 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4074 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n" 4075 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;"); 4076 verifyFormat( 4077 "llvm::outs() << \"aaaaaaaaaaaa: \"\n" 4078 " << (*aaaaaaaiaaaaaaa)[aaaaaaaaaaaaaaaaaaaaaaaaa]\n" 4079 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa];"); 4080 } 4081 4082 TEST_F(FormatTest, LineStartsWithSpecialCharacter) { 4083 verifyFormat("(a)->b();"); 4084 verifyFormat("--a;"); 4085 } 4086 4087 TEST_F(FormatTest, HandlesIncludeDirectives) { 4088 verifyFormat("#include <string>\n" 4089 "#include <a/b/c.h>\n" 4090 "#include \"a/b/string\"\n" 4091 "#include \"string.h\"\n" 4092 "#include \"string.h\"\n" 4093 "#include <a-a>\n" 4094 "#include < path with space >\n" 4095 "#include \"abc.h\" // this is included for ABC\n" 4096 "#include \"some long include\" // with a comment\n" 4097 "#include \"some very long include paaaaaaaaaaaaaaaaaaaaaaath\"", 4098 getLLVMStyleWithColumns(35)); 4099 4100 verifyFormat("#import <string>"); 4101 verifyFormat("#import <a/b/c.h>"); 4102 verifyFormat("#import \"a/b/string\""); 4103 verifyFormat("#import \"string.h\""); 4104 verifyFormat("#import \"string.h\""); 4105 verifyFormat("#if __has_include(<strstream>)\n" 4106 "#include <strstream>\n" 4107 "#endif"); 4108 } 4109 4110 //===----------------------------------------------------------------------===// 4111 // Error recovery tests. 4112 //===----------------------------------------------------------------------===// 4113 4114 TEST_F(FormatTest, IncompleteParameterLists) { 4115 FormatStyle NoBinPacking = getLLVMStyle(); 4116 NoBinPacking.BinPackParameters = false; 4117 verifyFormat("void aaaaaaaaaaaaaaaaaa(int level,\n" 4118 " double *min_x,\n" 4119 " double *max_x,\n" 4120 " double *min_y,\n" 4121 " double *max_y,\n" 4122 " double *min_z,\n" 4123 " double *max_z, ) {}", 4124 NoBinPacking); 4125 } 4126 4127 TEST_F(FormatTest, IncorrectCodeTrailingStuff) { 4128 verifyFormat("void f() { return; }\n42"); 4129 verifyFormat("void f() {\n" 4130 " if (0)\n" 4131 " return;\n" 4132 "}\n" 4133 "42"); 4134 verifyFormat("void f() { return }\n42"); 4135 verifyFormat("void f() {\n" 4136 " if (0)\n" 4137 " return\n" 4138 "}\n" 4139 "42"); 4140 } 4141 4142 TEST_F(FormatTest, IncorrectCodeMissingSemicolon) { 4143 EXPECT_EQ("void f() { return }", format("void f ( ) { return }")); 4144 EXPECT_EQ("void f() {\n" 4145 " if (a)\n" 4146 " return\n" 4147 "}", 4148 format("void f ( ) { if ( a ) return }")); 4149 EXPECT_EQ("namespace N {\n" 4150 "void f()\n" 4151 "}", 4152 format("namespace N { void f() }")); 4153 EXPECT_EQ("namespace N {\n" 4154 "void f() {}\n" 4155 "void g()\n" 4156 "}", 4157 format("namespace N { void f( ) { } void g( ) }")); 4158 } 4159 4160 TEST_F(FormatTest, IndentationWithinColumnLimitNotPossible) { 4161 verifyFormat("int aaaaaaaa =\n" 4162 " // Overlylongcomment\n" 4163 " b;", 4164 getLLVMStyleWithColumns(20)); 4165 verifyFormat("function(\n" 4166 " ShortArgument,\n" 4167 " LoooooooooooongArgument);\n", 4168 getLLVMStyleWithColumns(20)); 4169 } 4170 4171 TEST_F(FormatTest, IncorrectAccessSpecifier) { 4172 verifyFormat("public:"); 4173 verifyFormat("class A {\n" 4174 "public\n" 4175 " void f() {}\n" 4176 "};"); 4177 verifyFormat("public\n" 4178 "int qwerty;"); 4179 verifyFormat("public\n" 4180 "B {}"); 4181 verifyFormat("public\n" 4182 "{}"); 4183 verifyFormat("public\n" 4184 "B { int x; }"); 4185 } 4186 4187 TEST_F(FormatTest, IncorrectCodeUnbalancedBraces) { 4188 verifyFormat("{"); 4189 verifyFormat("#})"); 4190 } 4191 4192 TEST_F(FormatTest, IncorrectCodeDoNoWhile) { 4193 verifyFormat("do {\n}"); 4194 verifyFormat("do {\n}\n" 4195 "f();"); 4196 verifyFormat("do {\n}\n" 4197 "wheeee(fun);"); 4198 verifyFormat("do {\n" 4199 " f();\n" 4200 "}"); 4201 } 4202 4203 TEST_F(FormatTest, IncorrectCodeMissingParens) { 4204 verifyFormat("if {\n foo;\n foo();\n}"); 4205 verifyFormat("switch {\n foo;\n foo();\n}"); 4206 verifyFormat("for {\n foo;\n foo();\n}"); 4207 verifyFormat("while {\n foo;\n foo();\n}"); 4208 verifyFormat("do {\n foo;\n foo();\n} while;"); 4209 } 4210 4211 TEST_F(FormatTest, DoesNotTouchUnwrappedLinesWithErrors) { 4212 verifyFormat("namespace {\n" 4213 "class Foo { Foo (\n" 4214 "};\n" 4215 "} // comment"); 4216 } 4217 4218 TEST_F(FormatTest, IncorrectCodeErrorDetection) { 4219 EXPECT_EQ("{\n{}\n", format("{\n{\n}\n")); 4220 EXPECT_EQ("{\n {}\n", format("{\n {\n}\n")); 4221 EXPECT_EQ("{\n {}\n", format("{\n {\n }\n")); 4222 EXPECT_EQ("{\n {}\n }\n}\n", format("{\n {\n }\n }\n}\n")); 4223 4224 EXPECT_EQ("{\n" 4225 " {\n" 4226 " breakme(\n" 4227 " qwe);\n" 4228 "}\n", 4229 format("{\n" 4230 " {\n" 4231 " breakme(qwe);\n" 4232 "}\n", 4233 getLLVMStyleWithColumns(10))); 4234 } 4235 4236 TEST_F(FormatTest, LayoutCallsInsideBraceInitializers) { 4237 verifyFormat("int x = {\n" 4238 " avariable,\n" 4239 " b(alongervariable)\n" 4240 "};", 4241 getLLVMStyleWithColumns(25)); 4242 } 4243 4244 TEST_F(FormatTest, LayoutBraceInitializersInReturnStatement) { 4245 verifyFormat("return (a)(b) { 1, 2, 3 };"); 4246 } 4247 4248 TEST_F(FormatTest, LayoutCxx11ConstructorBraceInitializers) { 4249 verifyFormat("vector<int> x{ 1, 2, 3, 4 };"); 4250 verifyFormat("vector<T> x{ {}, {}, {}, {} };"); 4251 verifyFormat("f({ 1, 2 });"); 4252 verifyFormat("auto v = Foo{ 1 };"); 4253 verifyFormat("f({ 1, 2 }, { { 2, 3 }, { 4, 5 } }, c, { d });"); 4254 verifyFormat("Class::Class : member{ 1, 2, 3 } {}"); 4255 verifyFormat("new vector<int>{ 1, 2, 3 };"); 4256 verifyFormat("new int[3]{ 1, 2, 3 };"); 4257 verifyFormat("return { arg1, arg2 };"); 4258 verifyFormat("return { arg1, SomeType{ parameter } };"); 4259 verifyFormat("new T{ arg1, arg2 };"); 4260 verifyFormat("class Class {\n" 4261 " T member = { arg1, arg2 };\n" 4262 "};"); 4263 verifyFormat( 4264 "foo = aaaaaaaaaaa ? vector<int>{ aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4265 " aaaaaaaaaaaaaaaaaaaa, aaaaa }\n" 4266 " : vector<int>{ bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" 4267 " bbbbbbbbbbbbbbbbbbbb, bbbbb };"); 4268 verifyFormat("DoSomethingWithVector({} /* No data */);"); 4269 verifyFormat("DoSomethingWithVector({ {} /* No data */ }, { { 1, 2 } });"); 4270 verifyFormat( 4271 "someFunction(OtherParam, BracedList{\n" 4272 " // comment 1 (Forcing interesting break)\n" 4273 " param1, param2,\n" 4274 " // comment 2\n" 4275 " param3, param4\n" 4276 " });"); 4277 verifyFormat( 4278 "std::this_thread::sleep_for(\n" 4279 " std::chrono::nanoseconds{ std::chrono::seconds{ 1 } } / 5);"); 4280 4281 FormatStyle NoSpaces = getLLVMStyle(); 4282 NoSpaces.Cpp11BracedListStyle = true; 4283 verifyFormat("vector<int> x{1, 2, 3, 4};", NoSpaces); 4284 verifyFormat("vector<T> x{{}, {}, {}, {}};", NoSpaces); 4285 verifyFormat("f({1, 2});", NoSpaces); 4286 verifyFormat("auto v = Foo{-1};", NoSpaces); 4287 verifyFormat("f({1, 2}, {{2, 3}, {4, 5}}, c, {d});", NoSpaces); 4288 verifyFormat("Class::Class : member{1, 2, 3} {}", NoSpaces); 4289 verifyFormat("new vector<int>{1, 2, 3};", NoSpaces); 4290 verifyFormat("new int[3]{1, 2, 3};", NoSpaces); 4291 verifyFormat("return {arg1, arg2};", NoSpaces); 4292 verifyFormat("return {arg1, SomeType{parameter}};", NoSpaces); 4293 verifyFormat("new T{arg1, arg2};", NoSpaces); 4294 verifyFormat("class Class {\n" 4295 " T member = {arg1, arg2};\n" 4296 "};", 4297 NoSpaces); 4298 } 4299 4300 TEST_F(FormatTest, FormatsBracedListsinColumnLayout) { 4301 verifyFormat("vector<int> x = { 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 4302 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 4303 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 4304 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 4305 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 4306 " 1, 22, 333, 4444, 55555, 666666, 7777777 };"); 4307 verifyFormat("vector<int> x = { 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 4308 " // line comment\n" 4309 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 4310 " 1, 22, 333, 4444, 55555,\n" 4311 " // line comment\n" 4312 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 4313 " 1, 22, 333, 4444, 55555, 666666, 7777777 };"); 4314 verifyFormat( 4315 "vector<int> x = { 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 4316 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 4317 " 1, 22, 333, 4444, 55555, 666666, // comment\n" 4318 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 4319 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 4320 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 4321 " 7777777 };"); 4322 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n" 4323 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n" 4324 " X86::R8, X86::R9, X86::R10, X86::R11, 0\n" 4325 "};"); 4326 verifyFormat("vector<int> x = { 1, 1, 1, 1,\n" 4327 " 1, 1, 1, 1 };", 4328 getLLVMStyleWithColumns(39)); 4329 verifyFormat("vector<int> x = { 1, 1, 1, 1,\n" 4330 " 1, 1, 1, 1 };", 4331 getLLVMStyleWithColumns(38)); 4332 verifyFormat("vector<int> aaaaaaaaaaaaaaaaaaaaaa = {\n" 4333 " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1\n" 4334 "};", 4335 getLLVMStyleWithColumns(40)); 4336 4337 // Trailing commas. 4338 verifyFormat("vector<int> x = { 1, 1, 1, 1,\n" 4339 " 1, 1, 1, 1, };", 4340 getLLVMStyleWithColumns(39)); 4341 verifyFormat("vector<int> x = {\n" 4342 " 1, 1, 1, 1, 1, 1, 1, 1, //\n" 4343 "};", 4344 getLLVMStyleWithColumns(39)); 4345 verifyFormat("vector<int> x = { 1, 1, 1, 1,\n" 4346 " 1, 1, 1, 1,\n" 4347 " /**/ /**/ };", 4348 getLLVMStyleWithColumns(39)); 4349 verifyFormat("return { { aaaaaaaaaaaaaaaaaaaaa }, { aaaaaaaaaaaaaaaaaaa },\n" 4350 " { aaaaaaaaaaaaaaaaaaaaa }, { aaaaaaaaaaaaaaaaa } };", 4351 getLLVMStyleWithColumns(60)); 4352 } 4353 4354 TEST_F(FormatTest, PullTrivialFunctionDefinitionsIntoSingleLine) { 4355 verifyFormat("void f() { return 42; }"); 4356 verifyFormat("void f() {\n" 4357 " // Comment\n" 4358 "}"); 4359 verifyFormat("{\n" 4360 "#error {\n" 4361 " int a;\n" 4362 "}"); 4363 verifyFormat("{\n" 4364 " int a;\n" 4365 "#error {\n" 4366 "}"); 4367 verifyFormat("void f() {} // comment"); 4368 verifyFormat("void f() { int a; } // comment"); 4369 verifyFormat("void f() {\n" 4370 "} // comment", 4371 getLLVMStyleWithColumns(15)); 4372 4373 verifyFormat("void f() { return 42; }", getLLVMStyleWithColumns(23)); 4374 verifyFormat("void f() {\n return 42;\n}", getLLVMStyleWithColumns(22)); 4375 4376 verifyFormat("void f() {}", getLLVMStyleWithColumns(11)); 4377 verifyFormat("void f() {\n}", getLLVMStyleWithColumns(10)); 4378 } 4379 4380 TEST_F(FormatTest, UnderstandContextOfRecordTypeKeywords) { 4381 // Elaborate type variable declarations. 4382 verifyFormat("struct foo a = { bar };\nint n;"); 4383 verifyFormat("class foo a = { bar };\nint n;"); 4384 verifyFormat("union foo a = { bar };\nint n;"); 4385 4386 // Elaborate types inside function definitions. 4387 verifyFormat("struct foo f() {}\nint n;"); 4388 verifyFormat("class foo f() {}\nint n;"); 4389 verifyFormat("union foo f() {}\nint n;"); 4390 4391 // Templates. 4392 verifyFormat("template <class X> void f() {}\nint n;"); 4393 verifyFormat("template <struct X> void f() {}\nint n;"); 4394 verifyFormat("template <union X> void f() {}\nint n;"); 4395 4396 // Actual definitions... 4397 verifyFormat("struct {\n} n;"); 4398 verifyFormat( 4399 "template <template <class T, class Y>, class Z> class X {\n} n;"); 4400 verifyFormat("union Z {\n int n;\n} x;"); 4401 verifyFormat("class MACRO Z {\n} n;"); 4402 verifyFormat("class MACRO(X) Z {\n} n;"); 4403 verifyFormat("class __attribute__(X) Z {\n} n;"); 4404 verifyFormat("class __declspec(X) Z {\n} n;"); 4405 verifyFormat("class A##B##C {\n} n;"); 4406 4407 // Redefinition from nested context: 4408 verifyFormat("class A::B::C {\n} n;"); 4409 4410 // Template definitions. 4411 verifyFormat( 4412 "template <typename F>\n" 4413 "Matcher(const Matcher<F> &Other,\n" 4414 " typename enable_if_c<is_base_of<F, T>::value &&\n" 4415 " !is_same<F, T>::value>::type * = 0)\n" 4416 " : Implementation(new ImplicitCastMatcher<F>(Other)) {}"); 4417 4418 // FIXME: This is still incorrectly handled at the formatter side. 4419 verifyFormat("template <> struct X < 15, i<3 && 42 < 50 && 33 < 28> {};"); 4420 4421 // FIXME: 4422 // This now gets parsed incorrectly as class definition. 4423 // verifyFormat("class A<int> f() {\n}\nint n;"); 4424 4425 // Elaborate types where incorrectly parsing the structural element would 4426 // break the indent. 4427 verifyFormat("if (true)\n" 4428 " class X x;\n" 4429 "else\n" 4430 " f();\n"); 4431 4432 // This is simply incomplete. Formatting is not important, but must not crash. 4433 verifyFormat("class A:"); 4434 } 4435 4436 TEST_F(FormatTest, DoNotInterfereWithErrorAndWarning) { 4437 verifyFormat("#error Leave all white!!!!! space* alone!\n"); 4438 verifyFormat("#warning Leave all white!!!!! space* alone!\n"); 4439 EXPECT_EQ("#error 1", format(" # error 1")); 4440 EXPECT_EQ("#warning 1", format(" # warning 1")); 4441 } 4442 4443 TEST_F(FormatTest, FormatHashIfExpressions) { 4444 // FIXME: Come up with a better indentation for #elif. 4445 verifyFormat( 4446 "#if !defined(AAAAAAA) && (defined CCCCCC || defined DDDDDD) && \\\n" 4447 " defined(BBBBBBBB)\n" 4448 "#elif !defined(AAAAAA) && (defined CCCCC || defined DDDDDD) && \\\n" 4449 " defined(BBBBBBBB)\n" 4450 "#endif", 4451 getLLVMStyleWithColumns(65)); 4452 } 4453 4454 TEST_F(FormatTest, MergeHandlingInTheFaceOfPreprocessorDirectives) { 4455 FormatStyle AllowsMergedIf = getGoogleStyle(); 4456 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = true; 4457 verifyFormat("void f() { f(); }\n#error E", AllowsMergedIf); 4458 verifyFormat("if (true) return 42;\n#error E", AllowsMergedIf); 4459 verifyFormat("if (true)\n#error E\n return 42;", AllowsMergedIf); 4460 EXPECT_EQ("if (true) return 42;", 4461 format("if (true)\nreturn 42;", AllowsMergedIf)); 4462 FormatStyle ShortMergedIf = AllowsMergedIf; 4463 ShortMergedIf.ColumnLimit = 25; 4464 verifyFormat("#define A \\\n" 4465 " if (true) return 42;", 4466 ShortMergedIf); 4467 verifyFormat("#define A \\\n" 4468 " f(); \\\n" 4469 " if (true)\n" 4470 "#define B", 4471 ShortMergedIf); 4472 verifyFormat("#define A \\\n" 4473 " f(); \\\n" 4474 " if (true)\n" 4475 "g();", 4476 ShortMergedIf); 4477 verifyFormat("{\n" 4478 "#ifdef A\n" 4479 " // Comment\n" 4480 " if (true) continue;\n" 4481 "#endif\n" 4482 " // Comment\n" 4483 " if (true) continue;", 4484 ShortMergedIf); 4485 } 4486 4487 TEST_F(FormatTest, BlockCommentsInControlLoops) { 4488 verifyFormat("if (0) /* a comment in a strange place */ {\n" 4489 " f();\n" 4490 "}"); 4491 verifyFormat("if (0) /* a comment in a strange place */ {\n" 4492 " f();\n" 4493 "} /* another comment */ else /* comment #3 */ {\n" 4494 " g();\n" 4495 "}"); 4496 verifyFormat("while (0) /* a comment in a strange place */ {\n" 4497 " f();\n" 4498 "}"); 4499 verifyFormat("for (;;) /* a comment in a strange place */ {\n" 4500 " f();\n" 4501 "}"); 4502 verifyFormat("do /* a comment in a strange place */ {\n" 4503 " f();\n" 4504 "} /* another comment */ while (0);"); 4505 } 4506 4507 TEST_F(FormatTest, BlockComments) { 4508 EXPECT_EQ("/* */ /* */ /* */\n/* */ /* */ /* */", 4509 format("/* *//* */ /* */\n/* *//* */ /* */")); 4510 EXPECT_EQ("/* */ a /* */ b;", format(" /* */ a/* */ b;")); 4511 EXPECT_EQ("#define A /*123*/ \\\n" 4512 " b\n" 4513 "/* */\n" 4514 "someCall(\n" 4515 " parameter);", 4516 format("#define A /*123*/ b\n" 4517 "/* */\n" 4518 "someCall(parameter);", 4519 getLLVMStyleWithColumns(15))); 4520 4521 EXPECT_EQ("#define A\n" 4522 "/* */ someCall(\n" 4523 " parameter);", 4524 format("#define A\n" 4525 "/* */someCall(parameter);", 4526 getLLVMStyleWithColumns(15))); 4527 EXPECT_EQ("/*\n**\n*/", format("/*\n**\n*/")); 4528 EXPECT_EQ("/*\n" 4529 "*\n" 4530 " * aaaaaa\n" 4531 "*aaaaaa\n" 4532 "*/", 4533 format("/*\n" 4534 "*\n" 4535 " * aaaaaa aaaaaa\n" 4536 "*/", 4537 getLLVMStyleWithColumns(10))); 4538 EXPECT_EQ("/*\n" 4539 "**\n" 4540 "* aaaaaa\n" 4541 "*aaaaaa\n" 4542 "*/", 4543 format("/*\n" 4544 "**\n" 4545 "* aaaaaa aaaaaa\n" 4546 "*/", 4547 getLLVMStyleWithColumns(10))); 4548 4549 FormatStyle NoBinPacking = getLLVMStyle(); 4550 NoBinPacking.BinPackParameters = false; 4551 EXPECT_EQ("someFunction(1, /* comment 1 */\n" 4552 " 2, /* comment 2 */\n" 4553 " 3, /* comment 3 */\n" 4554 " aaaa,\n" 4555 " bbbb);", 4556 format("someFunction (1, /* comment 1 */\n" 4557 " 2, /* comment 2 */ \n" 4558 " 3, /* comment 3 */\n" 4559 "aaaa, bbbb );", 4560 NoBinPacking)); 4561 verifyFormat( 4562 "bool aaaaaaaaaaaaa = /* comment: */ aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 4563 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 4564 EXPECT_EQ( 4565 "bool aaaaaaaaaaaaa = /* trailing comment */\n" 4566 " aaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 4567 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaa;", 4568 format( 4569 "bool aaaaaaaaaaaaa = /* trailing comment */\n" 4570 " aaaaaaaaaaaaaaaaaaaaaaaaaaa||aaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 4571 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaa;")); 4572 EXPECT_EQ( 4573 "int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa; /* comment */\n" 4574 "int bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb; /* comment */\n" 4575 "int cccccccccccccccccccccccccccccc; /* comment */\n", 4576 format("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa; /* comment */\n" 4577 "int bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb; /* comment */\n" 4578 "int cccccccccccccccccccccccccccccc; /* comment */\n")); 4579 4580 verifyFormat("void f(int * /* unused */) {}"); 4581 4582 EXPECT_EQ("/*\n" 4583 " **\n" 4584 " */", 4585 format("/*\n" 4586 " **\n" 4587 " */")); 4588 EXPECT_EQ("/*\n" 4589 " *q\n" 4590 " */", 4591 format("/*\n" 4592 " *q\n" 4593 " */")); 4594 EXPECT_EQ("/*\n" 4595 " * q\n" 4596 " */", 4597 format("/*\n" 4598 " * q\n" 4599 " */")); 4600 EXPECT_EQ("/*\n" 4601 " **/", 4602 format("/*\n" 4603 " **/")); 4604 EXPECT_EQ("/*\n" 4605 " ***/", 4606 format("/*\n" 4607 " ***/")); 4608 } 4609 4610 TEST_F(FormatTest, BlockCommentsInMacros) { 4611 EXPECT_EQ("#define A \\\n" 4612 " { \\\n" 4613 " /* one line */ \\\n" 4614 " someCall();", 4615 format("#define A { \\\n" 4616 " /* one line */ \\\n" 4617 " someCall();", 4618 getLLVMStyleWithColumns(20))); 4619 EXPECT_EQ("#define A \\\n" 4620 " { \\\n" 4621 " /* previous */ \\\n" 4622 " /* one line */ \\\n" 4623 " someCall();", 4624 format("#define A { \\\n" 4625 " /* previous */ \\\n" 4626 " /* one line */ \\\n" 4627 " someCall();", 4628 getLLVMStyleWithColumns(20))); 4629 } 4630 4631 TEST_F(FormatTest, BlockCommentsAtEndOfLine) { 4632 EXPECT_EQ("a = {\n" 4633 " 1111 /* */\n" 4634 "};", 4635 format("a = {1111 /* */\n" 4636 "};", 4637 getLLVMStyleWithColumns(15))); 4638 EXPECT_EQ("a = {\n" 4639 " 1111 /* */\n" 4640 "};", 4641 format("a = {1111 /* */\n" 4642 "};", 4643 getLLVMStyleWithColumns(15))); 4644 4645 // FIXME: The formatting is still wrong here. 4646 EXPECT_EQ("a = {\n" 4647 " 1111 /* a\n" 4648 " */\n" 4649 "};", 4650 format("a = {1111 /* a */\n" 4651 "};", 4652 getLLVMStyleWithColumns(15))); 4653 } 4654 4655 TEST_F(FormatTest, IndentLineCommentsInStartOfBlockAtEndOfFile) { 4656 // FIXME: This is not what we want... 4657 verifyFormat("{\n" 4658 "// a" 4659 "// b"); 4660 } 4661 4662 TEST_F(FormatTest, FormatStarDependingOnContext) { 4663 verifyFormat("void f(int *a);"); 4664 verifyFormat("void f() { f(fint * b); }"); 4665 verifyFormat("class A {\n void f(int *a);\n};"); 4666 verifyFormat("class A {\n int *a;\n};"); 4667 verifyFormat("namespace a {\n" 4668 "namespace b {\n" 4669 "class A {\n" 4670 " void f() {}\n" 4671 " int *a;\n" 4672 "};\n" 4673 "}\n" 4674 "}"); 4675 } 4676 4677 TEST_F(FormatTest, SpecialTokensAtEndOfLine) { 4678 verifyFormat("while"); 4679 verifyFormat("operator"); 4680 } 4681 4682 //===----------------------------------------------------------------------===// 4683 // Objective-C tests. 4684 //===----------------------------------------------------------------------===// 4685 4686 TEST_F(FormatTest, FormatForObjectiveCMethodDecls) { 4687 verifyFormat("- (void)sendAction:(SEL)aSelector to:(BOOL)anObject;"); 4688 EXPECT_EQ("- (NSUInteger)indexOfObject:(id)anObject;", 4689 format("-(NSUInteger)indexOfObject:(id)anObject;")); 4690 EXPECT_EQ("- (NSInteger)Mthod1;", format("-(NSInteger)Mthod1;")); 4691 EXPECT_EQ("+ (id)Mthod2;", format("+(id)Mthod2;")); 4692 EXPECT_EQ("- (NSInteger)Method3:(id)anObject;", 4693 format("-(NSInteger)Method3:(id)anObject;")); 4694 EXPECT_EQ("- (NSInteger)Method4:(id)anObject;", 4695 format("-(NSInteger)Method4:(id)anObject;")); 4696 EXPECT_EQ("- (NSInteger)Method5:(id)anObject:(id)AnotherObject;", 4697 format("-(NSInteger)Method5:(id)anObject:(id)AnotherObject;")); 4698 EXPECT_EQ("- (id)Method6:(id)A:(id)B:(id)C:(id)D;", 4699 format("- (id)Method6:(id)A:(id)B:(id)C:(id)D;")); 4700 EXPECT_EQ( 4701 "- (void)sendAction:(SEL)aSelector to:(id)anObject forAllCells:(BOOL)flag;", 4702 format( 4703 "- (void)sendAction:(SEL)aSelector to:(id)anObject forAllCells:(BOOL)flag;")); 4704 4705 // Very long objectiveC method declaration. 4706 verifyFormat("- (NSUInteger)indexOfObject:(id)anObject\n" 4707 " inRange:(NSRange)range\n" 4708 " outRange:(NSRange)out_range\n" 4709 " outRange1:(NSRange)out_range1\n" 4710 " outRange2:(NSRange)out_range2\n" 4711 " outRange3:(NSRange)out_range3\n" 4712 " outRange4:(NSRange)out_range4\n" 4713 " outRange5:(NSRange)out_range5\n" 4714 " outRange6:(NSRange)out_range6\n" 4715 " outRange7:(NSRange)out_range7\n" 4716 " outRange8:(NSRange)out_range8\n" 4717 " outRange9:(NSRange)out_range9;"); 4718 4719 verifyFormat("- (int)sum:(vector<int>)numbers;"); 4720 verifyGoogleFormat("- (void)setDelegate:(id<Protocol>)delegate;"); 4721 // FIXME: In LLVM style, there should be a space in front of a '<' for ObjC 4722 // protocol lists (but not for template classes): 4723 //verifyFormat("- (void)setDelegate:(id <Protocol>)delegate;"); 4724 4725 verifyFormat("- (int (*)())foo:(int (*)())f;"); 4726 verifyGoogleFormat("- (int (*)())foo:(int (*)())foo;"); 4727 4728 // If there's no return type (very rare in practice!), LLVM and Google style 4729 // agree. 4730 verifyFormat("- foo;"); 4731 verifyFormat("- foo:(int)f;"); 4732 verifyGoogleFormat("- foo:(int)foo;"); 4733 } 4734 4735 TEST_F(FormatTest, FormatObjCBlocks) { 4736 verifyFormat("int (^Block)(int, int);"); 4737 verifyFormat("int (^Block1)(int, int) = ^(int i, int j)"); 4738 } 4739 4740 TEST_F(FormatTest, FormatObjCInterface) { 4741 verifyFormat("@interface Foo : NSObject <NSSomeDelegate> {\n" 4742 "@public\n" 4743 " int field1;\n" 4744 "@protected\n" 4745 " int field2;\n" 4746 "@private\n" 4747 " int field3;\n" 4748 "@package\n" 4749 " int field4;\n" 4750 "}\n" 4751 "+ (id)init;\n" 4752 "@end"); 4753 4754 verifyGoogleFormat("@interface Foo : NSObject<NSSomeDelegate> {\n" 4755 " @public\n" 4756 " int field1;\n" 4757 " @protected\n" 4758 " int field2;\n" 4759 " @private\n" 4760 " int field3;\n" 4761 " @package\n" 4762 " int field4;\n" 4763 "}\n" 4764 "+ (id)init;\n" 4765 "@end"); 4766 4767 verifyFormat("@interface /* wait for it */ Foo\n" 4768 "+ (id)init;\n" 4769 "// Look, a comment!\n" 4770 "- (int)answerWith:(int)i;\n" 4771 "@end"); 4772 4773 verifyFormat("@interface Foo\n" 4774 "@end\n" 4775 "@interface Bar\n" 4776 "@end"); 4777 4778 verifyFormat("@interface Foo : Bar\n" 4779 "+ (id)init;\n" 4780 "@end"); 4781 4782 verifyFormat("@interface Foo : /**/ Bar /**/ <Baz, /**/ Quux>\n" 4783 "+ (id)init;\n" 4784 "@end"); 4785 4786 verifyGoogleFormat("@interface Foo : Bar<Baz, Quux>\n" 4787 "+ (id)init;\n" 4788 "@end"); 4789 4790 verifyFormat("@interface Foo (HackStuff)\n" 4791 "+ (id)init;\n" 4792 "@end"); 4793 4794 verifyFormat("@interface Foo ()\n" 4795 "+ (id)init;\n" 4796 "@end"); 4797 4798 verifyFormat("@interface Foo (HackStuff) <MyProtocol>\n" 4799 "+ (id)init;\n" 4800 "@end"); 4801 4802 verifyGoogleFormat("@interface Foo (HackStuff)<MyProtocol>\n" 4803 "+ (id)init;\n" 4804 "@end"); 4805 4806 verifyFormat("@interface Foo {\n" 4807 " int _i;\n" 4808 "}\n" 4809 "+ (id)init;\n" 4810 "@end"); 4811 4812 verifyFormat("@interface Foo : Bar {\n" 4813 " int _i;\n" 4814 "}\n" 4815 "+ (id)init;\n" 4816 "@end"); 4817 4818 verifyFormat("@interface Foo : Bar <Baz, Quux> {\n" 4819 " int _i;\n" 4820 "}\n" 4821 "+ (id)init;\n" 4822 "@end"); 4823 4824 verifyFormat("@interface Foo (HackStuff) {\n" 4825 " int _i;\n" 4826 "}\n" 4827 "+ (id)init;\n" 4828 "@end"); 4829 4830 verifyFormat("@interface Foo () {\n" 4831 " int _i;\n" 4832 "}\n" 4833 "+ (id)init;\n" 4834 "@end"); 4835 4836 verifyFormat("@interface Foo (HackStuff) <MyProtocol> {\n" 4837 " int _i;\n" 4838 "}\n" 4839 "+ (id)init;\n" 4840 "@end"); 4841 } 4842 4843 TEST_F(FormatTest, FormatObjCImplementation) { 4844 verifyFormat("@implementation Foo : NSObject {\n" 4845 "@public\n" 4846 " int field1;\n" 4847 "@protected\n" 4848 " int field2;\n" 4849 "@private\n" 4850 " int field3;\n" 4851 "@package\n" 4852 " int field4;\n" 4853 "}\n" 4854 "+ (id)init {\n}\n" 4855 "@end"); 4856 4857 verifyGoogleFormat("@implementation Foo : NSObject {\n" 4858 " @public\n" 4859 " int field1;\n" 4860 " @protected\n" 4861 " int field2;\n" 4862 " @private\n" 4863 " int field3;\n" 4864 " @package\n" 4865 " int field4;\n" 4866 "}\n" 4867 "+ (id)init {\n}\n" 4868 "@end"); 4869 4870 verifyFormat("@implementation Foo\n" 4871 "+ (id)init {\n" 4872 " if (true)\n" 4873 " return nil;\n" 4874 "}\n" 4875 "// Look, a comment!\n" 4876 "- (int)answerWith:(int)i {\n" 4877 " return i;\n" 4878 "}\n" 4879 "+ (int)answerWith:(int)i {\n" 4880 " return i;\n" 4881 "}\n" 4882 "@end"); 4883 4884 verifyFormat("@implementation Foo\n" 4885 "@end\n" 4886 "@implementation Bar\n" 4887 "@end"); 4888 4889 verifyFormat("@implementation Foo : Bar\n" 4890 "+ (id)init {\n}\n" 4891 "- (void)foo {\n}\n" 4892 "@end"); 4893 4894 verifyFormat("@implementation Foo {\n" 4895 " int _i;\n" 4896 "}\n" 4897 "+ (id)init {\n}\n" 4898 "@end"); 4899 4900 verifyFormat("@implementation Foo : Bar {\n" 4901 " int _i;\n" 4902 "}\n" 4903 "+ (id)init {\n}\n" 4904 "@end"); 4905 4906 verifyFormat("@implementation Foo (HackStuff)\n" 4907 "+ (id)init {\n}\n" 4908 "@end"); 4909 verifyFormat("@implementation ObjcClass\n" 4910 "- (void)method;\n" 4911 "{}\n" 4912 "@end"); 4913 } 4914 4915 TEST_F(FormatTest, FormatObjCProtocol) { 4916 verifyFormat("@protocol Foo\n" 4917 "@property(weak) id delegate;\n" 4918 "- (NSUInteger)numberOfThings;\n" 4919 "@end"); 4920 4921 verifyFormat("@protocol MyProtocol <NSObject>\n" 4922 "- (NSUInteger)numberOfThings;\n" 4923 "@end"); 4924 4925 verifyGoogleFormat("@protocol MyProtocol<NSObject>\n" 4926 "- (NSUInteger)numberOfThings;\n" 4927 "@end"); 4928 4929 verifyFormat("@protocol Foo;\n" 4930 "@protocol Bar;\n"); 4931 4932 verifyFormat("@protocol Foo\n" 4933 "@end\n" 4934 "@protocol Bar\n" 4935 "@end"); 4936 4937 verifyFormat("@protocol myProtocol\n" 4938 "- (void)mandatoryWithInt:(int)i;\n" 4939 "@optional\n" 4940 "- (void)optional;\n" 4941 "@required\n" 4942 "- (void)required;\n" 4943 "@optional\n" 4944 "@property(assign) int madProp;\n" 4945 "@end\n"); 4946 4947 verifyFormat("@property(nonatomic, assign, readonly)\n" 4948 " int *looooooooooooooooooooooooooooongNumber;\n" 4949 "@property(nonatomic, assign, readonly)\n" 4950 " NSString *looooooooooooooooooooooooooooongName;"); 4951 } 4952 4953 TEST_F(FormatTest, FormatObjCMethodDeclarations) { 4954 verifyFormat("- (void)doSomethingWith:(GTMFoo *)theFoo\n" 4955 " rect:(NSRect)theRect\n" 4956 " interval:(float)theInterval {\n" 4957 "}"); 4958 verifyFormat("- (void)shortf:(GTMFoo *)theFoo\n" 4959 " longKeyword:(NSRect)theRect\n" 4960 " evenLongerKeyword:(float)theInterval\n" 4961 " error:(NSError **)theError {\n" 4962 "}"); 4963 } 4964 4965 TEST_F(FormatTest, FormatObjCMethodExpr) { 4966 verifyFormat("[foo bar:baz];"); 4967 verifyFormat("return [foo bar:baz];"); 4968 verifyFormat("f([foo bar:baz]);"); 4969 verifyFormat("f(2, [foo bar:baz]);"); 4970 verifyFormat("f(2, a ? b : c);"); 4971 verifyFormat("[[self initWithInt:4] bar:[baz quux:arrrr]];"); 4972 4973 // Unary operators. 4974 verifyFormat("int a = +[foo bar:baz];"); 4975 verifyFormat("int a = -[foo bar:baz];"); 4976 verifyFormat("int a = ![foo bar:baz];"); 4977 verifyFormat("int a = ~[foo bar:baz];"); 4978 verifyFormat("int a = ++[foo bar:baz];"); 4979 verifyFormat("int a = --[foo bar:baz];"); 4980 verifyFormat("int a = sizeof [foo bar:baz];"); 4981 verifyFormat("int a = alignof [foo bar:baz];", getGoogleStyle()); 4982 verifyFormat("int a = &[foo bar:baz];"); 4983 verifyFormat("int a = *[foo bar:baz];"); 4984 // FIXME: Make casts work, without breaking f()[4]. 4985 //verifyFormat("int a = (int)[foo bar:baz];"); 4986 //verifyFormat("return (int)[foo bar:baz];"); 4987 //verifyFormat("(void)[foo bar:baz];"); 4988 verifyFormat("return (MyType *)[self.tableView cellForRowAtIndexPath:cell];"); 4989 4990 // Binary operators. 4991 verifyFormat("[foo bar:baz], [foo bar:baz];"); 4992 verifyFormat("[foo bar:baz] = [foo bar:baz];"); 4993 verifyFormat("[foo bar:baz] *= [foo bar:baz];"); 4994 verifyFormat("[foo bar:baz] /= [foo bar:baz];"); 4995 verifyFormat("[foo bar:baz] %= [foo bar:baz];"); 4996 verifyFormat("[foo bar:baz] += [foo bar:baz];"); 4997 verifyFormat("[foo bar:baz] -= [foo bar:baz];"); 4998 verifyFormat("[foo bar:baz] <<= [foo bar:baz];"); 4999 verifyFormat("[foo bar:baz] >>= [foo bar:baz];"); 5000 verifyFormat("[foo bar:baz] &= [foo bar:baz];"); 5001 verifyFormat("[foo bar:baz] ^= [foo bar:baz];"); 5002 verifyFormat("[foo bar:baz] |= [foo bar:baz];"); 5003 verifyFormat("[foo bar:baz] ? [foo bar:baz] : [foo bar:baz];"); 5004 verifyFormat("[foo bar:baz] || [foo bar:baz];"); 5005 verifyFormat("[foo bar:baz] && [foo bar:baz];"); 5006 verifyFormat("[foo bar:baz] | [foo bar:baz];"); 5007 verifyFormat("[foo bar:baz] ^ [foo bar:baz];"); 5008 verifyFormat("[foo bar:baz] & [foo bar:baz];"); 5009 verifyFormat("[foo bar:baz] == [foo bar:baz];"); 5010 verifyFormat("[foo bar:baz] != [foo bar:baz];"); 5011 verifyFormat("[foo bar:baz] >= [foo bar:baz];"); 5012 verifyFormat("[foo bar:baz] <= [foo bar:baz];"); 5013 verifyFormat("[foo bar:baz] > [foo bar:baz];"); 5014 verifyFormat("[foo bar:baz] < [foo bar:baz];"); 5015 verifyFormat("[foo bar:baz] >> [foo bar:baz];"); 5016 verifyFormat("[foo bar:baz] << [foo bar:baz];"); 5017 verifyFormat("[foo bar:baz] - [foo bar:baz];"); 5018 verifyFormat("[foo bar:baz] + [foo bar:baz];"); 5019 verifyFormat("[foo bar:baz] * [foo bar:baz];"); 5020 verifyFormat("[foo bar:baz] / [foo bar:baz];"); 5021 verifyFormat("[foo bar:baz] % [foo bar:baz];"); 5022 // Whew! 5023 5024 verifyFormat("return in[42];"); 5025 verifyFormat("for (id foo in [self getStuffFor:bla]) {\n" 5026 "}"); 5027 5028 verifyFormat("[self stuffWithInt:(4 + 2) float:4.5];"); 5029 verifyFormat("[self stuffWithInt:a ? b : c float:4.5];"); 5030 verifyFormat("[self stuffWithInt:a ? [self foo:bar] : c];"); 5031 verifyFormat("[self stuffWithInt:a ? (e ? f : g) : c];"); 5032 verifyFormat("[cond ? obj1 : obj2 methodWithParam:param]"); 5033 verifyFormat("[button setAction:@selector(zoomOut:)];"); 5034 verifyFormat("[color getRed:&r green:&g blue:&b alpha:&a];"); 5035 5036 verifyFormat("arr[[self indexForFoo:a]];"); 5037 verifyFormat("throw [self errorFor:a];"); 5038 verifyFormat("@throw [self errorFor:a];"); 5039 5040 verifyFormat("[(id)foo bar:(id)baz quux:(id)snorf];"); 5041 verifyFormat("[(id)foo bar:(id) ? baz : quux];"); 5042 verifyFormat("4 > 4 ? (id)a : (id)baz;"); 5043 5044 // This tests that the formatter doesn't break after "backing" but before ":", 5045 // which would be at 80 columns. 5046 verifyFormat( 5047 "void f() {\n" 5048 " if ((self = [super initWithContentRect:contentRect\n" 5049 " styleMask:styleMask ?: otherMask\n" 5050 " backing:NSBackingStoreBuffered\n" 5051 " defer:YES]))"); 5052 5053 verifyFormat( 5054 "[foo checkThatBreakingAfterColonWorksOk:\n" 5055 " [bar ifItDoes:reduceOverallLineLengthLikeInThisCase]];"); 5056 5057 verifyFormat("[myObj short:arg1 // Force line break\n" 5058 " longKeyword:arg2 != nil ? arg2 : @\"longKeyword\"\n" 5059 " evenLongerKeyword:arg3 ?: @\"evenLongerKeyword\"\n" 5060 " error:arg4];"); 5061 verifyFormat( 5062 "void f() {\n" 5063 " popup_window_.reset([[RenderWidgetPopupWindow alloc]\n" 5064 " initWithContentRect:NSMakeRect(origin_global.x, origin_global.y,\n" 5065 " pos.width(), pos.height())\n" 5066 " styleMask:NSBorderlessWindowMask\n" 5067 " backing:NSBackingStoreBuffered\n" 5068 " defer:NO]);\n" 5069 "}"); 5070 verifyFormat("[contentsContainer replaceSubview:[subviews objectAtIndex:0]\n" 5071 " with:contentsNativeView];"); 5072 5073 verifyFormat( 5074 "[pboard addTypes:[NSArray arrayWithObject:kBookmarkButtonDragType]\n" 5075 " owner:nillllll];"); 5076 5077 verifyFormat( 5078 "[pboard setData:[NSData dataWithBytes:&button length:sizeof(button)]\n" 5079 " forType:kBookmarkButtonDragType];"); 5080 5081 verifyFormat("[defaultCenter addObserver:self\n" 5082 " selector:@selector(willEnterFullscreen)\n" 5083 " name:kWillEnterFullscreenNotification\n" 5084 " object:nil];"); 5085 verifyFormat("[image_rep drawInRect:drawRect\n" 5086 " fromRect:NSZeroRect\n" 5087 " operation:NSCompositeCopy\n" 5088 " fraction:1.0\n" 5089 " respectFlipped:NO\n" 5090 " hints:nil];"); 5091 5092 verifyFormat( 5093 "scoped_nsobject<NSTextField> message(\n" 5094 " // The frame will be fixed up when |-setMessageText:| is called.\n" 5095 " [[NSTextField alloc] initWithFrame:NSMakeRect(0, 0, 0, 0)]);"); 5096 verifyFormat("[self aaaaaa:bbbbbbbbbbbbb\n" 5097 " aaaaaaaaaa:bbbbbbbbbbbbbbbbb\n" 5098 " aaaaa:bbbbbbbbbbb + bbbbbbbbbbbb\n" 5099 " aaaa:bbb];"); 5100 } 5101 5102 TEST_F(FormatTest, ObjCAt) { 5103 verifyFormat("@autoreleasepool"); 5104 verifyFormat("@catch"); 5105 verifyFormat("@class"); 5106 verifyFormat("@compatibility_alias"); 5107 verifyFormat("@defs"); 5108 verifyFormat("@dynamic"); 5109 verifyFormat("@encode"); 5110 verifyFormat("@end"); 5111 verifyFormat("@finally"); 5112 verifyFormat("@implementation"); 5113 verifyFormat("@import"); 5114 verifyFormat("@interface"); 5115 verifyFormat("@optional"); 5116 verifyFormat("@package"); 5117 verifyFormat("@private"); 5118 verifyFormat("@property"); 5119 verifyFormat("@protected"); 5120 verifyFormat("@protocol"); 5121 verifyFormat("@public"); 5122 verifyFormat("@required"); 5123 verifyFormat("@selector"); 5124 verifyFormat("@synchronized"); 5125 verifyFormat("@synthesize"); 5126 verifyFormat("@throw"); 5127 verifyFormat("@try"); 5128 5129 EXPECT_EQ("@interface", format("@ interface")); 5130 5131 // The precise formatting of this doesn't matter, nobody writes code like 5132 // this. 5133 verifyFormat("@ /*foo*/ interface"); 5134 } 5135 5136 TEST_F(FormatTest, ObjCSnippets) { 5137 verifyFormat("@autoreleasepool {\n" 5138 " foo();\n" 5139 "}"); 5140 verifyFormat("@class Foo, Bar;"); 5141 verifyFormat("@compatibility_alias AliasName ExistingClass;"); 5142 verifyFormat("@dynamic textColor;"); 5143 verifyFormat("char *buf1 = @encode(int *);"); 5144 verifyFormat("char *buf1 = @encode(typeof(4 * 5));"); 5145 verifyFormat("char *buf1 = @encode(int **);"); 5146 verifyFormat("Protocol *proto = @protocol(p1);"); 5147 verifyFormat("SEL s = @selector(foo:);"); 5148 verifyFormat("@synchronized(self) {\n" 5149 " f();\n" 5150 "}"); 5151 5152 verifyFormat("@synthesize dropArrowPosition = dropArrowPosition_;"); 5153 verifyGoogleFormat("@synthesize dropArrowPosition = dropArrowPosition_;"); 5154 5155 verifyFormat("@property(assign, nonatomic) CGFloat hoverAlpha;"); 5156 verifyFormat("@property(assign, getter=isEditable) BOOL editable;"); 5157 verifyGoogleFormat("@property(assign, getter=isEditable) BOOL editable;"); 5158 5159 verifyFormat("@import foo.bar;\n" 5160 "@import baz;"); 5161 } 5162 5163 TEST_F(FormatTest, ObjCLiterals) { 5164 verifyFormat("@\"String\""); 5165 verifyFormat("@1"); 5166 verifyFormat("@+4.8"); 5167 verifyFormat("@-4"); 5168 verifyFormat("@1LL"); 5169 verifyFormat("@.5"); 5170 verifyFormat("@'c'"); 5171 verifyFormat("@true"); 5172 5173 verifyFormat("NSNumber *smallestInt = @(-INT_MAX - 1);"); 5174 verifyFormat("NSNumber *piOverTwo = @(M_PI / 2);"); 5175 verifyFormat("NSNumber *favoriteColor = @(Green);"); 5176 verifyFormat("NSString *path = @(getenv(\"PATH\"));"); 5177 5178 verifyFormat("@["); 5179 verifyFormat("@[]"); 5180 verifyFormat( 5181 "NSArray *array = @[ @\" Hey \", NSApp, [NSNumber numberWithInt:42] ];"); 5182 verifyFormat("return @[ @3, @[], @[ @4, @5 ] ];"); 5183 5184 verifyFormat("@{"); 5185 verifyFormat("@{}"); 5186 verifyFormat("@{ @\"one\" : @1 }"); 5187 verifyFormat("return @{ @\"one\" : @1 };"); 5188 verifyFormat("@{ @\"one\" : @1, }"); 5189 5190 verifyFormat("@{ @\"one\" : @{ @2 : @1 } }"); 5191 verifyFormat("@{ @\"one\" : @{ @2 : @1 }, }"); 5192 5193 verifyFormat("@{ 1 > 2 ? @\"one\" : @\"two\" : 1 > 2 ? @1 : @2 }"); 5194 verifyFormat("[self setDict:@{}"); 5195 verifyFormat("[self setDict:@{ @1 : @2 }"); 5196 verifyFormat("NSLog(@\"%@\", @{ @1 : @2, @2 : @3 }[@1]);"); 5197 verifyFormat( 5198 "NSDictionary *masses = @{ @\"H\" : @1.0078, @\"He\" : @4.0026 };"); 5199 verifyFormat( 5200 "NSDictionary *settings = @{ AVEncoderKey : @(AVAudioQualityMax) };"); 5201 5202 // FIXME: Nested and multi-line array and dictionary literals need more work. 5203 verifyFormat( 5204 "NSDictionary *d = @{ @\"nam\" : NSUserNam(), @\"dte\" : [NSDate date],\n" 5205 " @\"processInfo\" : [NSProcessInfo processInfo] };"); 5206 verifyFormat( 5207 "@{ NSFontAttributeNameeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee :\n" 5208 " regularFont, };"); 5209 5210 } 5211 5212 TEST_F(FormatTest, ReformatRegionAdjustsIndent) { 5213 EXPECT_EQ("{\n" 5214 "{\n" 5215 "a;\n" 5216 "b;\n" 5217 "}\n" 5218 "}", 5219 format("{\n" 5220 "{\n" 5221 "a;\n" 5222 " b;\n" 5223 "}\n" 5224 "}", 5225 13, 2, getLLVMStyle())); 5226 EXPECT_EQ("{\n" 5227 "{\n" 5228 " a;\n" 5229 "b;\n" 5230 "}\n" 5231 "}", 5232 format("{\n" 5233 "{\n" 5234 " a;\n" 5235 "b;\n" 5236 "}\n" 5237 "}", 5238 9, 2, getLLVMStyle())); 5239 EXPECT_EQ("{\n" 5240 "{\n" 5241 "public:\n" 5242 " b;\n" 5243 "}\n" 5244 "}", 5245 format("{\n" 5246 "{\n" 5247 "public:\n" 5248 " b;\n" 5249 "}\n" 5250 "}", 5251 17, 2, getLLVMStyle())); 5252 EXPECT_EQ("{\n" 5253 "{\n" 5254 "a;\n" 5255 "}\n" 5256 "{\n" 5257 " b; //\n" 5258 "}\n" 5259 "}", 5260 format("{\n" 5261 "{\n" 5262 "a;\n" 5263 "}\n" 5264 "{\n" 5265 " b; //\n" 5266 "}\n" 5267 "}", 5268 22, 2, getLLVMStyle())); 5269 EXPECT_EQ(" {\n" 5270 " a; //\n" 5271 " }", 5272 format(" {\n" 5273 "a; //\n" 5274 " }", 5275 4, 2, getLLVMStyle())); 5276 EXPECT_EQ("void f() {}\n" 5277 "void g() {}", 5278 format("void f() {}\n" 5279 "void g() {}", 5280 13, 0, getLLVMStyle())); 5281 EXPECT_EQ("int a; // comment\n" 5282 " // line 2\n" 5283 "int b;", 5284 format("int a; // comment\n" 5285 " // line 2\n" 5286 " int b;", 5287 35, 0, getLLVMStyle())); 5288 EXPECT_EQ(" int a;\n" 5289 " void\n" 5290 " ffffff() {\n" 5291 " }", 5292 format(" int a;\n" 5293 "void ffffff() {}", 5294 11, 0, getLLVMStyleWithColumns(11))); 5295 } 5296 5297 TEST_F(FormatTest, BreakStringLiterals) { 5298 EXPECT_EQ("\"some text \"\n" 5299 "\"other\";", 5300 format("\"some text other\";", getLLVMStyleWithColumns(12))); 5301 EXPECT_EQ("\"some text \"\n" 5302 "\"other\";", 5303 format("\\\n\"some text other\";", getLLVMStyleWithColumns(12))); 5304 EXPECT_EQ( 5305 "#define A \\\n" 5306 " \"some \" \\\n" 5307 " \"text \" \\\n" 5308 " \"other\";", 5309 format("#define A \"some text other\";", getLLVMStyleWithColumns(12))); 5310 EXPECT_EQ( 5311 "#define A \\\n" 5312 " \"so \" \\\n" 5313 " \"text \" \\\n" 5314 " \"other\";", 5315 format("#define A \"so text other\";", getLLVMStyleWithColumns(12))); 5316 5317 EXPECT_EQ("\"some text\"", 5318 format("\"some text\"", getLLVMStyleWithColumns(1))); 5319 EXPECT_EQ("\"some text\"", 5320 format("\"some text\"", getLLVMStyleWithColumns(11))); 5321 EXPECT_EQ("\"some \"\n" 5322 "\"text\"", 5323 format("\"some text\"", getLLVMStyleWithColumns(10))); 5324 EXPECT_EQ("\"some \"\n" 5325 "\"text\"", 5326 format("\"some text\"", getLLVMStyleWithColumns(7))); 5327 EXPECT_EQ("\"some\"\n" 5328 "\" tex\"\n" 5329 "\"t\"", 5330 format("\"some text\"", getLLVMStyleWithColumns(6))); 5331 EXPECT_EQ("\"some\"\n" 5332 "\" tex\"\n" 5333 "\" and\"", 5334 format("\"some tex and\"", getLLVMStyleWithColumns(6))); 5335 EXPECT_EQ("\"some\"\n" 5336 "\"/tex\"\n" 5337 "\"/and\"", 5338 format("\"some/tex/and\"", getLLVMStyleWithColumns(6))); 5339 5340 EXPECT_EQ("variable =\n" 5341 " \"long string \"\n" 5342 " \"literal\";", 5343 format("variable = \"long string literal\";", 5344 getLLVMStyleWithColumns(20))); 5345 5346 EXPECT_EQ("variable = f(\n" 5347 " \"long string \"\n" 5348 " \"literal\",\n" 5349 " short,\n" 5350 " loooooooooooooooooooong);", 5351 format("variable = f(\"long string literal\", short, " 5352 "loooooooooooooooooooong);", 5353 getLLVMStyleWithColumns(20))); 5354 5355 EXPECT_EQ("f(g(\"long string \"\n" 5356 " \"literal\"),\n" 5357 " b);", 5358 format("f(g(\"long string literal\"), b);", 5359 getLLVMStyleWithColumns(20))); 5360 EXPECT_EQ("f(g(\"long string \"\n" 5361 " \"literal\",\n" 5362 " a),\n" 5363 " b);", 5364 format("f(g(\"long string literal\", a), b);", 5365 getLLVMStyleWithColumns(20))); 5366 EXPECT_EQ( 5367 "f(\"one two\".split(\n" 5368 " variable));", 5369 format("f(\"one two\".split(variable));", getLLVMStyleWithColumns(20))); 5370 EXPECT_EQ("f(\"one two three four five six \"\n" 5371 " \"seven\".split(\n" 5372 " really_looooong_variable));", 5373 format("f(\"one two three four five six seven\"." 5374 "split(really_looooong_variable));", 5375 getLLVMStyleWithColumns(33))); 5376 5377 EXPECT_EQ("f(\"some \"\n" 5378 " \"text\",\n" 5379 " other);", 5380 format("f(\"some text\", other);", getLLVMStyleWithColumns(10))); 5381 5382 // Only break as a last resort. 5383 verifyFormat( 5384 "aaaaaaaaaaaaaaaaaaaa(\n" 5385 " aaaaaaaaaaaaaaaaaaaa,\n" 5386 " aaaaaa(\"aaa aaaaa aaa aaa aaaaa aaa aaaaa aaa aaa aaaaaa\"));"); 5387 5388 EXPECT_EQ( 5389 "\"splitmea\"\n" 5390 "\"trandomp\"\n" 5391 "\"oint\"", 5392 format("\"splitmeatrandompoint\"", getLLVMStyleWithColumns(10))); 5393 5394 EXPECT_EQ( 5395 "\"split/\"\n" 5396 "\"pathat/\"\n" 5397 "\"slashes\"", 5398 format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10))); 5399 5400 EXPECT_EQ( 5401 "\"split/\"\n" 5402 "\"pathat/\"\n" 5403 "\"slashes\"", 5404 format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10))); 5405 EXPECT_EQ("\"split at \"\n" 5406 "\"spaces/at/\"\n" 5407 "\"slashes.at.any$\"\n" 5408 "\"non-alphanumeric%\"\n" 5409 "\"1111111111characte\"\n" 5410 "\"rs\"", 5411 format("\"split at " 5412 "spaces/at/" 5413 "slashes.at." 5414 "any$non-" 5415 "alphanumeric%" 5416 "1111111111characte" 5417 "rs\"", 5418 getLLVMStyleWithColumns(20))); 5419 5420 // Verify that splitting the strings understands 5421 // Style::AlwaysBreakBeforeMultilineStrings. 5422 EXPECT_EQ("aaaaaaaaaaaa(aaaaaaaaaaaaa,\n" 5423 " \"aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa \"\n" 5424 " \"aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\");", 5425 format("aaaaaaaaaaaa(aaaaaaaaaaaaa, \"aaaaaaaaaaaaaaaaaaaaaa " 5426 "aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa " 5427 "aaaaaaaaaaaaaaaaaaaaaa\");", 5428 getGoogleStyle())); 5429 EXPECT_EQ("llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 5430 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";", 5431 format("llvm::outs() << " 5432 "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa" 5433 "aaaaaaaaaaaaaaaaaaa\";")); 5434 EXPECT_EQ("ffff(\n" 5435 " {\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 5436 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});", 5437 format("ffff({\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa " 5438 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});", 5439 getGoogleStyle())); 5440 5441 FormatStyle AlignLeft = getLLVMStyleWithColumns(12); 5442 AlignLeft.AlignEscapedNewlinesLeft = true; 5443 EXPECT_EQ( 5444 "#define A \\\n" 5445 " \"some \" \\\n" 5446 " \"text \" \\\n" 5447 " \"other\";", 5448 format("#define A \"some text other\";", AlignLeft)); 5449 } 5450 5451 TEST_F(FormatTest, DontSplitStringLiteralsWithEscapedNewlines) { 5452 EXPECT_EQ( 5453 "aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 5454 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 5455 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";", 5456 format("aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 5457 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 5458 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";")); 5459 } 5460 5461 TEST_F(FormatTest, CountsCharactersInMultilineRawStringLiterals) { 5462 EXPECT_EQ("f(g(R\"x(raw literal)x\", a), b);", 5463 format("f(g(R\"x(raw literal)x\", a), b);", getGoogleStyle())); 5464 EXPECT_EQ("fffffffffff(g(R\"x(\n" 5465 "multiline raw string literal xxxxxxxxxxxxxx\n" 5466 ")x\",\n" 5467 " a),\n" 5468 " b);", 5469 format("fffffffffff(g(R\"x(\n" 5470 "multiline raw string literal xxxxxxxxxxxxxx\n" 5471 ")x\", a), b);", 5472 getGoogleStyleWithColumns(20))); 5473 EXPECT_EQ("fffffffffff(\n" 5474 " g(R\"x(qqq\n" 5475 "multiline raw string literal xxxxxxxxxxxxxx\n" 5476 ")x\",\n" 5477 " a),\n" 5478 " b);", 5479 format("fffffffffff(g(R\"x(qqq\n" 5480 "multiline raw string literal xxxxxxxxxxxxxx\n" 5481 ")x\", a), b);", 5482 getGoogleStyleWithColumns(20))); 5483 5484 EXPECT_EQ("fffffffffff(R\"x(\n" 5485 "multiline raw string literal xxxxxxxxxxxxxx\n" 5486 ")x\");", 5487 format("fffffffffff(R\"x(\n" 5488 "multiline raw string literal xxxxxxxxxxxxxx\n" 5489 ")x\");", 5490 getGoogleStyleWithColumns(20))); 5491 EXPECT_EQ("fffffffffff(R\"x(\n" 5492 "multiline raw string literal xxxxxxxxxxxxxx\n" 5493 ")x\" +\n" 5494 " bbbbbb);", 5495 format("fffffffffff(R\"x(\n" 5496 "multiline raw string literal xxxxxxxxxxxxxx\n" 5497 ")x\" + bbbbbb);", 5498 getGoogleStyleWithColumns(20))); 5499 } 5500 5501 TEST_F(FormatTest, SkipsUnknownStringLiterals) { 5502 EXPECT_EQ( 5503 "u8\"unsupported literal\";", 5504 format("u8\"unsupported literal\";", getGoogleStyleWithColumns(15))); 5505 EXPECT_EQ("u\"unsupported literal\";", 5506 format("u\"unsupported literal\";", getGoogleStyleWithColumns(15))); 5507 EXPECT_EQ("U\"unsupported literal\";", 5508 format("U\"unsupported literal\";", getGoogleStyleWithColumns(15))); 5509 EXPECT_EQ("L\"unsupported literal\";", 5510 format("L\"unsupported literal\";", getGoogleStyleWithColumns(15))); 5511 EXPECT_EQ("R\"x(raw literal)x\";", 5512 format("R\"x(raw literal)x\";", getGoogleStyleWithColumns(15))); 5513 verifyFormat("string a = \"unterminated;"); 5514 EXPECT_EQ("function(\"unterminated,\n" 5515 " OtherParameter);", 5516 format("function( \"unterminated,\n" 5517 " OtherParameter);")); 5518 } 5519 5520 TEST_F(FormatTest, DoesNotTryToParseUDLiteralsInPreCpp11Code) { 5521 EXPECT_EQ("#define x(_a) printf(\"foo\" _a);", 5522 format("#define x(_a) printf(\"foo\"_a);", getLLVMStyle())); 5523 } 5524 5525 TEST_F(FormatTest, BreakStringLiteralsBeforeUnbreakableTokenSequence) { 5526 EXPECT_EQ("someFunction(\"aaabbbcccd\"\n" 5527 " \"ddeeefff\");", 5528 format("someFunction(\"aaabbbcccdddeeefff\");", 5529 getLLVMStyleWithColumns(25))); 5530 EXPECT_EQ("someFunction1234567890(\n" 5531 " \"aaabbbcccdddeeefff\");", 5532 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 5533 getLLVMStyleWithColumns(26))); 5534 EXPECT_EQ("someFunction1234567890(\n" 5535 " \"aaabbbcccdddeeeff\"\n" 5536 " \"f\");", 5537 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 5538 getLLVMStyleWithColumns(25))); 5539 EXPECT_EQ("someFunction1234567890(\n" 5540 " \"aaabbbcccdddeeeff\"\n" 5541 " \"f\");", 5542 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 5543 getLLVMStyleWithColumns(24))); 5544 EXPECT_EQ("someFunction(\"aaabbbcc \"\n" 5545 " \"ddde \"\n" 5546 " \"efff\");", 5547 format("someFunction(\"aaabbbcc ddde efff\");", 5548 getLLVMStyleWithColumns(25))); 5549 EXPECT_EQ("someFunction(\"aaabbbccc \"\n" 5550 " \"ddeeefff\");", 5551 format("someFunction(\"aaabbbccc ddeeefff\");", 5552 getLLVMStyleWithColumns(25))); 5553 EXPECT_EQ("someFunction1234567890(\n" 5554 " \"aaabb \"\n" 5555 " \"cccdddeeefff\");", 5556 format("someFunction1234567890(\"aaabb cccdddeeefff\");", 5557 getLLVMStyleWithColumns(25))); 5558 EXPECT_EQ("#define A \\\n" 5559 " string s = \\\n" 5560 " \"123456789\" \\\n" 5561 " \"0\"; \\\n" 5562 " int i;", 5563 format("#define A string s = \"1234567890\"; int i;", 5564 getLLVMStyleWithColumns(20))); 5565 // FIXME: Put additional penalties on breaking at non-whitespace locations. 5566 EXPECT_EQ("someFunction(\"aaabbbcc \"\n" 5567 " \"dddeeeff\"\n" 5568 " \"f\");", 5569 format("someFunction(\"aaabbbcc dddeeefff\");", 5570 getLLVMStyleWithColumns(25))); 5571 } 5572 5573 TEST_F(FormatTest, DoNotBreakStringLiteralsInEscapeSequence) { 5574 EXPECT_EQ("\"\\a\"", 5575 format("\"\\a\"", getLLVMStyleWithColumns(3))); 5576 EXPECT_EQ("\"\\\"", 5577 format("\"\\\"", getLLVMStyleWithColumns(2))); 5578 EXPECT_EQ("\"test\"\n" 5579 "\"\\n\"", 5580 format("\"test\\n\"", getLLVMStyleWithColumns(7))); 5581 EXPECT_EQ("\"tes\\\\\"\n" 5582 "\"n\"", 5583 format("\"tes\\\\n\"", getLLVMStyleWithColumns(7))); 5584 EXPECT_EQ("\"\\\\\\\\\"\n" 5585 "\"\\n\"", 5586 format("\"\\\\\\\\\\n\"", getLLVMStyleWithColumns(7))); 5587 EXPECT_EQ("\"\\uff01\"", 5588 format("\"\\uff01\"", getLLVMStyleWithColumns(7))); 5589 EXPECT_EQ("\"\\uff01\"\n" 5590 "\"test\"", 5591 format("\"\\uff01test\"", getLLVMStyleWithColumns(8))); 5592 EXPECT_EQ("\"\\Uff01ff02\"", 5593 format("\"\\Uff01ff02\"", getLLVMStyleWithColumns(11))); 5594 EXPECT_EQ("\"\\x000000000001\"\n" 5595 "\"next\"", 5596 format("\"\\x000000000001next\"", getLLVMStyleWithColumns(16))); 5597 EXPECT_EQ("\"\\x000000000001next\"", 5598 format("\"\\x000000000001next\"", getLLVMStyleWithColumns(15))); 5599 EXPECT_EQ("\"\\x000000000001\"", 5600 format("\"\\x000000000001\"", getLLVMStyleWithColumns(7))); 5601 EXPECT_EQ("\"test\"\n" 5602 "\"\\000000\"\n" 5603 "\"000001\"", 5604 format("\"test\\000000000001\"", getLLVMStyleWithColumns(9))); 5605 EXPECT_EQ("\"test\\000\"\n" 5606 "\"00000000\"\n" 5607 "\"1\"", 5608 format("\"test\\000000000001\"", getLLVMStyleWithColumns(10))); 5609 EXPECT_EQ("R\"(\\x\\x00)\"\n", 5610 format("R\"(\\x\\x00)\"\n", getGoogleStyleWithColumns(7))); 5611 } 5612 5613 TEST_F(FormatTest, DoNotCreateUnreasonableUnwrappedLines) { 5614 verifyFormat("void f() {\n" 5615 " return g() {}\n" 5616 " void h() {}"); 5617 verifyFormat("if (foo)\n" 5618 " return { forgot_closing_brace();\n" 5619 "test();"); 5620 verifyFormat("int a[] = { void forgot_closing_brace() { f();\n" 5621 "g();\n" 5622 "}"); 5623 } 5624 5625 TEST_F(FormatTest, FormatsClosingBracesInEmptyNestedBlocks) { 5626 verifyFormat("class X {\n" 5627 " void f() {\n" 5628 " }\n" 5629 "};", 5630 getLLVMStyleWithColumns(12)); 5631 } 5632 5633 TEST_F(FormatTest, ConfigurableIndentWidth) { 5634 FormatStyle EightIndent = getLLVMStyleWithColumns(18); 5635 EightIndent.IndentWidth = 8; 5636 verifyFormat("void f() {\n" 5637 " someFunction();\n" 5638 " if (true) {\n" 5639 " f();\n" 5640 " }\n" 5641 "}", 5642 EightIndent); 5643 verifyFormat("class X {\n" 5644 " void f() {\n" 5645 " }\n" 5646 "};", 5647 EightIndent); 5648 verifyFormat("int x[] = {\n" 5649 " call(),\n" 5650 " call(),\n" 5651 "};", 5652 EightIndent); 5653 } 5654 5655 TEST_F(FormatTest, ConfigurableFunctionDeclarationIndentAfterType) { 5656 verifyFormat("void\n" 5657 "f();", 5658 getLLVMStyleWithColumns(8)); 5659 } 5660 5661 TEST_F(FormatTest, ConfigurableUseOfTab) { 5662 FormatStyle Tab = getLLVMStyleWithColumns(42); 5663 Tab.IndentWidth = 8; 5664 Tab.UseTab = true; 5665 Tab.AlignEscapedNewlinesLeft = true; 5666 verifyFormat("class X {\n" 5667 "\tvoid f() {\n" 5668 "\t\tsomeFunction(parameter1,\n" 5669 "\t\t\t parameter2);\n" 5670 "\t}\n" 5671 "};", 5672 Tab); 5673 verifyFormat("#define A \\\n" 5674 "\tvoid f() { \\\n" 5675 "\t\tsomeFunction( \\\n" 5676 "\t\t parameter1, \\\n" 5677 "\t\t parameter2); \\\n" 5678 "\t}", 5679 Tab); 5680 EXPECT_EQ("void f() {\n" 5681 "\tf();\n" 5682 "\tg();\n" 5683 "}", 5684 format("void f() {\n" 5685 "\tf();\n" 5686 "\tg();\n" 5687 "}", 5688 0, 0, Tab)); 5689 EXPECT_EQ("void f() {\n" 5690 "\tf();\n" 5691 "\tg();\n" 5692 "}", 5693 format("void f() {\n" 5694 "\tf();\n" 5695 "\tg();\n" 5696 "}", 5697 16, 0, Tab)); 5698 EXPECT_EQ("void f() {\n" 5699 " \tf();\n" 5700 "\tg();\n" 5701 "}", 5702 format("void f() {\n" 5703 " \tf();\n" 5704 " \tg();\n" 5705 "}", 5706 21, 0, Tab)); 5707 5708 Tab.TabWidth = 4; 5709 Tab.IndentWidth = 8; 5710 verifyFormat("class TabWidth4Indent8 {\n" 5711 "\t\tvoid f() {\n" 5712 "\t\t\t\tsomeFunction(parameter1,\n" 5713 "\t\t\t\t\t\t\t parameter2);\n" 5714 "\t\t}\n" 5715 "};", 5716 Tab); 5717 5718 Tab.TabWidth = 4; 5719 Tab.IndentWidth = 4; 5720 verifyFormat("class TabWidth4Indent4 {\n" 5721 "\tvoid f() {\n" 5722 "\t\tsomeFunction(parameter1,\n" 5723 "\t\t\t\t\t parameter2);\n" 5724 "\t}\n" 5725 "};", 5726 Tab); 5727 5728 Tab.TabWidth = 8; 5729 Tab.IndentWidth = 4; 5730 verifyFormat("class TabWidth8Indent4 {\n" 5731 " void f() {\n" 5732 "\tsomeFunction(parameter1,\n" 5733 "\t\t parameter2);\n" 5734 " }\n" 5735 "};", 5736 Tab); 5737 5738 // FIXME: To correctly count mixed whitespace we need to 5739 // also correctly count mixed whitespace in front of the comment. 5740 5741 // Tab.TabWidth = 8; 5742 // Tab.IndentWidth = 8; 5743 // EXPECT_EQ("/*\n" 5744 // "\t a\t\tcomment\n" 5745 // "\t in multiple lines\n" 5746 // " */", 5747 // format(" /*\t \t \n" 5748 // " \t \t a\t\tcomment\t \t\n" 5749 // " \t \t in multiple lines\t\n" 5750 // " \t */", 5751 // Tab)); 5752 // Tab.UseTab = false; 5753 // EXPECT_EQ("/*\n" 5754 // " a\t\tcomment\n" 5755 // " in multiple lines\n" 5756 // " */", 5757 // format(" /*\t \t \n" 5758 // " \t \t a\t\tcomment\t \t\n" 5759 // " \t \t in multiple lines\t\n" 5760 // " \t */", 5761 // Tab)); 5762 // EXPECT_EQ("/* some\n" 5763 // " comment */", 5764 // format(" \t \t /* some\n" 5765 // " \t \t comment */", 5766 // Tab)); 5767 5768 EXPECT_EQ("{\n" 5769 " /*\n" 5770 " * Comment\n" 5771 " */\n" 5772 " int i;\n" 5773 "}", 5774 format("{\n" 5775 "\t/*\n" 5776 "\t * Comment\n" 5777 "\t */\n" 5778 "\t int i;\n" 5779 "}")); 5780 } 5781 5782 TEST_F(FormatTest, ConfigurableSpaceAfterControlStatementKeyword) { 5783 FormatStyle NoSpace = getLLVMStyle(); 5784 NoSpace.SpaceAfterControlStatementKeyword = false; 5785 5786 verifyFormat("while(true)\n" 5787 " continue;", NoSpace); 5788 verifyFormat("for(;;)\n" 5789 " continue;", NoSpace); 5790 verifyFormat("if(true)\n" 5791 " f();\n" 5792 "else if(true)\n" 5793 " f();", NoSpace); 5794 verifyFormat("do {\n" 5795 " do_something();\n" 5796 "} while(something());", NoSpace); 5797 verifyFormat("switch(x) {\n" 5798 "default:\n" 5799 " break;\n" 5800 "}", NoSpace); 5801 } 5802 5803 TEST_F(FormatTest, ConfigurableSpacesInParentheses) { 5804 FormatStyle Spaces = getLLVMStyle(); 5805 5806 Spaces.SpacesInParentheses = true; 5807 verifyFormat("call( x, y, z );", Spaces); 5808 verifyFormat("while ( (bool)1 )\n" 5809 " continue;", Spaces); 5810 verifyFormat("for ( ;; )\n" 5811 " continue;", Spaces); 5812 verifyFormat("if ( true )\n" 5813 " f();\n" 5814 "else if ( true )\n" 5815 " f();", Spaces); 5816 verifyFormat("do {\n" 5817 " do_something( (int)i );\n" 5818 "} while ( something() );", Spaces); 5819 verifyFormat("switch ( x ) {\n" 5820 "default:\n" 5821 " break;\n" 5822 "}", Spaces); 5823 5824 Spaces.SpacesInParentheses = false; 5825 Spaces.SpacesInCStyleCastParentheses = true; 5826 verifyFormat("Type *A = ( Type * )P;", Spaces); 5827 verifyFormat("Type *A = ( vector<Type *, int *> )P;", Spaces); 5828 verifyFormat("x = ( int32 )y;", Spaces); 5829 verifyFormat("int a = ( int )(2.0f);", Spaces); 5830 verifyFormat("#define AA(X) sizeof((( X * )NULL)->a)", Spaces); 5831 verifyFormat("my_int a = ( my_int )sizeof(int);", Spaces); 5832 verifyFormat("#define x (( int )-1)", Spaces); 5833 5834 Spaces.SpacesInParentheses = false; 5835 Spaces.SpaceInEmptyParentheses = true; 5836 verifyFormat("call(x, y, z);", Spaces); 5837 verifyFormat("call( )", Spaces); 5838 5839 // Run the first set of tests again with 5840 // Spaces.SpacesInParentheses = false, 5841 // Spaces.SpaceInEmptyParentheses = true and 5842 // Spaces.SpacesInCStyleCastParentheses = true 5843 Spaces.SpacesInParentheses = false, 5844 Spaces.SpaceInEmptyParentheses = true; 5845 Spaces.SpacesInCStyleCastParentheses = true; 5846 verifyFormat("call(x, y, z);", Spaces); 5847 verifyFormat("while (( bool )1)\n" 5848 " continue;", Spaces); 5849 verifyFormat("for (;;)\n" 5850 " continue;", Spaces); 5851 verifyFormat("if (true)\n" 5852 " f( );\n" 5853 "else if (true)\n" 5854 " f( );", Spaces); 5855 verifyFormat("do {\n" 5856 " do_something(( int )i);\n" 5857 "} while (something( ));", Spaces); 5858 verifyFormat("switch (x) {\n" 5859 "default:\n" 5860 " break;\n" 5861 "}", Spaces); 5862 } 5863 5864 TEST_F(FormatTest, LinuxBraceBreaking) { 5865 FormatStyle BreakBeforeBrace = getLLVMStyle(); 5866 BreakBeforeBrace.BreakBeforeBraces = FormatStyle::BS_Linux; 5867 verifyFormat("namespace a\n" 5868 "{\n" 5869 "class A\n" 5870 "{\n" 5871 " void f()\n" 5872 " {\n" 5873 " if (true) {\n" 5874 " a();\n" 5875 " b();\n" 5876 " }\n" 5877 " }\n" 5878 " void g()\n" 5879 " {\n" 5880 " return;\n" 5881 " }\n" 5882 "}\n" 5883 "}", 5884 BreakBeforeBrace); 5885 } 5886 5887 TEST_F(FormatTest, StroustrupBraceBreaking) { 5888 FormatStyle BreakBeforeBrace = getLLVMStyle(); 5889 BreakBeforeBrace.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 5890 verifyFormat("namespace a {\n" 5891 "class A {\n" 5892 " void f()\n" 5893 " {\n" 5894 " if (true) {\n" 5895 " a();\n" 5896 " b();\n" 5897 " }\n" 5898 " }\n" 5899 " void g()\n" 5900 " {\n" 5901 " return;\n" 5902 " }\n" 5903 "}\n" 5904 "}", 5905 BreakBeforeBrace); 5906 } 5907 5908 TEST_F(FormatTest, AllmanBraceBreaking) { 5909 FormatStyle BreakBeforeBrace = getLLVMStyle(); 5910 BreakBeforeBrace.BreakBeforeBraces = FormatStyle::BS_Allman; 5911 verifyFormat("namespace a\n" 5912 "{\n" 5913 "class A\n" 5914 "{\n" 5915 " void f()\n" 5916 " {\n" 5917 " if (true)\n" 5918 " {\n" 5919 " a();\n" 5920 " b();\n" 5921 " }\n" 5922 " }\n" 5923 " void g()\n" 5924 " {\n" 5925 " return;\n" 5926 " }\n" 5927 "}\n" 5928 "}", 5929 BreakBeforeBrace); 5930 5931 verifyFormat("void f()\n" 5932 "{\n" 5933 " if (true)\n" 5934 " {\n" 5935 " a();\n" 5936 " }\n" 5937 " else if (false)\n" 5938 " {\n" 5939 " b();\n" 5940 " }\n" 5941 " else\n" 5942 " {\n" 5943 " c();\n" 5944 " }\n" 5945 "}\n", 5946 BreakBeforeBrace); 5947 5948 verifyFormat("void f()\n" 5949 "{\n" 5950 " for (int i = 0; i < 10; ++i)\n" 5951 " {\n" 5952 " a();\n" 5953 " }\n" 5954 " while (false)\n" 5955 " {\n" 5956 " b();\n" 5957 " }\n" 5958 " do\n" 5959 " {\n" 5960 " c();\n" 5961 " } while (false)\n" 5962 "}\n", 5963 BreakBeforeBrace); 5964 5965 verifyFormat("void f(int a)\n" 5966 "{\n" 5967 " switch (a)\n" 5968 " {\n" 5969 " case 0:\n" 5970 " break;\n" 5971 " case 1:\n" 5972 " {\n" 5973 " break;\n" 5974 " }\n" 5975 " case 2:\n" 5976 " {\n" 5977 " }\n" 5978 " break;\n" 5979 " default:\n" 5980 " break;\n" 5981 " }\n" 5982 "}\n", 5983 BreakBeforeBrace); 5984 5985 verifyFormat("enum X\n" 5986 "{\n" 5987 " Y = 0,\n" 5988 "}\n", 5989 BreakBeforeBrace); 5990 5991 FormatStyle BreakBeforeBraceShortIfs = BreakBeforeBrace; 5992 BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine = true; 5993 BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true; 5994 verifyFormat("void f(bool b)\n" 5995 "{\n" 5996 " if (b)\n" 5997 " {\n" 5998 " return;\n" 5999 " }\n" 6000 "}\n", 6001 BreakBeforeBraceShortIfs); 6002 verifyFormat("void f(bool b)\n" 6003 "{\n" 6004 " if (b) return;\n" 6005 "}\n", 6006 BreakBeforeBraceShortIfs); 6007 verifyFormat("void f(bool b)\n" 6008 "{\n" 6009 " while (b)\n" 6010 " {\n" 6011 " return;\n" 6012 " }\n" 6013 "}\n", 6014 BreakBeforeBraceShortIfs); 6015 } 6016 6017 TEST_F(FormatTest, CatchExceptionReferenceBinding) { 6018 verifyFormat("void f() {\n" 6019 " try {\n" 6020 " }\n" 6021 " catch (const Exception &e) {\n" 6022 " }\n" 6023 "}\n", 6024 getLLVMStyle()); 6025 } 6026 6027 TEST_F(FormatTest, UnderstandsPragmas) { 6028 verifyFormat("#pragma omp reduction(| : var)"); 6029 verifyFormat("#pragma omp reduction(+ : var)"); 6030 } 6031 6032 bool allStylesEqual(ArrayRef<FormatStyle> Styles) { 6033 for (size_t i = 1; i < Styles.size(); ++i) 6034 if (!(Styles[0] == Styles[i])) 6035 return false; 6036 return true; 6037 } 6038 6039 TEST_F(FormatTest, GetsPredefinedStyleByName) { 6040 FormatStyle Styles[3]; 6041 6042 Styles[0] = getLLVMStyle(); 6043 EXPECT_TRUE(getPredefinedStyle("LLVM", &Styles[1])); 6044 EXPECT_TRUE(getPredefinedStyle("lLvM", &Styles[2])); 6045 EXPECT_TRUE(allStylesEqual(Styles)); 6046 6047 Styles[0] = getGoogleStyle(); 6048 EXPECT_TRUE(getPredefinedStyle("Google", &Styles[1])); 6049 EXPECT_TRUE(getPredefinedStyle("gOOgle", &Styles[2])); 6050 EXPECT_TRUE(allStylesEqual(Styles)); 6051 6052 Styles[0] = getChromiumStyle(); 6053 EXPECT_TRUE(getPredefinedStyle("Chromium", &Styles[1])); 6054 EXPECT_TRUE(getPredefinedStyle("cHRoMiUM", &Styles[2])); 6055 EXPECT_TRUE(allStylesEqual(Styles)); 6056 6057 Styles[0] = getMozillaStyle(); 6058 EXPECT_TRUE(getPredefinedStyle("Mozilla", &Styles[1])); 6059 EXPECT_TRUE(getPredefinedStyle("moZILla", &Styles[2])); 6060 EXPECT_TRUE(allStylesEqual(Styles)); 6061 6062 Styles[0] = getWebKitStyle(); 6063 EXPECT_TRUE(getPredefinedStyle("WebKit", &Styles[1])); 6064 EXPECT_TRUE(getPredefinedStyle("wEbKit", &Styles[2])); 6065 EXPECT_TRUE(allStylesEqual(Styles)); 6066 6067 EXPECT_FALSE(getPredefinedStyle("qwerty", &Styles[0])); 6068 } 6069 6070 TEST_F(FormatTest, ParsesConfiguration) { 6071 FormatStyle Style = {}; 6072 #define CHECK_PARSE(TEXT, FIELD, VALUE) \ 6073 EXPECT_NE(VALUE, Style.FIELD); \ 6074 EXPECT_EQ(0, parseConfiguration(TEXT, &Style).value()); \ 6075 EXPECT_EQ(VALUE, Style.FIELD) 6076 6077 #define CHECK_PARSE_BOOL(FIELD) \ 6078 Style.FIELD = false; \ 6079 EXPECT_EQ(0, parseConfiguration(#FIELD ": true", &Style).value()); \ 6080 EXPECT_TRUE(Style.FIELD); \ 6081 EXPECT_EQ(0, parseConfiguration(#FIELD ": false", &Style).value()); \ 6082 EXPECT_FALSE(Style.FIELD); 6083 6084 CHECK_PARSE_BOOL(AlignEscapedNewlinesLeft); 6085 CHECK_PARSE_BOOL(AlignTrailingComments); 6086 CHECK_PARSE_BOOL(AllowAllParametersOfDeclarationOnNextLine); 6087 CHECK_PARSE_BOOL(AllowShortIfStatementsOnASingleLine); 6088 CHECK_PARSE_BOOL(AllowShortLoopsOnASingleLine); 6089 CHECK_PARSE_BOOL(AlwaysBreakTemplateDeclarations); 6090 CHECK_PARSE_BOOL(BinPackParameters); 6091 CHECK_PARSE_BOOL(BreakBeforeBinaryOperators); 6092 CHECK_PARSE_BOOL(BreakConstructorInitializersBeforeComma); 6093 CHECK_PARSE_BOOL(ConstructorInitializerAllOnOneLineOrOnePerLine); 6094 CHECK_PARSE_BOOL(DerivePointerBinding); 6095 CHECK_PARSE_BOOL(IndentCaseLabels); 6096 CHECK_PARSE_BOOL(ObjCSpaceBeforeProtocolList); 6097 CHECK_PARSE_BOOL(PointerBindsToType); 6098 CHECK_PARSE_BOOL(Cpp11BracedListStyle); 6099 CHECK_PARSE_BOOL(UseTab); 6100 CHECK_PARSE_BOOL(IndentFunctionDeclarationAfterType); 6101 CHECK_PARSE_BOOL(SpacesInParentheses); 6102 CHECK_PARSE_BOOL(SpaceInEmptyParentheses); 6103 CHECK_PARSE_BOOL(SpacesInCStyleCastParentheses); 6104 CHECK_PARSE_BOOL(SpaceAfterControlStatementKeyword); 6105 6106 CHECK_PARSE("AccessModifierOffset: -1234", AccessModifierOffset, -1234); 6107 CHECK_PARSE("ConstructorInitializerIndentWidth: 1234", 6108 ConstructorInitializerIndentWidth, 1234u); 6109 CHECK_PARSE("ColumnLimit: 1234", ColumnLimit, 1234u); 6110 CHECK_PARSE("MaxEmptyLinesToKeep: 1234", MaxEmptyLinesToKeep, 1234u); 6111 CHECK_PARSE("PenaltyExcessCharacter: 1234", PenaltyExcessCharacter, 1234u); 6112 CHECK_PARSE("PenaltyReturnTypeOnItsOwnLine: 1234", 6113 PenaltyReturnTypeOnItsOwnLine, 1234u); 6114 CHECK_PARSE("SpacesBeforeTrailingComments: 1234", 6115 SpacesBeforeTrailingComments, 1234u); 6116 CHECK_PARSE("IndentWidth: 32", IndentWidth, 32u); 6117 6118 Style.Standard = FormatStyle::LS_Auto; 6119 CHECK_PARSE("Standard: Cpp03", Standard, FormatStyle::LS_Cpp03); 6120 CHECK_PARSE("Standard: Cpp11", Standard, FormatStyle::LS_Cpp11); 6121 CHECK_PARSE("Standard: C++03", Standard, FormatStyle::LS_Cpp03); 6122 CHECK_PARSE("Standard: C++11", Standard, FormatStyle::LS_Cpp11); 6123 CHECK_PARSE("Standard: Auto", Standard, FormatStyle::LS_Auto); 6124 6125 Style.ColumnLimit = 123; 6126 FormatStyle BaseStyle = getLLVMStyle(); 6127 CHECK_PARSE("BasedOnStyle: LLVM", ColumnLimit, BaseStyle.ColumnLimit); 6128 CHECK_PARSE("BasedOnStyle: LLVM\nColumnLimit: 1234", ColumnLimit, 1234u); 6129 6130 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 6131 CHECK_PARSE("BreakBeforeBraces: Attach", BreakBeforeBraces, 6132 FormatStyle::BS_Attach); 6133 CHECK_PARSE("BreakBeforeBraces: Linux", BreakBeforeBraces, 6134 FormatStyle::BS_Linux); 6135 CHECK_PARSE("BreakBeforeBraces: Stroustrup", BreakBeforeBraces, 6136 FormatStyle::BS_Stroustrup); 6137 6138 Style.NamespaceIndentation = FormatStyle::NI_All; 6139 CHECK_PARSE("NamespaceIndentation: None", NamespaceIndentation, 6140 FormatStyle::NI_None); 6141 CHECK_PARSE("NamespaceIndentation: Inner", NamespaceIndentation, 6142 FormatStyle::NI_Inner); 6143 CHECK_PARSE("NamespaceIndentation: All", NamespaceIndentation, 6144 FormatStyle::NI_All); 6145 6146 #undef CHECK_PARSE 6147 #undef CHECK_PARSE_BOOL 6148 } 6149 6150 TEST_F(FormatTest, ConfigurationRoundTripTest) { 6151 FormatStyle Style = getLLVMStyle(); 6152 std::string YAML = configurationAsText(Style); 6153 FormatStyle ParsedStyle = {}; 6154 EXPECT_EQ(0, parseConfiguration(YAML, &ParsedStyle).value()); 6155 EXPECT_EQ(Style, ParsedStyle); 6156 } 6157 6158 TEST_F(FormatTest, WorksFor8bitEncodings) { 6159 EXPECT_EQ("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 \"\n" 6160 "\"\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \"\n" 6161 "\"\xe7\xe8\xec\xed\xfe\xfe \"\n" 6162 "\"\xef\xee\xf0\xf3...\"", 6163 format("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 " 6164 "\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \xe7\xe8\xec\xed\xfe\xfe " 6165 "\xef\xee\xf0\xf3...\"", 6166 getLLVMStyleWithColumns(12))); 6167 } 6168 6169 // FIXME: Encode Cyrillic and CJK characters below to appease MS compilers. 6170 #if !defined(_MSC_VER) 6171 6172 TEST_F(FormatTest, CountsUTF8CharactersProperly) { 6173 verifyFormat("\"Однажды в студёную зимнюю пору...\"", 6174 getLLVMStyleWithColumns(35)); 6175 verifyFormat("\"一 二 三 四 五 六 七 八 九 十\"", 6176 getLLVMStyleWithColumns(31)); 6177 verifyFormat("// Однажды в студёную зимнюю пору...", 6178 getLLVMStyleWithColumns(36)); 6179 verifyFormat("// 一 二 三 四 五 六 七 八 九 十", 6180 getLLVMStyleWithColumns(32)); 6181 verifyFormat("/* Однажды в студёную зимнюю пору... */", 6182 getLLVMStyleWithColumns(39)); 6183 verifyFormat("/* 一 二 三 四 五 六 七 八 九 十 */", 6184 getLLVMStyleWithColumns(35)); 6185 } 6186 6187 TEST_F(FormatTest, SplitsUTF8Strings) { 6188 EXPECT_EQ( 6189 "\"Однажды, в \"\n" 6190 "\"студёную \"\n" 6191 "\"зимнюю \"\n" 6192 "\"пору,\"", 6193 format("\"Однажды, в студёную зимнюю пору,\"", 6194 getLLVMStyleWithColumns(13))); 6195 EXPECT_EQ("\"一 二 三 \"\n" 6196 "\"四 五六 \"\n" 6197 "\"七 八 九 \"\n" 6198 "\"十\"", 6199 format("\"一 二 三 四 五六 七 八 九 十\"", 6200 getLLVMStyleWithColumns(11))); 6201 EXPECT_EQ("\"一\t二 \"\n" 6202 "\"\t三 \"\n" 6203 "\"四 五\t六 \"\n" 6204 "\"\t七 \"\n" 6205 "\"八九十\tqq\"", 6206 format("\"一\t二 \t三 四 五\t六 \t七 八九十\tqq\"", 6207 getLLVMStyleWithColumns(11))); 6208 } 6209 6210 6211 TEST_F(FormatTest, HandlesDoubleWidthCharsInMultiLineStrings) { 6212 EXPECT_EQ("const char *sssss =\n" 6213 " \"一二三四五六七八\\\n" 6214 " 九 十\";", 6215 format("const char *sssss = \"一二三四五六七八\\\n" 6216 " 九 十\";", 6217 getLLVMStyleWithColumns(30))); 6218 } 6219 6220 TEST_F(FormatTest, SplitsUTF8LineComments) { 6221 EXPECT_EQ("// Я из лесу\n" 6222 "// вышел; был\n" 6223 "// сильный\n" 6224 "// мороз.", 6225 format("// Я из лесу вышел; был сильный мороз.", 6226 getLLVMStyleWithColumns(13))); 6227 EXPECT_EQ("// 一二三\n" 6228 "// 四五六七\n" 6229 "// 八 九\n" 6230 "// 十", 6231 format("// 一二三 四五六七 八 九 十", getLLVMStyleWithColumns(9))); 6232 } 6233 6234 TEST_F(FormatTest, SplitsUTF8BlockComments) { 6235 EXPECT_EQ("/* Гляжу,\n" 6236 " * поднимается\n" 6237 " * медленно в\n" 6238 " * гору\n" 6239 " * Лошадка,\n" 6240 " * везущая\n" 6241 " * хворосту\n" 6242 " * воз. */", 6243 format("/* Гляжу, поднимается медленно в гору\n" 6244 " * Лошадка, везущая хворосту воз. */", 6245 getLLVMStyleWithColumns(13))); 6246 EXPECT_EQ( 6247 "/* 一二三\n" 6248 " * 四五六七\n" 6249 " * 八 九\n" 6250 " * 十 */", 6251 format("/* 一二三 四五六七 八 九 十 */", getLLVMStyleWithColumns(9))); 6252 EXPECT_EQ("/* �������� ��������\n" 6253 " * ��������\n" 6254 " * ������-�� */", 6255 format("/* �������� �������� �������� ������-�� */", getLLVMStyleWithColumns(12))); 6256 } 6257 6258 #endif // _MSC_VER 6259 6260 TEST_F(FormatTest, ConstructorInitializerIndentWidth) { 6261 FormatStyle Style = getLLVMStyle(); 6262 6263 Style.ConstructorInitializerIndentWidth = 4; 6264 verifyFormat( 6265 "SomeClass::Constructor()\n" 6266 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 6267 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 6268 Style); 6269 6270 Style.ConstructorInitializerIndentWidth = 2; 6271 verifyFormat( 6272 "SomeClass::Constructor()\n" 6273 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 6274 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 6275 Style); 6276 6277 Style.ConstructorInitializerIndentWidth = 0; 6278 verifyFormat( 6279 "SomeClass::Constructor()\n" 6280 ": aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 6281 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 6282 Style); 6283 6284 Style.BreakConstructorInitializersBeforeComma = true; 6285 Style.ConstructorInitializerIndentWidth = 4; 6286 verifyFormat("SomeClass::Constructor()\n" 6287 " : a(a)\n" 6288 " , b(b)\n" 6289 " , c(c) {}", 6290 Style); 6291 6292 Style.ConstructorInitializerIndentWidth = 2; 6293 verifyFormat("SomeClass::Constructor()\n" 6294 " : a(a)\n" 6295 " , b(b)\n" 6296 " , c(c) {}", 6297 Style); 6298 6299 Style.ConstructorInitializerIndentWidth = 0; 6300 verifyFormat("SomeClass::Constructor()\n" 6301 ": a(a)\n" 6302 ", b(b)\n" 6303 ", c(c) {}", 6304 Style); 6305 } 6306 6307 TEST_F(FormatTest, FormatsWithWebKitStyle) { 6308 FormatStyle Style = getWebKitStyle(); 6309 6310 // Don't indent in outer namespaces. 6311 verifyFormat("namespace outer {\n" 6312 "int i;\n" 6313 "namespace inner {\n" 6314 " int i;\n" 6315 "} // namespace inner\n" 6316 "} // namespace outer\n" 6317 "namespace other_outer {\n" 6318 "int i;\n" 6319 "}", 6320 Style); 6321 6322 // Don't indent case labels. 6323 verifyFormat("switch (variable) {\n" 6324 "case 1:\n" 6325 "case 2:\n" 6326 " doSomething();\n" 6327 " break;\n" 6328 "default:\n" 6329 " ++variable;\n" 6330 "}", 6331 Style); 6332 6333 // Wrap before binary operators. 6334 EXPECT_EQ( 6335 "void f()\n" 6336 "{\n" 6337 " if (aaaaaaaaaaaaaaaa\n" 6338 " && bbbbbbbbbbbbbbbbbbbbbbbb\n" 6339 " && (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n" 6340 " return;\n" 6341 "}", 6342 format( 6343 "void f() {\n" 6344 "if (aaaaaaaaaaaaaaaa\n" 6345 "&& bbbbbbbbbbbbbbbbbbbbbbbb\n" 6346 "&& (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n" 6347 "return;\n" 6348 "}", 6349 Style)); 6350 6351 // Constructor initializers are formatted one per line with the "," on the 6352 // new line. 6353 verifyFormat("Constructor()\n" 6354 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6355 " , aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaa, // break\n" 6356 " aaaaaaaaaaaaaa)\n" 6357 " , aaaaaaaaaaaaaaaaaaaaaaa()\n{\n}", 6358 Style); 6359 6360 // Access specifiers should be aligned left. 6361 verifyFormat("class C {\n" 6362 "public:\n" 6363 " int i;\n" 6364 "};", 6365 Style); 6366 6367 // Do not align comments. 6368 verifyFormat("int a; // Do not\n" 6369 "double b; // align comments.", 6370 Style); 6371 6372 // Accept input's line breaks. 6373 EXPECT_EQ("if (aaaaaaaaaaaaaaa\n" 6374 " || bbbbbbbbbbbbbbb) {\n" 6375 " i++;\n" 6376 "}", 6377 format("if (aaaaaaaaaaaaaaa\n" 6378 "|| bbbbbbbbbbbbbbb) { i++; }", 6379 Style)); 6380 EXPECT_EQ("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) {\n" 6381 " i++;\n" 6382 "}", 6383 format("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) { i++; }", Style)); 6384 } 6385 6386 TEST_F(FormatTest, FormatsProtocolBufferDefinitions) { 6387 // It seems that clang-format can format protocol buffer definitions 6388 // (see https://code.google.com/p/protobuf/). 6389 verifyFormat("message SomeMessage {\n" 6390 " required int32 field1 = 1;\n" 6391 " optional string field2 = 2 [default = \"2\"]\n" 6392 "}"); 6393 } 6394 6395 TEST_F(FormatTest, FormatsLambdas) { 6396 verifyFormat("int c = [b]() mutable {\n" 6397 " return [&b] { return b++; }();\n" 6398 "}();\n"); 6399 verifyFormat("int c = [&] {\n" 6400 " [=] { return b++; }();\n" 6401 "}();\n"); 6402 verifyFormat("int c = [&, &a, a] {\n" 6403 " [=, c, &d] { return b++; }();\n" 6404 "}();\n"); 6405 verifyFormat("int c = [&a, &a, a] {\n" 6406 " [=, a, b, &c] { return b++; }();\n" 6407 "}();\n"); 6408 verifyFormat("auto c = { [&a, &a, a] {\n" 6409 " [=, a, b, &c] { return b++; }();\n" 6410 "} }\n"); 6411 verifyFormat("auto c = { [&a, &a, a] { [=, a, b, &c] {}(); } }\n"); 6412 verifyFormat("void f() {\n" 6413 " other(x.begin(), x.end(), [&](int, int) { return 1; });\n" 6414 "}\n"); 6415 verifyFormat("void f() {\n" 6416 " other(x.begin(), //\n" 6417 " x.end(), //\n" 6418 " [&](int, int) { return 1; });\n" 6419 "}\n"); 6420 6421 // Not lambdas. 6422 verifyFormat("constexpr char hello[]{ \"hello\" };"); 6423 verifyFormat("double &operator[](int i) { return 0; }\n" 6424 "int i;"); 6425 } 6426 6427 TEST_F(FormatTest, FormatsBlocks) { 6428 // FIXME: Make whitespace formatting consistent. Ask a ObjC dev how 6429 // it would ideally look. 6430 verifyFormat("[operation setCompletionBlock:^{ [self onOperationDone]; }];"); 6431 verifyFormat("int i = {[operation setCompletionBlock : ^{ [self " 6432 "onOperationDone]; }] };"); 6433 } 6434 6435 } // end namespace tooling 6436 } // end namespace clang 6437