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 #include "clang/Format/Format.h" 11 12 #include "../Tooling/ReplacementTest.h" 13 #include "FormatTestUtils.h" 14 15 #include "clang/Frontend/TextDiagnosticPrinter.h" 16 #include "llvm/Support/Debug.h" 17 #include "llvm/Support/MemoryBuffer.h" 18 #include "gtest/gtest.h" 19 20 #define DEBUG_TYPE "format-test" 21 22 using clang::tooling::ReplacementTest; 23 using clang::tooling::toReplacements; 24 25 namespace clang { 26 namespace format { 27 namespace { 28 29 FormatStyle getGoogleStyle() { return getGoogleStyle(FormatStyle::LK_Cpp); } 30 31 class FormatTest : public ::testing::Test { 32 protected: 33 enum IncompleteCheck { 34 IC_ExpectComplete, 35 IC_ExpectIncomplete, 36 IC_DoNotCheck 37 }; 38 39 std::string format(llvm::StringRef Code, 40 const FormatStyle &Style = getLLVMStyle(), 41 IncompleteCheck CheckIncomplete = IC_ExpectComplete) { 42 DEBUG(llvm::errs() << "---\n"); 43 DEBUG(llvm::errs() << Code << "\n\n"); 44 std::vector<tooling::Range> Ranges(1, tooling::Range(0, Code.size())); 45 bool IncompleteFormat = false; 46 tooling::Replacements Replaces = 47 reformat(Style, Code, Ranges, "<stdin>", &IncompleteFormat); 48 if (CheckIncomplete != IC_DoNotCheck) { 49 bool ExpectedIncompleteFormat = CheckIncomplete == IC_ExpectIncomplete; 50 EXPECT_EQ(ExpectedIncompleteFormat, IncompleteFormat) << Code << "\n\n"; 51 } 52 ReplacementCount = Replaces.size(); 53 auto Result = applyAllReplacements(Code, Replaces); 54 EXPECT_TRUE(static_cast<bool>(Result)); 55 DEBUG(llvm::errs() << "\n" << *Result << "\n\n"); 56 return *Result; 57 } 58 59 FormatStyle getLLVMStyleWithColumns(unsigned ColumnLimit) { 60 FormatStyle Style = getLLVMStyle(); 61 Style.ColumnLimit = ColumnLimit; 62 return Style; 63 } 64 65 FormatStyle getGoogleStyleWithColumns(unsigned ColumnLimit) { 66 FormatStyle Style = getGoogleStyle(); 67 Style.ColumnLimit = ColumnLimit; 68 return Style; 69 } 70 71 void verifyFormat(llvm::StringRef Code, 72 const FormatStyle &Style = getLLVMStyle()) { 73 EXPECT_EQ(Code.str(), format(test::messUp(Code), Style)); 74 } 75 76 void verifyIncompleteFormat(llvm::StringRef Code, 77 const FormatStyle &Style = getLLVMStyle()) { 78 EXPECT_EQ(Code.str(), 79 format(test::messUp(Code), Style, IC_ExpectIncomplete)); 80 } 81 82 void verifyGoogleFormat(llvm::StringRef Code) { 83 verifyFormat(Code, getGoogleStyle()); 84 } 85 86 void verifyIndependentOfContext(llvm::StringRef text) { 87 verifyFormat(text); 88 verifyFormat(llvm::Twine("void f() { " + text + " }").str()); 89 } 90 91 /// \brief Verify that clang-format does not crash on the given input. 92 void verifyNoCrash(llvm::StringRef Code, 93 const FormatStyle &Style = getLLVMStyle()) { 94 format(Code, Style, IC_DoNotCheck); 95 } 96 97 int ReplacementCount; 98 }; 99 100 TEST_F(FormatTest, MessUp) { 101 EXPECT_EQ("1 2 3", test::messUp("1 2 3")); 102 EXPECT_EQ("1 2 3\n", test::messUp("1\n2\n3\n")); 103 EXPECT_EQ("a\n//b\nc", test::messUp("a\n//b\nc")); 104 EXPECT_EQ("a\n#b\nc", test::messUp("a\n#b\nc")); 105 EXPECT_EQ("a\n#b c d\ne", test::messUp("a\n#b\\\nc\\\nd\ne")); 106 } 107 108 //===----------------------------------------------------------------------===// 109 // Basic function tests. 110 //===----------------------------------------------------------------------===// 111 112 TEST_F(FormatTest, DoesNotChangeCorrectlyFormattedCode) { 113 EXPECT_EQ(";", format(";")); 114 } 115 116 TEST_F(FormatTest, FormatsGlobalStatementsAt0) { 117 EXPECT_EQ("int i;", format(" int i;")); 118 EXPECT_EQ("\nint i;", format(" \n\t \v \f int i;")); 119 EXPECT_EQ("int i;\nint j;", format(" int i; int j;")); 120 EXPECT_EQ("int i;\nint j;", format(" int i;\n int j;")); 121 } 122 123 TEST_F(FormatTest, FormatsUnwrappedLinesAtFirstFormat) { 124 EXPECT_EQ("int i;", format("int\ni;")); 125 } 126 127 TEST_F(FormatTest, FormatsNestedBlockStatements) { 128 EXPECT_EQ("{\n {\n {}\n }\n}", format("{{{}}}")); 129 } 130 131 TEST_F(FormatTest, FormatsNestedCall) { 132 verifyFormat("Method(f1, f2(f3));"); 133 verifyFormat("Method(f1(f2, f3()));"); 134 verifyFormat("Method(f1(f2, (f3())));"); 135 } 136 137 TEST_F(FormatTest, NestedNameSpecifiers) { 138 verifyFormat("vector<::Type> v;"); 139 verifyFormat("::ns::SomeFunction(::ns::SomeOtherFunction())"); 140 verifyFormat("static constexpr bool Bar = decltype(bar())::value;"); 141 verifyFormat("bool a = 2 < ::SomeFunction();"); 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 EXPECT_EQ("/*\r\n" 158 "\r\n" 159 "*/\r\n", 160 format("/*\r\n" 161 "\r\n" 162 "*/\r\n")); 163 EXPECT_EQ(0, ReplacementCount); 164 } 165 166 TEST_F(FormatTest, RemovesEmptyLines) { 167 EXPECT_EQ("class C {\n" 168 " int i;\n" 169 "};", 170 format("class C {\n" 171 " int i;\n" 172 "\n" 173 "};")); 174 175 // Don't remove empty lines at the start of namespaces or extern "C" blocks. 176 EXPECT_EQ("namespace N {\n" 177 "\n" 178 "int i;\n" 179 "}", 180 format("namespace N {\n" 181 "\n" 182 "int i;\n" 183 "}", 184 getGoogleStyle())); 185 EXPECT_EQ("extern /**/ \"C\" /**/ {\n" 186 "\n" 187 "int i;\n" 188 "}", 189 format("extern /**/ \"C\" /**/ {\n" 190 "\n" 191 "int i;\n" 192 "}", 193 getGoogleStyle())); 194 195 // ...but do keep inlining and removing empty lines for non-block extern "C" 196 // functions. 197 verifyFormat("extern \"C\" int f() { return 42; }", getGoogleStyle()); 198 EXPECT_EQ("extern \"C\" int f() {\n" 199 " int i = 42;\n" 200 " return i;\n" 201 "}", 202 format("extern \"C\" int f() {\n" 203 "\n" 204 " int i = 42;\n" 205 " return i;\n" 206 "}", 207 getGoogleStyle())); 208 209 // Remove empty lines at the beginning and end of blocks. 210 EXPECT_EQ("void f() {\n" 211 "\n" 212 " if (a) {\n" 213 "\n" 214 " f();\n" 215 " }\n" 216 "}", 217 format("void f() {\n" 218 "\n" 219 " if (a) {\n" 220 "\n" 221 " f();\n" 222 "\n" 223 " }\n" 224 "\n" 225 "}", 226 getLLVMStyle())); 227 EXPECT_EQ("void f() {\n" 228 " if (a) {\n" 229 " f();\n" 230 " }\n" 231 "}", 232 format("void f() {\n" 233 "\n" 234 " if (a) {\n" 235 "\n" 236 " f();\n" 237 "\n" 238 " }\n" 239 "\n" 240 "}", 241 getGoogleStyle())); 242 243 // Don't remove empty lines in more complex control statements. 244 EXPECT_EQ("void f() {\n" 245 " if (a) {\n" 246 " f();\n" 247 "\n" 248 " } else if (b) {\n" 249 " f();\n" 250 " }\n" 251 "}", 252 format("void f() {\n" 253 " if (a) {\n" 254 " f();\n" 255 "\n" 256 " } else if (b) {\n" 257 " f();\n" 258 "\n" 259 " }\n" 260 "\n" 261 "}")); 262 263 // FIXME: This is slightly inconsistent. 264 EXPECT_EQ("namespace {\n" 265 "int i;\n" 266 "}", 267 format("namespace {\n" 268 "int i;\n" 269 "\n" 270 "}")); 271 EXPECT_EQ("namespace {\n" 272 "int i;\n" 273 "\n" 274 "} // namespace", 275 format("namespace {\n" 276 "int i;\n" 277 "\n" 278 "} // namespace")); 279 280 FormatStyle Style = getLLVMStyle(); 281 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 282 Style.MaxEmptyLinesToKeep = 2; 283 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 284 Style.BraceWrapping.AfterClass = true; 285 Style.BraceWrapping.AfterFunction = true; 286 Style.KeepEmptyLinesAtTheStartOfBlocks = false; 287 288 EXPECT_EQ("class Foo\n" 289 "{\n" 290 " Foo() {}\n" 291 "\n" 292 " void funk() {}\n" 293 "};", 294 format("class Foo\n" 295 "{\n" 296 " Foo()\n" 297 " {\n" 298 " }\n" 299 "\n" 300 " void funk() {}\n" 301 "};", 302 Style)); 303 } 304 305 TEST_F(FormatTest, RecognizesBinaryOperatorKeywords) { 306 verifyFormat("x = (a) and (b);"); 307 verifyFormat("x = (a) or (b);"); 308 verifyFormat("x = (a) bitand (b);"); 309 verifyFormat("x = (a) bitor (b);"); 310 verifyFormat("x = (a) not_eq (b);"); 311 verifyFormat("x = (a) and_eq (b);"); 312 verifyFormat("x = (a) or_eq (b);"); 313 verifyFormat("x = (a) xor (b);"); 314 } 315 316 //===----------------------------------------------------------------------===// 317 // Tests for control statements. 318 //===----------------------------------------------------------------------===// 319 320 TEST_F(FormatTest, FormatIfWithoutCompoundStatement) { 321 verifyFormat("if (true)\n f();\ng();"); 322 verifyFormat("if (a)\n if (b)\n if (c)\n g();\nh();"); 323 verifyFormat("if (a)\n if (b) {\n f();\n }\ng();"); 324 325 FormatStyle AllowsMergedIf = getLLVMStyle(); 326 AllowsMergedIf.AlignEscapedNewlinesLeft = true; 327 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = true; 328 verifyFormat("if (a)\n" 329 " // comment\n" 330 " f();", 331 AllowsMergedIf); 332 verifyFormat("{\n" 333 " if (a)\n" 334 " label:\n" 335 " f();\n" 336 "}", 337 AllowsMergedIf); 338 verifyFormat("#define A \\\n" 339 " if (a) \\\n" 340 " label: \\\n" 341 " f()", 342 AllowsMergedIf); 343 verifyFormat("if (a)\n" 344 " ;", 345 AllowsMergedIf); 346 verifyFormat("if (a)\n" 347 " if (b) return;", 348 AllowsMergedIf); 349 350 verifyFormat("if (a) // Can't merge this\n" 351 " f();\n", 352 AllowsMergedIf); 353 verifyFormat("if (a) /* still don't merge */\n" 354 " f();", 355 AllowsMergedIf); 356 verifyFormat("if (a) { // Never merge this\n" 357 " f();\n" 358 "}", 359 AllowsMergedIf); 360 verifyFormat("if (a) { /* Never merge this */\n" 361 " f();\n" 362 "}", 363 AllowsMergedIf); 364 365 AllowsMergedIf.ColumnLimit = 14; 366 verifyFormat("if (a) return;", AllowsMergedIf); 367 verifyFormat("if (aaaaaaaaa)\n" 368 " return;", 369 AllowsMergedIf); 370 371 AllowsMergedIf.ColumnLimit = 13; 372 verifyFormat("if (a)\n return;", AllowsMergedIf); 373 } 374 375 TEST_F(FormatTest, FormatLoopsWithoutCompoundStatement) { 376 FormatStyle AllowsMergedLoops = getLLVMStyle(); 377 AllowsMergedLoops.AllowShortLoopsOnASingleLine = true; 378 verifyFormat("while (true) continue;", AllowsMergedLoops); 379 verifyFormat("for (;;) continue;", AllowsMergedLoops); 380 verifyFormat("for (int &v : vec) v *= 2;", AllowsMergedLoops); 381 verifyFormat("while (true)\n" 382 " ;", 383 AllowsMergedLoops); 384 verifyFormat("for (;;)\n" 385 " ;", 386 AllowsMergedLoops); 387 verifyFormat("for (;;)\n" 388 " for (;;) continue;", 389 AllowsMergedLoops); 390 verifyFormat("for (;;) // Can't merge this\n" 391 " continue;", 392 AllowsMergedLoops); 393 verifyFormat("for (;;) /* still don't merge */\n" 394 " continue;", 395 AllowsMergedLoops); 396 } 397 398 TEST_F(FormatTest, FormatShortBracedStatements) { 399 FormatStyle AllowSimpleBracedStatements = getLLVMStyle(); 400 AllowSimpleBracedStatements.AllowShortBlocksOnASingleLine = true; 401 402 AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = true; 403 AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = true; 404 405 verifyFormat("if (true) {}", AllowSimpleBracedStatements); 406 verifyFormat("while (true) {}", AllowSimpleBracedStatements); 407 verifyFormat("for (;;) {}", AllowSimpleBracedStatements); 408 verifyFormat("if (true) { f(); }", AllowSimpleBracedStatements); 409 verifyFormat("while (true) { f(); }", AllowSimpleBracedStatements); 410 verifyFormat("for (;;) { f(); }", AllowSimpleBracedStatements); 411 verifyFormat("if (true) { //\n" 412 " f();\n" 413 "}", 414 AllowSimpleBracedStatements); 415 verifyFormat("if (true) {\n" 416 " f();\n" 417 " f();\n" 418 "}", 419 AllowSimpleBracedStatements); 420 verifyFormat("if (true) {\n" 421 " f();\n" 422 "} else {\n" 423 " f();\n" 424 "}", 425 AllowSimpleBracedStatements); 426 427 verifyFormat("template <int> struct A2 {\n" 428 " struct B {};\n" 429 "};", 430 AllowSimpleBracedStatements); 431 432 AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = false; 433 verifyFormat("if (true) {\n" 434 " f();\n" 435 "}", 436 AllowSimpleBracedStatements); 437 verifyFormat("if (true) {\n" 438 " f();\n" 439 "} else {\n" 440 " f();\n" 441 "}", 442 AllowSimpleBracedStatements); 443 444 AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = false; 445 verifyFormat("while (true) {\n" 446 " f();\n" 447 "}", 448 AllowSimpleBracedStatements); 449 verifyFormat("for (;;) {\n" 450 " f();\n" 451 "}", 452 AllowSimpleBracedStatements); 453 } 454 455 TEST_F(FormatTest, ParseIfElse) { 456 verifyFormat("if (true)\n" 457 " if (true)\n" 458 " if (true)\n" 459 " f();\n" 460 " else\n" 461 " g();\n" 462 " else\n" 463 " h();\n" 464 "else\n" 465 " i();"); 466 verifyFormat("if (true)\n" 467 " if (true)\n" 468 " if (true) {\n" 469 " if (true)\n" 470 " f();\n" 471 " } else {\n" 472 " g();\n" 473 " }\n" 474 " else\n" 475 " h();\n" 476 "else {\n" 477 " i();\n" 478 "}"); 479 verifyFormat("void f() {\n" 480 " if (a) {\n" 481 " } else {\n" 482 " }\n" 483 "}"); 484 } 485 486 TEST_F(FormatTest, ElseIf) { 487 verifyFormat("if (a) {\n} else if (b) {\n}"); 488 verifyFormat("if (a)\n" 489 " f();\n" 490 "else if (b)\n" 491 " g();\n" 492 "else\n" 493 " h();"); 494 verifyFormat("if (a) {\n" 495 " f();\n" 496 "}\n" 497 "// or else ..\n" 498 "else {\n" 499 " g()\n" 500 "}"); 501 502 verifyFormat("if (a) {\n" 503 "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 504 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n" 505 "}"); 506 verifyFormat("if (a) {\n" 507 "} else if (\n" 508 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 509 "}", 510 getLLVMStyleWithColumns(62)); 511 } 512 513 TEST_F(FormatTest, FormatsForLoop) { 514 verifyFormat( 515 "for (int VeryVeryLongLoopVariable = 0; VeryVeryLongLoopVariable < 10;\n" 516 " ++VeryVeryLongLoopVariable)\n" 517 " ;"); 518 verifyFormat("for (;;)\n" 519 " f();"); 520 verifyFormat("for (;;) {\n}"); 521 verifyFormat("for (;;) {\n" 522 " f();\n" 523 "}"); 524 verifyFormat("for (int i = 0; (i < 10); ++i) {\n}"); 525 526 verifyFormat( 527 "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n" 528 " E = UnwrappedLines.end();\n" 529 " I != E; ++I) {\n}"); 530 531 verifyFormat( 532 "for (MachineFun::iterator IIII = PrevIt, EEEE = F.end(); IIII != EEEE;\n" 533 " ++IIIII) {\n}"); 534 verifyFormat("for (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaa =\n" 535 " aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa;\n" 536 " aaaaaaaaaaa != aaaaaaaaaaaaaaaaaaa; ++aaaaaaaaaaa) {\n}"); 537 verifyFormat("for (llvm::ArrayRef<NamedDecl *>::iterator\n" 538 " I = FD->getDeclsInPrototypeScope().begin(),\n" 539 " E = FD->getDeclsInPrototypeScope().end();\n" 540 " I != E; ++I) {\n}"); 541 verifyFormat("for (SmallVectorImpl<TemplateIdAnnotationn *>::iterator\n" 542 " I = Container.begin(),\n" 543 " E = Container.end();\n" 544 " I != E; ++I) {\n}", 545 getLLVMStyleWithColumns(76)); 546 547 verifyFormat( 548 "for (aaaaaaaaaaaaaaaaa aaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n" 549 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa !=\n" 550 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 551 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 552 " ++aaaaaaaaaaa) {\n}"); 553 verifyFormat("for (int i = 0; i < aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 554 " bbbbbbbbbbbbbbbbbbbb < ccccccccccccccc;\n" 555 " ++i) {\n}"); 556 verifyFormat("for (int aaaaaaaaaaa = 1; aaaaaaaaaaa <= bbbbbbbbbbbbbbb;\n" 557 " aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n" 558 "}"); 559 verifyFormat("for (some_namespace::SomeIterator iter( // force break\n" 560 " aaaaaaaaaa);\n" 561 " iter; ++iter) {\n" 562 "}"); 563 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 564 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 565 " aaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbbbbbbb;\n" 566 " ++aaaaaaaaaaaaaaaaaaaaaaaaaaa) {"); 567 568 FormatStyle NoBinPacking = getLLVMStyle(); 569 NoBinPacking.BinPackParameters = false; 570 verifyFormat("for (int aaaaaaaaaaa = 1;\n" 571 " aaaaaaaaaaa <= aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa,\n" 572 " aaaaaaaaaaaaaaaa,\n" 573 " aaaaaaaaaaaaaaaa,\n" 574 " aaaaaaaaaaaaaaaa);\n" 575 " aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n" 576 "}", 577 NoBinPacking); 578 verifyFormat( 579 "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n" 580 " E = UnwrappedLines.end();\n" 581 " I != E;\n" 582 " ++I) {\n}", 583 NoBinPacking); 584 } 585 586 TEST_F(FormatTest, RangeBasedForLoops) { 587 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 588 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 589 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaa :\n" 590 " aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa, aaaaaaaaaaaaa)) {\n}"); 591 verifyFormat("for (const aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaa :\n" 592 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 593 verifyFormat("for (aaaaaaaaa aaaaaaaaaaaaaaaaaaaaa :\n" 594 " aaaaaaaaaaaa.aaaaaaaaaaaa().aaaaaaaaa().a()) {\n}"); 595 } 596 597 TEST_F(FormatTest, ForEachLoops) { 598 verifyFormat("void f() {\n" 599 " foreach (Item *item, itemlist) {}\n" 600 " Q_FOREACH (Item *item, itemlist) {}\n" 601 " BOOST_FOREACH (Item *item, itemlist) {}\n" 602 " UNKNOWN_FORACH(Item * item, itemlist) {}\n" 603 "}"); 604 605 // As function-like macros. 606 verifyFormat("#define foreach(x, y)\n" 607 "#define Q_FOREACH(x, y)\n" 608 "#define BOOST_FOREACH(x, y)\n" 609 "#define UNKNOWN_FOREACH(x, y)\n"); 610 611 // Not as function-like macros. 612 verifyFormat("#define foreach (x, y)\n" 613 "#define Q_FOREACH (x, y)\n" 614 "#define BOOST_FOREACH (x, y)\n" 615 "#define UNKNOWN_FOREACH (x, y)\n"); 616 } 617 618 TEST_F(FormatTest, FormatsWhileLoop) { 619 verifyFormat("while (true) {\n}"); 620 verifyFormat("while (true)\n" 621 " f();"); 622 verifyFormat("while () {\n}"); 623 verifyFormat("while () {\n" 624 " f();\n" 625 "}"); 626 } 627 628 TEST_F(FormatTest, FormatsDoWhile) { 629 verifyFormat("do {\n" 630 " do_something();\n" 631 "} while (something());"); 632 verifyFormat("do\n" 633 " do_something();\n" 634 "while (something());"); 635 } 636 637 TEST_F(FormatTest, FormatsSwitchStatement) { 638 verifyFormat("switch (x) {\n" 639 "case 1:\n" 640 " f();\n" 641 " break;\n" 642 "case kFoo:\n" 643 "case ns::kBar:\n" 644 "case kBaz:\n" 645 " break;\n" 646 "default:\n" 647 " g();\n" 648 " break;\n" 649 "}"); 650 verifyFormat("switch (x) {\n" 651 "case 1: {\n" 652 " f();\n" 653 " break;\n" 654 "}\n" 655 "case 2: {\n" 656 " break;\n" 657 "}\n" 658 "}"); 659 verifyFormat("switch (x) {\n" 660 "case 1: {\n" 661 " f();\n" 662 " {\n" 663 " g();\n" 664 " h();\n" 665 " }\n" 666 " break;\n" 667 "}\n" 668 "}"); 669 verifyFormat("switch (x) {\n" 670 "case 1: {\n" 671 " f();\n" 672 " if (foo) {\n" 673 " g();\n" 674 " h();\n" 675 " }\n" 676 " break;\n" 677 "}\n" 678 "}"); 679 verifyFormat("switch (x) {\n" 680 "case 1: {\n" 681 " f();\n" 682 " g();\n" 683 "} break;\n" 684 "}"); 685 verifyFormat("switch (test)\n" 686 " ;"); 687 verifyFormat("switch (x) {\n" 688 "default: {\n" 689 " // Do nothing.\n" 690 "}\n" 691 "}"); 692 verifyFormat("switch (x) {\n" 693 "// comment\n" 694 "// if 1, do f()\n" 695 "case 1:\n" 696 " f();\n" 697 "}"); 698 verifyFormat("switch (x) {\n" 699 "case 1:\n" 700 " // Do amazing stuff\n" 701 " {\n" 702 " f();\n" 703 " g();\n" 704 " }\n" 705 " break;\n" 706 "}"); 707 verifyFormat("#define A \\\n" 708 " switch (x) { \\\n" 709 " case a: \\\n" 710 " foo = b; \\\n" 711 " }", 712 getLLVMStyleWithColumns(20)); 713 verifyFormat("#define OPERATION_CASE(name) \\\n" 714 " case OP_name: \\\n" 715 " return operations::Operation##name\n", 716 getLLVMStyleWithColumns(40)); 717 verifyFormat("switch (x) {\n" 718 "case 1:;\n" 719 "default:;\n" 720 " int i;\n" 721 "}"); 722 723 verifyGoogleFormat("switch (x) {\n" 724 " case 1:\n" 725 " f();\n" 726 " break;\n" 727 " case kFoo:\n" 728 " case ns::kBar:\n" 729 " case kBaz:\n" 730 " break;\n" 731 " default:\n" 732 " g();\n" 733 " break;\n" 734 "}"); 735 verifyGoogleFormat("switch (x) {\n" 736 " case 1: {\n" 737 " f();\n" 738 " break;\n" 739 " }\n" 740 "}"); 741 verifyGoogleFormat("switch (test)\n" 742 " ;"); 743 744 verifyGoogleFormat("#define OPERATION_CASE(name) \\\n" 745 " case OP_name: \\\n" 746 " return operations::Operation##name\n"); 747 verifyGoogleFormat("Operation codeToOperation(OperationCode OpCode) {\n" 748 " // Get the correction operation class.\n" 749 " switch (OpCode) {\n" 750 " CASE(Add);\n" 751 " CASE(Subtract);\n" 752 " default:\n" 753 " return operations::Unknown;\n" 754 " }\n" 755 "#undef OPERATION_CASE\n" 756 "}"); 757 verifyFormat("DEBUG({\n" 758 " switch (x) {\n" 759 " case A:\n" 760 " f();\n" 761 " break;\n" 762 " // On B:\n" 763 " case B:\n" 764 " g();\n" 765 " break;\n" 766 " }\n" 767 "});"); 768 verifyFormat("switch (a) {\n" 769 "case (b):\n" 770 " return;\n" 771 "}"); 772 773 verifyFormat("switch (a) {\n" 774 "case some_namespace::\n" 775 " some_constant:\n" 776 " return;\n" 777 "}", 778 getLLVMStyleWithColumns(34)); 779 } 780 781 TEST_F(FormatTest, CaseRanges) { 782 verifyFormat("switch (x) {\n" 783 "case 'A' ... 'Z':\n" 784 "case 1 ... 5:\n" 785 "case a ... b:\n" 786 " break;\n" 787 "}"); 788 } 789 790 TEST_F(FormatTest, ShortCaseLabels) { 791 FormatStyle Style = getLLVMStyle(); 792 Style.AllowShortCaseLabelsOnASingleLine = true; 793 verifyFormat("switch (a) {\n" 794 "case 1: x = 1; break;\n" 795 "case 2: return;\n" 796 "case 3:\n" 797 "case 4:\n" 798 "case 5: return;\n" 799 "case 6: // comment\n" 800 " return;\n" 801 "case 7:\n" 802 " // comment\n" 803 " return;\n" 804 "case 8:\n" 805 " x = 8; // comment\n" 806 " break;\n" 807 "default: y = 1; break;\n" 808 "}", 809 Style); 810 verifyFormat("switch (a) {\n" 811 "#if FOO\n" 812 "case 0: return 0;\n" 813 "#endif\n" 814 "}", 815 Style); 816 verifyFormat("switch (a) {\n" 817 "case 1: {\n" 818 "}\n" 819 "case 2: {\n" 820 " return;\n" 821 "}\n" 822 "case 3: {\n" 823 " x = 1;\n" 824 " return;\n" 825 "}\n" 826 "case 4:\n" 827 " if (x)\n" 828 " return;\n" 829 "}", 830 Style); 831 Style.ColumnLimit = 21; 832 verifyFormat("switch (a) {\n" 833 "case 1: x = 1; break;\n" 834 "case 2: return;\n" 835 "case 3:\n" 836 "case 4:\n" 837 "case 5: return;\n" 838 "default:\n" 839 " y = 1;\n" 840 " break;\n" 841 "}", 842 Style); 843 } 844 845 TEST_F(FormatTest, FormatsLabels) { 846 verifyFormat("void f() {\n" 847 " some_code();\n" 848 "test_label:\n" 849 " some_other_code();\n" 850 " {\n" 851 " some_more_code();\n" 852 " another_label:\n" 853 " some_more_code();\n" 854 " }\n" 855 "}"); 856 verifyFormat("{\n" 857 " some_code();\n" 858 "test_label:\n" 859 " some_other_code();\n" 860 "}"); 861 verifyFormat("{\n" 862 " some_code();\n" 863 "test_label:;\n" 864 " int i = 0;\n" 865 "}"); 866 } 867 868 //===----------------------------------------------------------------------===// 869 // Tests for classes, namespaces, etc. 870 //===----------------------------------------------------------------------===// 871 872 TEST_F(FormatTest, DoesNotBreakSemiAfterClassDecl) { 873 verifyFormat("class A {};"); 874 } 875 876 TEST_F(FormatTest, UnderstandsAccessSpecifiers) { 877 verifyFormat("class A {\n" 878 "public:\n" 879 "public: // comment\n" 880 "protected:\n" 881 "private:\n" 882 " void f() {}\n" 883 "};"); 884 verifyGoogleFormat("class A {\n" 885 " public:\n" 886 " protected:\n" 887 " private:\n" 888 " void f() {}\n" 889 "};"); 890 verifyFormat("class A {\n" 891 "public slots:\n" 892 " void f1() {}\n" 893 "public Q_SLOTS:\n" 894 " void f2() {}\n" 895 "protected slots:\n" 896 " void f3() {}\n" 897 "protected Q_SLOTS:\n" 898 " void f4() {}\n" 899 "private slots:\n" 900 " void f5() {}\n" 901 "private Q_SLOTS:\n" 902 " void f6() {}\n" 903 "signals:\n" 904 " void g1();\n" 905 "Q_SIGNALS:\n" 906 " void g2();\n" 907 "};"); 908 909 // Don't interpret 'signals' the wrong way. 910 verifyFormat("signals.set();"); 911 verifyFormat("for (Signals signals : f()) {\n}"); 912 verifyFormat("{\n" 913 " signals.set(); // This needs indentation.\n" 914 "}"); 915 verifyFormat("void f() {\n" 916 "label:\n" 917 " signals.baz();\n" 918 "}"); 919 } 920 921 TEST_F(FormatTest, SeparatesLogicalBlocks) { 922 EXPECT_EQ("class A {\n" 923 "public:\n" 924 " void f();\n" 925 "\n" 926 "private:\n" 927 " void g() {}\n" 928 " // test\n" 929 "protected:\n" 930 " int h;\n" 931 "};", 932 format("class A {\n" 933 "public:\n" 934 "void f();\n" 935 "private:\n" 936 "void g() {}\n" 937 "// test\n" 938 "protected:\n" 939 "int h;\n" 940 "};")); 941 EXPECT_EQ("class A {\n" 942 "protected:\n" 943 "public:\n" 944 " void f();\n" 945 "};", 946 format("class A {\n" 947 "protected:\n" 948 "\n" 949 "public:\n" 950 "\n" 951 " void f();\n" 952 "};")); 953 954 // Even ensure proper spacing inside macros. 955 EXPECT_EQ("#define B \\\n" 956 " class A { \\\n" 957 " protected: \\\n" 958 " public: \\\n" 959 " void f(); \\\n" 960 " };", 961 format("#define B \\\n" 962 " class A { \\\n" 963 " protected: \\\n" 964 " \\\n" 965 " public: \\\n" 966 " \\\n" 967 " void f(); \\\n" 968 " };", 969 getGoogleStyle())); 970 // But don't remove empty lines after macros ending in access specifiers. 971 EXPECT_EQ("#define A private:\n" 972 "\n" 973 "int i;", 974 format("#define A private:\n" 975 "\n" 976 "int i;")); 977 } 978 979 TEST_F(FormatTest, FormatsClasses) { 980 verifyFormat("class A : public B {};"); 981 verifyFormat("class A : public ::B {};"); 982 983 verifyFormat( 984 "class AAAAAAAAAAAAAAAAAAAA : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n" 985 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};"); 986 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n" 987 " : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n" 988 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};"); 989 verifyFormat( 990 "class A : public B, public C, public D, public E, public F {};"); 991 verifyFormat("class AAAAAAAAAAAA : public B,\n" 992 " public C,\n" 993 " public D,\n" 994 " public E,\n" 995 " public F,\n" 996 " public G {};"); 997 998 verifyFormat("class\n" 999 " ReallyReallyLongClassName {\n" 1000 " int i;\n" 1001 "};", 1002 getLLVMStyleWithColumns(32)); 1003 verifyFormat("struct aaaaaaaaaaaaa : public aaaaaaaaaaaaaaaaaaa< // break\n" 1004 " aaaaaaaaaaaaaaaa> {};"); 1005 verifyFormat("struct aaaaaaaaaaaaaaaaaaaa\n" 1006 " : public aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaa,\n" 1007 " aaaaaaaaaaaaaaaaaaaaaa> {};"); 1008 verifyFormat("template <class R, class C>\n" 1009 "struct Aaaaaaaaaaaaaaaaa<R (C::*)(int) const>\n" 1010 " : Aaaaaaaaaaaaaaaaa<R (C::*)(int)> {};"); 1011 verifyFormat("class ::A::B {};"); 1012 } 1013 1014 TEST_F(FormatTest, FormatsVariableDeclarationsAfterStructOrClass) { 1015 verifyFormat("class A {\n} a, b;"); 1016 verifyFormat("struct A {\n} a, b;"); 1017 verifyFormat("union A {\n} a;"); 1018 } 1019 1020 TEST_F(FormatTest, FormatsEnum) { 1021 verifyFormat("enum {\n" 1022 " Zero,\n" 1023 " One = 1,\n" 1024 " Two = One + 1,\n" 1025 " Three = (One + Two),\n" 1026 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1027 " Five = (One, Two, Three, Four, 5)\n" 1028 "};"); 1029 verifyGoogleFormat("enum {\n" 1030 " Zero,\n" 1031 " One = 1,\n" 1032 " Two = One + 1,\n" 1033 " Three = (One + Two),\n" 1034 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1035 " Five = (One, Two, Three, Four, 5)\n" 1036 "};"); 1037 verifyFormat("enum Enum {};"); 1038 verifyFormat("enum {};"); 1039 verifyFormat("enum X E {} d;"); 1040 verifyFormat("enum __attribute__((...)) E {} d;"); 1041 verifyFormat("enum __declspec__((...)) E {} d;"); 1042 verifyFormat("enum {\n" 1043 " Bar = Foo<int, int>::value\n" 1044 "};", 1045 getLLVMStyleWithColumns(30)); 1046 1047 verifyFormat("enum ShortEnum { A, B, C };"); 1048 verifyGoogleFormat("enum ShortEnum { A, B, C };"); 1049 1050 EXPECT_EQ("enum KeepEmptyLines {\n" 1051 " ONE,\n" 1052 "\n" 1053 " TWO,\n" 1054 "\n" 1055 " THREE\n" 1056 "}", 1057 format("enum KeepEmptyLines {\n" 1058 " ONE,\n" 1059 "\n" 1060 " TWO,\n" 1061 "\n" 1062 "\n" 1063 " THREE\n" 1064 "}")); 1065 verifyFormat("enum E { // comment\n" 1066 " ONE,\n" 1067 " TWO\n" 1068 "};\n" 1069 "int i;"); 1070 // Not enums. 1071 verifyFormat("enum X f() {\n" 1072 " a();\n" 1073 " return 42;\n" 1074 "}"); 1075 verifyFormat("enum X Type::f() {\n" 1076 " a();\n" 1077 " return 42;\n" 1078 "}"); 1079 verifyFormat("enum ::X f() {\n" 1080 " a();\n" 1081 " return 42;\n" 1082 "}"); 1083 verifyFormat("enum ns::X f() {\n" 1084 " a();\n" 1085 " return 42;\n" 1086 "}"); 1087 } 1088 1089 TEST_F(FormatTest, FormatsEnumsWithErrors) { 1090 verifyFormat("enum Type {\n" 1091 " One = 0; // These semicolons should be commas.\n" 1092 " Two = 1;\n" 1093 "};"); 1094 verifyFormat("namespace n {\n" 1095 "enum Type {\n" 1096 " One,\n" 1097 " Two, // missing };\n" 1098 " int i;\n" 1099 "}\n" 1100 "void g() {}"); 1101 } 1102 1103 TEST_F(FormatTest, FormatsEnumStruct) { 1104 verifyFormat("enum struct {\n" 1105 " Zero,\n" 1106 " One = 1,\n" 1107 " Two = One + 1,\n" 1108 " Three = (One + Two),\n" 1109 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1110 " Five = (One, Two, Three, Four, 5)\n" 1111 "};"); 1112 verifyFormat("enum struct Enum {};"); 1113 verifyFormat("enum struct {};"); 1114 verifyFormat("enum struct X E {} d;"); 1115 verifyFormat("enum struct __attribute__((...)) E {} d;"); 1116 verifyFormat("enum struct __declspec__((...)) E {} d;"); 1117 verifyFormat("enum struct X f() {\n a();\n return 42;\n}"); 1118 } 1119 1120 TEST_F(FormatTest, FormatsEnumClass) { 1121 verifyFormat("enum class {\n" 1122 " Zero,\n" 1123 " One = 1,\n" 1124 " Two = One + 1,\n" 1125 " Three = (One + Two),\n" 1126 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1127 " Five = (One, Two, Three, Four, 5)\n" 1128 "};"); 1129 verifyFormat("enum class Enum {};"); 1130 verifyFormat("enum class {};"); 1131 verifyFormat("enum class X E {} d;"); 1132 verifyFormat("enum class __attribute__((...)) E {} d;"); 1133 verifyFormat("enum class __declspec__((...)) E {} d;"); 1134 verifyFormat("enum class X f() {\n a();\n return 42;\n}"); 1135 } 1136 1137 TEST_F(FormatTest, FormatsEnumTypes) { 1138 verifyFormat("enum X : int {\n" 1139 " A, // Force multiple lines.\n" 1140 " B\n" 1141 "};"); 1142 verifyFormat("enum X : int { A, B };"); 1143 verifyFormat("enum X : std::uint32_t { A, B };"); 1144 } 1145 1146 TEST_F(FormatTest, FormatsNSEnums) { 1147 verifyGoogleFormat("typedef NS_ENUM(NSInteger, SomeName) { AAA, BBB }"); 1148 verifyGoogleFormat("typedef NS_ENUM(NSInteger, MyType) {\n" 1149 " // Information about someDecentlyLongValue.\n" 1150 " someDecentlyLongValue,\n" 1151 " // Information about anotherDecentlyLongValue.\n" 1152 " anotherDecentlyLongValue,\n" 1153 " // Information about aThirdDecentlyLongValue.\n" 1154 " aThirdDecentlyLongValue\n" 1155 "};"); 1156 verifyGoogleFormat("typedef NS_OPTIONS(NSInteger, MyType) {\n" 1157 " a = 1,\n" 1158 " b = 2,\n" 1159 " c = 3,\n" 1160 "};"); 1161 verifyGoogleFormat("typedef CF_ENUM(NSInteger, MyType) {\n" 1162 " a = 1,\n" 1163 " b = 2,\n" 1164 " c = 3,\n" 1165 "};"); 1166 verifyGoogleFormat("typedef CF_OPTIONS(NSInteger, MyType) {\n" 1167 " a = 1,\n" 1168 " b = 2,\n" 1169 " c = 3,\n" 1170 "};"); 1171 } 1172 1173 TEST_F(FormatTest, FormatsBitfields) { 1174 verifyFormat("struct Bitfields {\n" 1175 " unsigned sClass : 8;\n" 1176 " unsigned ValueKind : 2;\n" 1177 "};"); 1178 verifyFormat("struct A {\n" 1179 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa : 1,\n" 1180 " bbbbbbbbbbbbbbbbbbbbbbbbb;\n" 1181 "};"); 1182 verifyFormat("struct MyStruct {\n" 1183 " uchar data;\n" 1184 " uchar : 8;\n" 1185 " uchar : 8;\n" 1186 " uchar other;\n" 1187 "};"); 1188 } 1189 1190 TEST_F(FormatTest, FormatsNamespaces) { 1191 verifyFormat("namespace some_namespace {\n" 1192 "class A {};\n" 1193 "void f() { f(); }\n" 1194 "}"); 1195 verifyFormat("namespace {\n" 1196 "class A {};\n" 1197 "void f() { f(); }\n" 1198 "}"); 1199 verifyFormat("inline namespace X {\n" 1200 "class A {};\n" 1201 "void f() { f(); }\n" 1202 "}"); 1203 verifyFormat("using namespace some_namespace;\n" 1204 "class A {};\n" 1205 "void f() { f(); }"); 1206 1207 // This code is more common than we thought; if we 1208 // layout this correctly the semicolon will go into 1209 // its own line, which is undesirable. 1210 verifyFormat("namespace {};"); 1211 verifyFormat("namespace {\n" 1212 "class A {};\n" 1213 "};"); 1214 1215 verifyFormat("namespace {\n" 1216 "int SomeVariable = 0; // comment\n" 1217 "} // namespace"); 1218 EXPECT_EQ("#ifndef HEADER_GUARD\n" 1219 "#define HEADER_GUARD\n" 1220 "namespace my_namespace {\n" 1221 "int i;\n" 1222 "} // my_namespace\n" 1223 "#endif // HEADER_GUARD", 1224 format("#ifndef HEADER_GUARD\n" 1225 " #define HEADER_GUARD\n" 1226 " namespace my_namespace {\n" 1227 "int i;\n" 1228 "} // my_namespace\n" 1229 "#endif // HEADER_GUARD")); 1230 1231 EXPECT_EQ("namespace A::B {\n" 1232 "class C {};\n" 1233 "}", 1234 format("namespace A::B {\n" 1235 "class C {};\n" 1236 "}")); 1237 1238 FormatStyle Style = getLLVMStyle(); 1239 Style.NamespaceIndentation = FormatStyle::NI_All; 1240 EXPECT_EQ("namespace out {\n" 1241 " int i;\n" 1242 " namespace in {\n" 1243 " int i;\n" 1244 " } // namespace\n" 1245 "} // namespace", 1246 format("namespace out {\n" 1247 "int i;\n" 1248 "namespace in {\n" 1249 "int i;\n" 1250 "} // namespace\n" 1251 "} // namespace", 1252 Style)); 1253 1254 Style.NamespaceIndentation = FormatStyle::NI_Inner; 1255 EXPECT_EQ("namespace out {\n" 1256 "int i;\n" 1257 "namespace in {\n" 1258 " int i;\n" 1259 "} // namespace\n" 1260 "} // namespace", 1261 format("namespace out {\n" 1262 "int i;\n" 1263 "namespace in {\n" 1264 "int i;\n" 1265 "} // namespace\n" 1266 "} // namespace", 1267 Style)); 1268 } 1269 1270 TEST_F(FormatTest, FormatsExternC) { verifyFormat("extern \"C\" {\nint a;"); } 1271 1272 TEST_F(FormatTest, FormatsInlineASM) { 1273 verifyFormat("asm(\"xyz\" : \"=a\"(a), \"=d\"(b) : \"a\"(data));"); 1274 verifyFormat("asm(\"nop\" ::: \"memory\");"); 1275 verifyFormat( 1276 "asm(\"movq\\t%%rbx, %%rsi\\n\\t\"\n" 1277 " \"cpuid\\n\\t\"\n" 1278 " \"xchgq\\t%%rbx, %%rsi\\n\\t\"\n" 1279 " : \"=a\"(*rEAX), \"=S\"(*rEBX), \"=c\"(*rECX), \"=d\"(*rEDX)\n" 1280 " : \"a\"(value));"); 1281 EXPECT_EQ( 1282 "void NS_InvokeByIndex(void *that, unsigned int methodIndex) {\n" 1283 " __asm {\n" 1284 " mov edx,[that] // vtable in edx\n" 1285 " mov eax,methodIndex\n" 1286 " call [edx][eax*4] // stdcall\n" 1287 " }\n" 1288 "}", 1289 format("void NS_InvokeByIndex(void *that, unsigned int methodIndex) {\n" 1290 " __asm {\n" 1291 " mov edx,[that] // vtable in edx\n" 1292 " mov eax,methodIndex\n" 1293 " call [edx][eax*4] // stdcall\n" 1294 " }\n" 1295 "}")); 1296 EXPECT_EQ("_asm {\n" 1297 " xor eax, eax;\n" 1298 " cpuid;\n" 1299 "}", 1300 format("_asm {\n" 1301 " xor eax, eax;\n" 1302 " cpuid;\n" 1303 "}")); 1304 verifyFormat("void function() {\n" 1305 " // comment\n" 1306 " asm(\"\");\n" 1307 "}"); 1308 EXPECT_EQ("__asm {\n" 1309 "}\n" 1310 "int i;", 1311 format("__asm {\n" 1312 "}\n" 1313 "int i;")); 1314 } 1315 1316 TEST_F(FormatTest, FormatTryCatch) { 1317 verifyFormat("try {\n" 1318 " throw a * b;\n" 1319 "} catch (int a) {\n" 1320 " // Do nothing.\n" 1321 "} catch (...) {\n" 1322 " exit(42);\n" 1323 "}"); 1324 1325 // Function-level try statements. 1326 verifyFormat("int f() try { return 4; } catch (...) {\n" 1327 " return 5;\n" 1328 "}"); 1329 verifyFormat("class A {\n" 1330 " int a;\n" 1331 " A() try : a(0) {\n" 1332 " } catch (...) {\n" 1333 " throw;\n" 1334 " }\n" 1335 "};\n"); 1336 1337 // Incomplete try-catch blocks. 1338 verifyIncompleteFormat("try {} catch ("); 1339 } 1340 1341 TEST_F(FormatTest, FormatSEHTryCatch) { 1342 verifyFormat("__try {\n" 1343 " int a = b * c;\n" 1344 "} __except (EXCEPTION_EXECUTE_HANDLER) {\n" 1345 " // Do nothing.\n" 1346 "}"); 1347 1348 verifyFormat("__try {\n" 1349 " int a = b * c;\n" 1350 "} __finally {\n" 1351 " // Do nothing.\n" 1352 "}"); 1353 1354 verifyFormat("DEBUG({\n" 1355 " __try {\n" 1356 " } __finally {\n" 1357 " }\n" 1358 "});\n"); 1359 } 1360 1361 TEST_F(FormatTest, IncompleteTryCatchBlocks) { 1362 verifyFormat("try {\n" 1363 " f();\n" 1364 "} catch {\n" 1365 " g();\n" 1366 "}"); 1367 verifyFormat("try {\n" 1368 " f();\n" 1369 "} catch (A a) MACRO(x) {\n" 1370 " g();\n" 1371 "} catch (B b) MACRO(x) {\n" 1372 " g();\n" 1373 "}"); 1374 } 1375 1376 TEST_F(FormatTest, FormatTryCatchBraceStyles) { 1377 FormatStyle Style = getLLVMStyle(); 1378 for (auto BraceStyle : {FormatStyle::BS_Attach, FormatStyle::BS_Mozilla, 1379 FormatStyle::BS_WebKit}) { 1380 Style.BreakBeforeBraces = BraceStyle; 1381 verifyFormat("try {\n" 1382 " // something\n" 1383 "} catch (...) {\n" 1384 " // something\n" 1385 "}", 1386 Style); 1387 } 1388 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 1389 verifyFormat("try {\n" 1390 " // something\n" 1391 "}\n" 1392 "catch (...) {\n" 1393 " // something\n" 1394 "}", 1395 Style); 1396 verifyFormat("__try {\n" 1397 " // something\n" 1398 "}\n" 1399 "__finally {\n" 1400 " // something\n" 1401 "}", 1402 Style); 1403 verifyFormat("@try {\n" 1404 " // something\n" 1405 "}\n" 1406 "@finally {\n" 1407 " // something\n" 1408 "}", 1409 Style); 1410 Style.BreakBeforeBraces = FormatStyle::BS_Allman; 1411 verifyFormat("try\n" 1412 "{\n" 1413 " // something\n" 1414 "}\n" 1415 "catch (...)\n" 1416 "{\n" 1417 " // something\n" 1418 "}", 1419 Style); 1420 Style.BreakBeforeBraces = FormatStyle::BS_GNU; 1421 verifyFormat("try\n" 1422 " {\n" 1423 " // something\n" 1424 " }\n" 1425 "catch (...)\n" 1426 " {\n" 1427 " // something\n" 1428 " }", 1429 Style); 1430 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 1431 Style.BraceWrapping.BeforeCatch = true; 1432 verifyFormat("try {\n" 1433 " // something\n" 1434 "}\n" 1435 "catch (...) {\n" 1436 " // something\n" 1437 "}", 1438 Style); 1439 } 1440 1441 TEST_F(FormatTest, StaticInitializers) { 1442 verifyFormat("static SomeClass SC = {1, 'a'};"); 1443 1444 verifyFormat("static SomeClass WithALoooooooooooooooooooongName = {\n" 1445 " 100000000, " 1446 "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"};"); 1447 1448 // Here, everything other than the "}" would fit on a line. 1449 verifyFormat("static int LooooooooooooooooooooooooongVariable[1] = {\n" 1450 " 10000000000000000000000000};"); 1451 EXPECT_EQ("S s = {a,\n" 1452 "\n" 1453 " b};", 1454 format("S s = {\n" 1455 " a,\n" 1456 "\n" 1457 " b\n" 1458 "};")); 1459 1460 // FIXME: This would fit into the column limit if we'd fit "{ {" on the first 1461 // line. However, the formatting looks a bit off and this probably doesn't 1462 // happen often in practice. 1463 verifyFormat("static int Variable[1] = {\n" 1464 " {1000000000000000000000000000000000000}};", 1465 getLLVMStyleWithColumns(40)); 1466 } 1467 1468 TEST_F(FormatTest, DesignatedInitializers) { 1469 verifyFormat("const struct A a = {.a = 1, .b = 2};"); 1470 verifyFormat("const struct A a = {.aaaaaaaaaa = 1,\n" 1471 " .bbbbbbbbbb = 2,\n" 1472 " .cccccccccc = 3,\n" 1473 " .dddddddddd = 4,\n" 1474 " .eeeeeeeeee = 5};"); 1475 verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n" 1476 " .aaaaaaaaaaaaaaaaaaaaaaaaaaa = 1,\n" 1477 " .bbbbbbbbbbbbbbbbbbbbbbbbbbb = 2,\n" 1478 " .ccccccccccccccccccccccccccc = 3,\n" 1479 " .ddddddddddddddddddddddddddd = 4,\n" 1480 " .eeeeeeeeeeeeeeeeeeeeeeeeeee = 5};"); 1481 1482 verifyGoogleFormat("const struct A a = {.a = 1, .b = 2};"); 1483 } 1484 1485 TEST_F(FormatTest, NestedStaticInitializers) { 1486 verifyFormat("static A x = {{{}}};\n"); 1487 verifyFormat("static A x = {{{init1, init2, init3, init4},\n" 1488 " {init1, init2, init3, init4}}};", 1489 getLLVMStyleWithColumns(50)); 1490 1491 verifyFormat("somes Status::global_reps[3] = {\n" 1492 " {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n" 1493 " {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n" 1494 " {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};", 1495 getLLVMStyleWithColumns(60)); 1496 verifyGoogleFormat("SomeType Status::global_reps[3] = {\n" 1497 " {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n" 1498 " {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n" 1499 " {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};"); 1500 verifyFormat("CGRect cg_rect = {{rect.fLeft, rect.fTop},\n" 1501 " {rect.fRight - rect.fLeft, rect.fBottom - " 1502 "rect.fTop}};"); 1503 1504 verifyFormat( 1505 "SomeArrayOfSomeType a = {\n" 1506 " {{1, 2, 3},\n" 1507 " {1, 2, 3},\n" 1508 " {111111111111111111111111111111, 222222222222222222222222222222,\n" 1509 " 333333333333333333333333333333},\n" 1510 " {1, 2, 3},\n" 1511 " {1, 2, 3}}};"); 1512 verifyFormat( 1513 "SomeArrayOfSomeType a = {\n" 1514 " {{1, 2, 3}},\n" 1515 " {{1, 2, 3}},\n" 1516 " {{111111111111111111111111111111, 222222222222222222222222222222,\n" 1517 " 333333333333333333333333333333}},\n" 1518 " {{1, 2, 3}},\n" 1519 " {{1, 2, 3}}};"); 1520 1521 verifyFormat("struct {\n" 1522 " unsigned bit;\n" 1523 " const char *const name;\n" 1524 "} kBitsToOs[] = {{kOsMac, \"Mac\"},\n" 1525 " {kOsWin, \"Windows\"},\n" 1526 " {kOsLinux, \"Linux\"},\n" 1527 " {kOsCrOS, \"Chrome OS\"}};"); 1528 verifyFormat("struct {\n" 1529 " unsigned bit;\n" 1530 " const char *const name;\n" 1531 "} kBitsToOs[] = {\n" 1532 " {kOsMac, \"Mac\"},\n" 1533 " {kOsWin, \"Windows\"},\n" 1534 " {kOsLinux, \"Linux\"},\n" 1535 " {kOsCrOS, \"Chrome OS\"},\n" 1536 "};"); 1537 } 1538 1539 TEST_F(FormatTest, FormatsSmallMacroDefinitionsInSingleLine) { 1540 verifyFormat("#define ALooooooooooooooooooooooooooooooooooooooongMacro(" 1541 " \\\n" 1542 " aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)"); 1543 } 1544 1545 TEST_F(FormatTest, DoesNotBreakPureVirtualFunctionDefinition) { 1546 verifyFormat("virtual void write(ELFWriter *writerrr,\n" 1547 " OwningPtr<FileOutputBuffer> &buffer) = 0;"); 1548 1549 // Do break defaulted and deleted functions. 1550 verifyFormat("virtual void ~Deeeeeeeestructor() =\n" 1551 " default;", 1552 getLLVMStyleWithColumns(40)); 1553 verifyFormat("virtual void ~Deeeeeeeestructor() =\n" 1554 " delete;", 1555 getLLVMStyleWithColumns(40)); 1556 } 1557 1558 TEST_F(FormatTest, BreaksStringLiteralsOnlyInDefine) { 1559 verifyFormat("# 1111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\" 2 3", 1560 getLLVMStyleWithColumns(40)); 1561 verifyFormat("#line 11111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"", 1562 getLLVMStyleWithColumns(40)); 1563 EXPECT_EQ("#define Q \\\n" 1564 " \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/\" \\\n" 1565 " \"aaaaaaaa.cpp\"", 1566 format("#define Q \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"", 1567 getLLVMStyleWithColumns(40))); 1568 } 1569 1570 TEST_F(FormatTest, UnderstandsLinePPDirective) { 1571 EXPECT_EQ("# 123 \"A string literal\"", 1572 format(" # 123 \"A string literal\"")); 1573 } 1574 1575 TEST_F(FormatTest, LayoutUnknownPPDirective) { 1576 EXPECT_EQ("#;", format("#;")); 1577 verifyFormat("#\n;\n;\n;"); 1578 } 1579 1580 TEST_F(FormatTest, UnescapedEndOfLineEndsPPDirective) { 1581 EXPECT_EQ("#line 42 \"test\"\n", 1582 format("# \\\n line \\\n 42 \\\n \"test\"\n")); 1583 EXPECT_EQ("#define A B\n", format("# \\\n define \\\n A \\\n B\n", 1584 getLLVMStyleWithColumns(12))); 1585 } 1586 1587 TEST_F(FormatTest, EndOfFileEndsPPDirective) { 1588 EXPECT_EQ("#line 42 \"test\"", 1589 format("# \\\n line \\\n 42 \\\n \"test\"")); 1590 EXPECT_EQ("#define A B", format("# \\\n define \\\n A \\\n B")); 1591 } 1592 1593 TEST_F(FormatTest, DoesntRemoveUnknownTokens) { 1594 verifyFormat("#define A \\x20"); 1595 verifyFormat("#define A \\ x20"); 1596 EXPECT_EQ("#define A \\ x20", format("#define A \\ x20")); 1597 verifyFormat("#define A ''"); 1598 verifyFormat("#define A ''qqq"); 1599 verifyFormat("#define A `qqq"); 1600 verifyFormat("f(\"aaaa, bbbb, \"\\\"ccccc\\\"\");"); 1601 EXPECT_EQ("const char *c = STRINGIFY(\n" 1602 "\\na : b);", 1603 format("const char * c = STRINGIFY(\n" 1604 "\\na : b);")); 1605 1606 verifyFormat("a\r\\"); 1607 verifyFormat("a\v\\"); 1608 verifyFormat("a\f\\"); 1609 } 1610 1611 TEST_F(FormatTest, IndentsPPDirectiveInReducedSpace) { 1612 verifyFormat("#define A(BB)", getLLVMStyleWithColumns(13)); 1613 verifyFormat("#define A( \\\n BB)", getLLVMStyleWithColumns(12)); 1614 verifyFormat("#define A( \\\n A, B)", getLLVMStyleWithColumns(12)); 1615 // FIXME: We never break before the macro name. 1616 verifyFormat("#define AA( \\\n B)", getLLVMStyleWithColumns(12)); 1617 1618 verifyFormat("#define A A\n#define A A"); 1619 verifyFormat("#define A(X) A\n#define A A"); 1620 1621 verifyFormat("#define Something Other", getLLVMStyleWithColumns(23)); 1622 verifyFormat("#define Something \\\n Other", getLLVMStyleWithColumns(22)); 1623 } 1624 1625 TEST_F(FormatTest, HandlePreprocessorDirectiveContext) { 1626 EXPECT_EQ("// somecomment\n" 1627 "#include \"a.h\"\n" 1628 "#define A( \\\n" 1629 " A, B)\n" 1630 "#include \"b.h\"\n" 1631 "// somecomment\n", 1632 format(" // somecomment\n" 1633 " #include \"a.h\"\n" 1634 "#define A(A,\\\n" 1635 " B)\n" 1636 " #include \"b.h\"\n" 1637 " // somecomment\n", 1638 getLLVMStyleWithColumns(13))); 1639 } 1640 1641 TEST_F(FormatTest, LayoutSingleHash) { EXPECT_EQ("#\na;", format("#\na;")); } 1642 1643 TEST_F(FormatTest, LayoutCodeInMacroDefinitions) { 1644 EXPECT_EQ("#define A \\\n" 1645 " c; \\\n" 1646 " e;\n" 1647 "f;", 1648 format("#define A c; e;\n" 1649 "f;", 1650 getLLVMStyleWithColumns(14))); 1651 } 1652 1653 TEST_F(FormatTest, LayoutRemainingTokens) { EXPECT_EQ("{}", format("{}")); } 1654 1655 TEST_F(FormatTest, MacroDefinitionInsideStatement) { 1656 EXPECT_EQ("int x,\n" 1657 "#define A\n" 1658 " y;", 1659 format("int x,\n#define A\ny;")); 1660 } 1661 1662 TEST_F(FormatTest, HashInMacroDefinition) { 1663 EXPECT_EQ("#define A(c) L#c", format("#define A(c) L#c", getLLVMStyle())); 1664 verifyFormat("#define A \\\n b #c;", getLLVMStyleWithColumns(11)); 1665 verifyFormat("#define A \\\n" 1666 " { \\\n" 1667 " f(#c); \\\n" 1668 " }", 1669 getLLVMStyleWithColumns(11)); 1670 1671 verifyFormat("#define A(X) \\\n" 1672 " void function##X()", 1673 getLLVMStyleWithColumns(22)); 1674 1675 verifyFormat("#define A(a, b, c) \\\n" 1676 " void a##b##c()", 1677 getLLVMStyleWithColumns(22)); 1678 1679 verifyFormat("#define A void # ## #", getLLVMStyleWithColumns(22)); 1680 } 1681 1682 TEST_F(FormatTest, RespectWhitespaceInMacroDefinitions) { 1683 EXPECT_EQ("#define A (x)", format("#define A (x)")); 1684 EXPECT_EQ("#define A(x)", format("#define A(x)")); 1685 } 1686 1687 TEST_F(FormatTest, EmptyLinesInMacroDefinitions) { 1688 EXPECT_EQ("#define A b;", format("#define A \\\n" 1689 " \\\n" 1690 " b;", 1691 getLLVMStyleWithColumns(25))); 1692 EXPECT_EQ("#define A \\\n" 1693 " \\\n" 1694 " a; \\\n" 1695 " b;", 1696 format("#define A \\\n" 1697 " \\\n" 1698 " a; \\\n" 1699 " b;", 1700 getLLVMStyleWithColumns(11))); 1701 EXPECT_EQ("#define A \\\n" 1702 " a; \\\n" 1703 " \\\n" 1704 " b;", 1705 format("#define A \\\n" 1706 " a; \\\n" 1707 " \\\n" 1708 " b;", 1709 getLLVMStyleWithColumns(11))); 1710 } 1711 1712 TEST_F(FormatTest, MacroDefinitionsWithIncompleteCode) { 1713 verifyIncompleteFormat("#define A :"); 1714 verifyFormat("#define SOMECASES \\\n" 1715 " case 1: \\\n" 1716 " case 2\n", 1717 getLLVMStyleWithColumns(20)); 1718 verifyFormat("#define MACRO(a) \\\n" 1719 " if (a) \\\n" 1720 " f(); \\\n" 1721 " else \\\n" 1722 " g()", 1723 getLLVMStyleWithColumns(18)); 1724 verifyFormat("#define A template <typename T>"); 1725 verifyIncompleteFormat("#define STR(x) #x\n" 1726 "f(STR(this_is_a_string_literal{));"); 1727 verifyFormat("#pragma omp threadprivate( \\\n" 1728 " y)), // expected-warning", 1729 getLLVMStyleWithColumns(28)); 1730 verifyFormat("#d, = };"); 1731 verifyFormat("#if \"a"); 1732 verifyIncompleteFormat("({\n" 1733 "#define b \\\n" 1734 " } \\\n" 1735 " a\n" 1736 "a", 1737 getLLVMStyleWithColumns(15)); 1738 verifyFormat("#define A \\\n" 1739 " { \\\n" 1740 " {\n" 1741 "#define B \\\n" 1742 " } \\\n" 1743 " }", 1744 getLLVMStyleWithColumns(15)); 1745 verifyNoCrash("#if a\na(\n#else\n#endif\n{a"); 1746 verifyNoCrash("a={0,1\n#if a\n#else\n;\n#endif\n}"); 1747 verifyNoCrash("#if a\na(\n#else\n#endif\n) a {a,b,c,d,f,g};"); 1748 verifyNoCrash("#ifdef A\n a(\n #else\n #endif\n) = []() { \n)}"); 1749 } 1750 1751 TEST_F(FormatTest, MacrosWithoutTrailingSemicolon) { 1752 verifyFormat("SOME_TYPE_NAME abc;"); // Gated on the newline. 1753 EXPECT_EQ("class A : public QObject {\n" 1754 " Q_OBJECT\n" 1755 "\n" 1756 " A() {}\n" 1757 "};", 1758 format("class A : public QObject {\n" 1759 " Q_OBJECT\n" 1760 "\n" 1761 " A() {\n}\n" 1762 "} ;")); 1763 EXPECT_EQ("MACRO\n" 1764 "/*static*/ int i;", 1765 format("MACRO\n" 1766 " /*static*/ int i;")); 1767 EXPECT_EQ("SOME_MACRO\n" 1768 "namespace {\n" 1769 "void f();\n" 1770 "}", 1771 format("SOME_MACRO\n" 1772 " namespace {\n" 1773 "void f( );\n" 1774 "}")); 1775 // Only if the identifier contains at least 5 characters. 1776 EXPECT_EQ("HTTP f();", format("HTTP\nf();")); 1777 EXPECT_EQ("MACRO\nf();", format("MACRO\nf();")); 1778 // Only if everything is upper case. 1779 EXPECT_EQ("class A : public QObject {\n" 1780 " Q_Object A() {}\n" 1781 "};", 1782 format("class A : public QObject {\n" 1783 " Q_Object\n" 1784 " A() {\n}\n" 1785 "} ;")); 1786 1787 // Only if the next line can actually start an unwrapped line. 1788 EXPECT_EQ("SOME_WEIRD_LOG_MACRO << SomeThing;", 1789 format("SOME_WEIRD_LOG_MACRO\n" 1790 "<< SomeThing;")); 1791 1792 verifyFormat("VISIT_GL_CALL(GenBuffers, void, (GLsizei n, GLuint* buffers), " 1793 "(n, buffers))\n", 1794 getChromiumStyle(FormatStyle::LK_Cpp)); 1795 } 1796 1797 TEST_F(FormatTest, MacroCallsWithoutTrailingSemicolon) { 1798 EXPECT_EQ("INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n" 1799 "INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n" 1800 "INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n" 1801 "class X {};\n" 1802 "INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n" 1803 "int *createScopDetectionPass() { return 0; }", 1804 format(" INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n" 1805 " INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n" 1806 " INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n" 1807 " class X {};\n" 1808 " INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n" 1809 " int *createScopDetectionPass() { return 0; }")); 1810 // FIXME: We could probably treat IPC_BEGIN_MESSAGE_MAP/IPC_END_MESSAGE_MAP as 1811 // braces, so that inner block is indented one level more. 1812 EXPECT_EQ("int q() {\n" 1813 " IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n" 1814 " IPC_MESSAGE_HANDLER(xxx, qqq)\n" 1815 " IPC_END_MESSAGE_MAP()\n" 1816 "}", 1817 format("int q() {\n" 1818 " IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n" 1819 " IPC_MESSAGE_HANDLER(xxx, qqq)\n" 1820 " IPC_END_MESSAGE_MAP()\n" 1821 "}")); 1822 1823 // Same inside macros. 1824 EXPECT_EQ("#define LIST(L) \\\n" 1825 " L(A) \\\n" 1826 " L(B) \\\n" 1827 " L(C)", 1828 format("#define LIST(L) \\\n" 1829 " L(A) \\\n" 1830 " L(B) \\\n" 1831 " L(C)", 1832 getGoogleStyle())); 1833 1834 // These must not be recognized as macros. 1835 EXPECT_EQ("int q() {\n" 1836 " f(x);\n" 1837 " f(x) {}\n" 1838 " f(x)->g();\n" 1839 " f(x)->*g();\n" 1840 " f(x).g();\n" 1841 " f(x) = x;\n" 1842 " f(x) += x;\n" 1843 " f(x) -= x;\n" 1844 " f(x) *= x;\n" 1845 " f(x) /= x;\n" 1846 " f(x) %= x;\n" 1847 " f(x) &= x;\n" 1848 " f(x) |= x;\n" 1849 " f(x) ^= x;\n" 1850 " f(x) >>= x;\n" 1851 " f(x) <<= x;\n" 1852 " f(x)[y].z();\n" 1853 " LOG(INFO) << x;\n" 1854 " ifstream(x) >> x;\n" 1855 "}\n", 1856 format("int q() {\n" 1857 " f(x)\n;\n" 1858 " f(x)\n {}\n" 1859 " f(x)\n->g();\n" 1860 " f(x)\n->*g();\n" 1861 " f(x)\n.g();\n" 1862 " f(x)\n = x;\n" 1863 " f(x)\n += x;\n" 1864 " f(x)\n -= x;\n" 1865 " f(x)\n *= x;\n" 1866 " f(x)\n /= x;\n" 1867 " f(x)\n %= x;\n" 1868 " f(x)\n &= x;\n" 1869 " f(x)\n |= x;\n" 1870 " f(x)\n ^= x;\n" 1871 " f(x)\n >>= x;\n" 1872 " f(x)\n <<= x;\n" 1873 " f(x)\n[y].z();\n" 1874 " LOG(INFO)\n << x;\n" 1875 " ifstream(x)\n >> x;\n" 1876 "}\n")); 1877 EXPECT_EQ("int q() {\n" 1878 " F(x)\n" 1879 " if (1) {\n" 1880 " }\n" 1881 " F(x)\n" 1882 " while (1) {\n" 1883 " }\n" 1884 " F(x)\n" 1885 " G(x);\n" 1886 " F(x)\n" 1887 " try {\n" 1888 " Q();\n" 1889 " } catch (...) {\n" 1890 " }\n" 1891 "}\n", 1892 format("int q() {\n" 1893 "F(x)\n" 1894 "if (1) {}\n" 1895 "F(x)\n" 1896 "while (1) {}\n" 1897 "F(x)\n" 1898 "G(x);\n" 1899 "F(x)\n" 1900 "try { Q(); } catch (...) {}\n" 1901 "}\n")); 1902 EXPECT_EQ("class A {\n" 1903 " A() : t(0) {}\n" 1904 " A(int i) noexcept() : {}\n" 1905 " A(X x)\n" // FIXME: function-level try blocks are broken. 1906 " try : t(0) {\n" 1907 " } catch (...) {\n" 1908 " }\n" 1909 "};", 1910 format("class A {\n" 1911 " A()\n : t(0) {}\n" 1912 " A(int i)\n noexcept() : {}\n" 1913 " A(X x)\n" 1914 " try : t(0) {} catch (...) {}\n" 1915 "};")); 1916 EXPECT_EQ("class SomeClass {\n" 1917 "public:\n" 1918 " SomeClass() EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 1919 "};", 1920 format("class SomeClass {\n" 1921 "public:\n" 1922 " SomeClass()\n" 1923 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 1924 "};")); 1925 EXPECT_EQ("class SomeClass {\n" 1926 "public:\n" 1927 " SomeClass()\n" 1928 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 1929 "};", 1930 format("class SomeClass {\n" 1931 "public:\n" 1932 " SomeClass()\n" 1933 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 1934 "};", 1935 getLLVMStyleWithColumns(40))); 1936 1937 verifyFormat("MACRO(>)"); 1938 } 1939 1940 TEST_F(FormatTest, LayoutMacroDefinitionsStatementsSpanningBlocks) { 1941 verifyFormat("#define A \\\n" 1942 " f({ \\\n" 1943 " g(); \\\n" 1944 " });", 1945 getLLVMStyleWithColumns(11)); 1946 } 1947 1948 TEST_F(FormatTest, IndentPreprocessorDirectivesAtZero) { 1949 EXPECT_EQ("{\n {\n#define A\n }\n}", format("{{\n#define A\n}}")); 1950 } 1951 1952 TEST_F(FormatTest, FormatHashIfNotAtStartOfLine) { 1953 verifyFormat("{\n { a #c; }\n}"); 1954 } 1955 1956 TEST_F(FormatTest, FormatUnbalancedStructuralElements) { 1957 EXPECT_EQ("#define A \\\n { \\\n {\nint i;", 1958 format("#define A { {\nint i;", getLLVMStyleWithColumns(11))); 1959 EXPECT_EQ("#define A \\\n } \\\n }\nint i;", 1960 format("#define A } }\nint i;", getLLVMStyleWithColumns(11))); 1961 } 1962 1963 TEST_F(FormatTest, EscapedNewlines) { 1964 EXPECT_EQ( 1965 "#define A \\\n int i; \\\n int j;", 1966 format("#define A \\\nint i;\\\n int j;", getLLVMStyleWithColumns(11))); 1967 EXPECT_EQ("#define A\n\nint i;", format("#define A \\\n\n int i;")); 1968 EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();")); 1969 EXPECT_EQ("/* \\ \\ \\\n*/", format("\\\n/* \\ \\ \\\n*/")); 1970 EXPECT_EQ("<a\n\\\\\n>", format("<a\n\\\\\n>")); 1971 } 1972 1973 TEST_F(FormatTest, CalculateSpaceOnConsecutiveLinesInMacro) { 1974 verifyFormat("#define A \\\n" 1975 " int v( \\\n" 1976 " a); \\\n" 1977 " int i;", 1978 getLLVMStyleWithColumns(11)); 1979 } 1980 1981 TEST_F(FormatTest, MixingPreprocessorDirectivesAndNormalCode) { 1982 EXPECT_EQ( 1983 "#define ALooooooooooooooooooooooooooooooooooooooongMacro(" 1984 " \\\n" 1985 " aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n" 1986 "\n" 1987 "AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n" 1988 " aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n", 1989 format(" #define ALooooooooooooooooooooooooooooooooooooooongMacro(" 1990 "\\\n" 1991 "aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n" 1992 " \n" 1993 " AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n" 1994 " aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n")); 1995 } 1996 1997 TEST_F(FormatTest, LayoutStatementsAroundPreprocessorDirectives) { 1998 EXPECT_EQ("int\n" 1999 "#define A\n" 2000 " a;", 2001 format("int\n#define A\na;")); 2002 verifyFormat("functionCallTo(\n" 2003 " someOtherFunction(\n" 2004 " withSomeParameters, whichInSequence,\n" 2005 " areLongerThanALine(andAnotherCall,\n" 2006 "#define A B\n" 2007 " withMoreParamters,\n" 2008 " whichStronglyInfluenceTheLayout),\n" 2009 " andMoreParameters),\n" 2010 " trailing);", 2011 getLLVMStyleWithColumns(69)); 2012 verifyFormat("Foo::Foo()\n" 2013 "#ifdef BAR\n" 2014 " : baz(0)\n" 2015 "#endif\n" 2016 "{\n" 2017 "}"); 2018 verifyFormat("void f() {\n" 2019 " if (true)\n" 2020 "#ifdef A\n" 2021 " f(42);\n" 2022 " x();\n" 2023 "#else\n" 2024 " g();\n" 2025 " x();\n" 2026 "#endif\n" 2027 "}"); 2028 verifyFormat("void f(param1, param2,\n" 2029 " param3,\n" 2030 "#ifdef A\n" 2031 " param4(param5,\n" 2032 "#ifdef A1\n" 2033 " param6,\n" 2034 "#ifdef A2\n" 2035 " param7),\n" 2036 "#else\n" 2037 " param8),\n" 2038 " param9,\n" 2039 "#endif\n" 2040 " param10,\n" 2041 "#endif\n" 2042 " param11)\n" 2043 "#else\n" 2044 " param12)\n" 2045 "#endif\n" 2046 "{\n" 2047 " x();\n" 2048 "}", 2049 getLLVMStyleWithColumns(28)); 2050 verifyFormat("#if 1\n" 2051 "int i;"); 2052 verifyFormat("#if 1\n" 2053 "#endif\n" 2054 "#if 1\n" 2055 "#else\n" 2056 "#endif\n"); 2057 verifyFormat("DEBUG({\n" 2058 " return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 2059 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n" 2060 "});\n" 2061 "#if a\n" 2062 "#else\n" 2063 "#endif"); 2064 2065 verifyIncompleteFormat("void f(\n" 2066 "#if A\n" 2067 " );\n" 2068 "#else\n" 2069 "#endif"); 2070 } 2071 2072 TEST_F(FormatTest, GraciouslyHandleIncorrectPreprocessorConditions) { 2073 verifyFormat("#endif\n" 2074 "#if B"); 2075 } 2076 2077 TEST_F(FormatTest, FormatsJoinedLinesOnSubsequentRuns) { 2078 FormatStyle SingleLine = getLLVMStyle(); 2079 SingleLine.AllowShortIfStatementsOnASingleLine = true; 2080 verifyFormat("#if 0\n" 2081 "#elif 1\n" 2082 "#endif\n" 2083 "void foo() {\n" 2084 " if (test) foo2();\n" 2085 "}", 2086 SingleLine); 2087 } 2088 2089 TEST_F(FormatTest, LayoutBlockInsideParens) { 2090 verifyFormat("functionCall({ int i; });"); 2091 verifyFormat("functionCall({\n" 2092 " int i;\n" 2093 " int j;\n" 2094 "});"); 2095 verifyFormat("functionCall(\n" 2096 " {\n" 2097 " int i;\n" 2098 " int j;\n" 2099 " },\n" 2100 " aaaa, bbbb, cccc);"); 2101 verifyFormat("functionA(functionB({\n" 2102 " int i;\n" 2103 " int j;\n" 2104 " }),\n" 2105 " aaaa, bbbb, cccc);"); 2106 verifyFormat("functionCall(\n" 2107 " {\n" 2108 " int i;\n" 2109 " int j;\n" 2110 " },\n" 2111 " aaaa, bbbb, // comment\n" 2112 " cccc);"); 2113 verifyFormat("functionA(functionB({\n" 2114 " int i;\n" 2115 " int j;\n" 2116 " }),\n" 2117 " aaaa, bbbb, // comment\n" 2118 " cccc);"); 2119 verifyFormat("functionCall(aaaa, bbbb, { int i; });"); 2120 verifyFormat("functionCall(aaaa, bbbb, {\n" 2121 " int i;\n" 2122 " int j;\n" 2123 "});"); 2124 verifyFormat( 2125 "Aaa(\n" // FIXME: There shouldn't be a linebreak here. 2126 " {\n" 2127 " int i; // break\n" 2128 " },\n" 2129 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" 2130 " ccccccccccccccccc));"); 2131 verifyFormat("DEBUG({\n" 2132 " if (a)\n" 2133 " f();\n" 2134 "});"); 2135 } 2136 2137 TEST_F(FormatTest, LayoutBlockInsideStatement) { 2138 EXPECT_EQ("SOME_MACRO { int i; }\n" 2139 "int i;", 2140 format(" SOME_MACRO {int i;} int i;")); 2141 } 2142 2143 TEST_F(FormatTest, LayoutNestedBlocks) { 2144 verifyFormat("void AddOsStrings(unsigned bitmask) {\n" 2145 " struct s {\n" 2146 " int i;\n" 2147 " };\n" 2148 " s kBitsToOs[] = {{10}};\n" 2149 " for (int i = 0; i < 10; ++i)\n" 2150 " return;\n" 2151 "}"); 2152 verifyFormat("call(parameter, {\n" 2153 " something();\n" 2154 " // Comment using all columns.\n" 2155 " somethingelse();\n" 2156 "});", 2157 getLLVMStyleWithColumns(40)); 2158 verifyFormat("DEBUG( //\n" 2159 " { f(); }, a);"); 2160 verifyFormat("DEBUG( //\n" 2161 " {\n" 2162 " f(); //\n" 2163 " },\n" 2164 " a);"); 2165 2166 EXPECT_EQ("call(parameter, {\n" 2167 " something();\n" 2168 " // Comment too\n" 2169 " // looooooooooong.\n" 2170 " somethingElse();\n" 2171 "});", 2172 format("call(parameter, {\n" 2173 " something();\n" 2174 " // Comment too looooooooooong.\n" 2175 " somethingElse();\n" 2176 "});", 2177 getLLVMStyleWithColumns(29))); 2178 EXPECT_EQ("DEBUG({ int i; });", format("DEBUG({ int i; });")); 2179 EXPECT_EQ("DEBUG({ // comment\n" 2180 " int i;\n" 2181 "});", 2182 format("DEBUG({ // comment\n" 2183 "int i;\n" 2184 "});")); 2185 EXPECT_EQ("DEBUG({\n" 2186 " int i;\n" 2187 "\n" 2188 " // comment\n" 2189 " int j;\n" 2190 "});", 2191 format("DEBUG({\n" 2192 " int i;\n" 2193 "\n" 2194 " // comment\n" 2195 " int j;\n" 2196 "});")); 2197 2198 verifyFormat("DEBUG({\n" 2199 " if (a)\n" 2200 " return;\n" 2201 "});"); 2202 verifyGoogleFormat("DEBUG({\n" 2203 " if (a) return;\n" 2204 "});"); 2205 FormatStyle Style = getGoogleStyle(); 2206 Style.ColumnLimit = 45; 2207 verifyFormat("Debug(aaaaa,\n" 2208 " {\n" 2209 " if (aaaaaaaaaaaaaaaaaaaaaaaa) return;\n" 2210 " },\n" 2211 " a);", 2212 Style); 2213 2214 verifyFormat("SomeFunction({MACRO({ return output; }), b});"); 2215 2216 verifyNoCrash("^{v^{a}}"); 2217 } 2218 2219 TEST_F(FormatTest, FormatNestedBlocksInMacros) { 2220 EXPECT_EQ("#define MACRO() \\\n" 2221 " Debug(aaa, /* force line break */ \\\n" 2222 " { \\\n" 2223 " int i; \\\n" 2224 " int j; \\\n" 2225 " })", 2226 format("#define MACRO() Debug(aaa, /* force line break */ \\\n" 2227 " { int i; int j; })", 2228 getGoogleStyle())); 2229 2230 EXPECT_EQ("#define A \\\n" 2231 " [] { \\\n" 2232 " xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n" 2233 " xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); \\\n" 2234 " }", 2235 format("#define A [] { xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n" 2236 "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); }", 2237 getGoogleStyle())); 2238 } 2239 2240 TEST_F(FormatTest, PutEmptyBlocksIntoOneLine) { 2241 EXPECT_EQ("{}", format("{}")); 2242 verifyFormat("enum E {};"); 2243 verifyFormat("enum E {}"); 2244 } 2245 2246 TEST_F(FormatTest, FormatBeginBlockEndMacros) { 2247 FormatStyle Style = getLLVMStyle(); 2248 Style.MacroBlockBegin = "^[A-Z_]+_BEGIN$"; 2249 Style.MacroBlockEnd = "^[A-Z_]+_END$"; 2250 verifyFormat("FOO_BEGIN\n" 2251 " FOO_ENTRY\n" 2252 "FOO_END", Style); 2253 verifyFormat("FOO_BEGIN\n" 2254 " NESTED_FOO_BEGIN\n" 2255 " NESTED_FOO_ENTRY\n" 2256 " NESTED_FOO_END\n" 2257 "FOO_END", Style); 2258 verifyFormat("FOO_BEGIN(Foo, Bar)\n" 2259 " int x;\n" 2260 " x = 1;\n" 2261 "FOO_END(Baz)", Style); 2262 } 2263 2264 //===----------------------------------------------------------------------===// 2265 // Line break tests. 2266 //===----------------------------------------------------------------------===// 2267 2268 TEST_F(FormatTest, PreventConfusingIndents) { 2269 verifyFormat( 2270 "void f() {\n" 2271 " SomeLongMethodName(SomeReallyLongMethod(CallOtherReallyLongMethod(\n" 2272 " parameter, parameter, parameter)),\n" 2273 " SecondLongCall(parameter));\n" 2274 "}"); 2275 verifyFormat( 2276 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 2277 " aaaaaaaaaaaaaaaaaaaaaaaa(\n" 2278 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 2279 " aaaaaaaaaaaaaaaaaaaaaaaa);"); 2280 verifyFormat( 2281 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2282 " [aaaaaaaaaaaaaaaaaaaaaaaa\n" 2283 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n" 2284 " [aaaaaaaaaaaaaaaaaaaaaaaa]];"); 2285 verifyFormat( 2286 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n" 2287 " aaaaaaaaaaaaaaaaaaaaaaaa<\n" 2288 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>,\n" 2289 " aaaaaaaaaaaaaaaaaaaaaaaa>;"); 2290 verifyFormat("int a = bbbb && ccc &&\n" 2291 " fffff(\n" 2292 "#define A Just forcing a new line\n" 2293 " ddd);"); 2294 } 2295 2296 TEST_F(FormatTest, LineBreakingInBinaryExpressions) { 2297 verifyFormat( 2298 "bool aaaaaaa =\n" 2299 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() ||\n" 2300 " bbbbbbbb();"); 2301 verifyFormat( 2302 "bool aaaaaaa =\n" 2303 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() or\n" 2304 " bbbbbbbb();"); 2305 2306 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n" 2307 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb &&\n" 2308 " ccccccccc == ddddddddddd;"); 2309 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n" 2310 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb and\n" 2311 " ccccccccc == ddddddddddd;"); 2312 verifyFormat( 2313 "bool aaaaaaaaaaaaaaaaaaaaa =\n" 2314 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa not_eq bbbbbbbbbbbbbbbbbb and\n" 2315 " ccccccccc == ddddddddddd;"); 2316 2317 verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n" 2318 " aaaaaa) &&\n" 2319 " bbbbbb && cccccc;"); 2320 verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n" 2321 " aaaaaa) >>\n" 2322 " bbbbbb;"); 2323 verifyFormat("aa = Whitespaces.addUntouchableComment(\n" 2324 " SourceMgr.getSpellingColumnNumber(\n" 2325 " TheLine.Last->FormatTok.Tok.getLocation()) -\n" 2326 " 1);"); 2327 2328 verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 2329 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaaaaaaa\n" 2330 " cccccc) {\n}"); 2331 verifyFormat("b = a &&\n" 2332 " // Comment\n" 2333 " b.c && d;"); 2334 2335 // If the LHS of a comparison is not a binary expression itself, the 2336 // additional linebreak confuses many people. 2337 verifyFormat( 2338 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 2339 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) > 5) {\n" 2340 "}"); 2341 verifyFormat( 2342 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 2343 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n" 2344 "}"); 2345 verifyFormat( 2346 "if (aaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaa(\n" 2347 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n" 2348 "}"); 2349 // Even explicit parentheses stress the precedence enough to make the 2350 // additional break unnecessary. 2351 verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 2352 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n" 2353 "}"); 2354 // This cases is borderline, but with the indentation it is still readable. 2355 verifyFormat( 2356 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 2357 " aaaaaaaaaaaaaaa) > aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 2358 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 2359 "}", 2360 getLLVMStyleWithColumns(75)); 2361 2362 // If the LHS is a binary expression, we should still use the additional break 2363 // as otherwise the formatting hides the operator precedence. 2364 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 2365 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 2366 " 5) {\n" 2367 "}"); 2368 2369 FormatStyle OnePerLine = getLLVMStyle(); 2370 OnePerLine.BinPackParameters = false; 2371 verifyFormat( 2372 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 2373 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 2374 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}", 2375 OnePerLine); 2376 2377 verifyFormat("int i = someFunction(aaaaaaa, 0)\n" 2378 " .aaa(aaaaaaaaaaaaa) *\n" 2379 " aaaaaaa +\n" 2380 " aaaaaaa;", 2381 getLLVMStyleWithColumns(40)); 2382 } 2383 2384 TEST_F(FormatTest, ExpressionIndentation) { 2385 verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 2386 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 2387 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 2388 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 2389 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb +\n" 2390 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb &&\n" 2391 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 2392 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >\n" 2393 " ccccccccccccccccccccccccccccccccccccccccc;"); 2394 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 2395 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 2396 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 2397 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); 2398 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 2399 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 2400 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 2401 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); 2402 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 2403 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 2404 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 2405 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); 2406 verifyFormat("if () {\n" 2407 "} else if (aaaaa && bbbbb > // break\n" 2408 " ccccc) {\n" 2409 "}"); 2410 verifyFormat("if () {\n" 2411 "} else if (aaaaa &&\n" 2412 " bbbbb > // break\n" 2413 " ccccc &&\n" 2414 " ddddd) {\n" 2415 "}"); 2416 2417 // Presence of a trailing comment used to change indentation of b. 2418 verifyFormat("return aaaaaaaaaaaaaaaaaaa +\n" 2419 " b;\n" 2420 "return aaaaaaaaaaaaaaaaaaa +\n" 2421 " b; //", 2422 getLLVMStyleWithColumns(30)); 2423 } 2424 2425 TEST_F(FormatTest, ExpressionIndentationBreakingBeforeOperators) { 2426 // Not sure what the best system is here. Like this, the LHS can be found 2427 // immediately above an operator (everything with the same or a higher 2428 // indent). The RHS is aligned right of the operator and so compasses 2429 // everything until something with the same indent as the operator is found. 2430 // FIXME: Is this a good system? 2431 FormatStyle Style = getLLVMStyle(); 2432 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 2433 verifyFormat( 2434 "bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2435 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2436 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2437 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2438 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 2439 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 2440 " && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2441 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2442 " > ccccccccccccccccccccccccccccccccccccccccc;", 2443 Style); 2444 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2445 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2446 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2447 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 2448 Style); 2449 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2450 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2451 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2452 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 2453 Style); 2454 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2455 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2456 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2457 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 2458 Style); 2459 verifyFormat("if () {\n" 2460 "} else if (aaaaa\n" 2461 " && bbbbb // break\n" 2462 " > ccccc) {\n" 2463 "}", 2464 Style); 2465 verifyFormat("return (a)\n" 2466 " // comment\n" 2467 " + b;", 2468 Style); 2469 verifyFormat( 2470 "int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2471 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 2472 " + cc;", 2473 Style); 2474 2475 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2476 " = aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 2477 Style); 2478 2479 // Forced by comments. 2480 verifyFormat( 2481 "unsigned ContentSize =\n" 2482 " sizeof(int16_t) // DWARF ARange version number\n" 2483 " + sizeof(int32_t) // Offset of CU in the .debug_info section\n" 2484 " + sizeof(int8_t) // Pointer Size (in bytes)\n" 2485 " + sizeof(int8_t); // Segment Size (in bytes)"); 2486 2487 verifyFormat("return boost::fusion::at_c<0>(iiii).second\n" 2488 " == boost::fusion::at_c<1>(iiii).second;", 2489 Style); 2490 2491 Style.ColumnLimit = 60; 2492 verifyFormat("zzzzzzzzzz\n" 2493 " = bbbbbbbbbbbbbbbbb\n" 2494 " >> aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa);", 2495 Style); 2496 } 2497 2498 TEST_F(FormatTest, EnforcedOperatorWraps) { 2499 // Here we'd like to wrap after the || operators, but a comment is forcing an 2500 // earlier wrap. 2501 verifyFormat("bool x = aaaaa //\n" 2502 " || bbbbb\n" 2503 " //\n" 2504 " || cccc;"); 2505 } 2506 2507 TEST_F(FormatTest, NoOperandAlignment) { 2508 FormatStyle Style = getLLVMStyle(); 2509 Style.AlignOperands = false; 2510 verifyFormat("aaaaaaaaaaaaaa(aaaaaaaaaaaa,\n" 2511 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 2512 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 2513 Style); 2514 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment; 2515 verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2516 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2517 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2518 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2519 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 2520 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 2521 " && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2522 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2523 " > ccccccccccccccccccccccccccccccccccccccccc;", 2524 Style); 2525 2526 verifyFormat("int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2527 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 2528 " + cc;", 2529 Style); 2530 verifyFormat("int a = aa\n" 2531 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 2532 " * cccccccccccccccccccccccccccccccccccc;\n", 2533 Style); 2534 2535 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 2536 verifyFormat("return (a > b\n" 2537 " // comment1\n" 2538 " // comment2\n" 2539 " || c);", 2540 Style); 2541 } 2542 2543 TEST_F(FormatTest, BreakingBeforeNonAssigmentOperators) { 2544 FormatStyle Style = getLLVMStyle(); 2545 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment; 2546 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 2547 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2548 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;", 2549 Style); 2550 } 2551 2552 TEST_F(FormatTest, ConstructorInitializers) { 2553 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}"); 2554 verifyFormat("Constructor() : Inttializer(FitsOnTheLine) {}", 2555 getLLVMStyleWithColumns(45)); 2556 verifyFormat("Constructor()\n" 2557 " : Inttializer(FitsOnTheLine) {}", 2558 getLLVMStyleWithColumns(44)); 2559 verifyFormat("Constructor()\n" 2560 " : Inttializer(FitsOnTheLine) {}", 2561 getLLVMStyleWithColumns(43)); 2562 2563 verifyFormat("template <typename T>\n" 2564 "Constructor() : Initializer(FitsOnTheLine) {}", 2565 getLLVMStyleWithColumns(45)); 2566 2567 verifyFormat( 2568 "SomeClass::Constructor()\n" 2569 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}"); 2570 2571 verifyFormat( 2572 "SomeClass::Constructor()\n" 2573 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 2574 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}"); 2575 verifyFormat( 2576 "SomeClass::Constructor()\n" 2577 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 2578 " aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}"); 2579 verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 2580 " aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 2581 " : aaaaaaaaaa(aaaaaa) {}"); 2582 2583 verifyFormat("Constructor()\n" 2584 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 2585 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 2586 " aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 2587 " aaaaaaaaaaaaaaaaaaaaaaa() {}"); 2588 2589 verifyFormat("Constructor()\n" 2590 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 2591 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); 2592 2593 verifyFormat("Constructor(int Parameter = 0)\n" 2594 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n" 2595 " aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}"); 2596 verifyFormat("Constructor()\n" 2597 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n" 2598 "}", 2599 getLLVMStyleWithColumns(60)); 2600 verifyFormat("Constructor()\n" 2601 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 2602 " aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}"); 2603 2604 // Here a line could be saved by splitting the second initializer onto two 2605 // lines, but that is not desirable. 2606 verifyFormat("Constructor()\n" 2607 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n" 2608 " aaaaaaaaaaa(aaaaaaaaaaa),\n" 2609 " aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); 2610 2611 FormatStyle OnePerLine = getLLVMStyle(); 2612 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 2613 OnePerLine.AllowAllParametersOfDeclarationOnNextLine = false; 2614 verifyFormat("SomeClass::Constructor()\n" 2615 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 2616 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 2617 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 2618 OnePerLine); 2619 verifyFormat("SomeClass::Constructor()\n" 2620 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n" 2621 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 2622 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 2623 OnePerLine); 2624 verifyFormat("MyClass::MyClass(int var)\n" 2625 " : some_var_(var), // 4 space indent\n" 2626 " some_other_var_(var + 1) { // lined up\n" 2627 "}", 2628 OnePerLine); 2629 verifyFormat("Constructor()\n" 2630 " : aaaaa(aaaaaa),\n" 2631 " aaaaa(aaaaaa),\n" 2632 " aaaaa(aaaaaa),\n" 2633 " aaaaa(aaaaaa),\n" 2634 " aaaaa(aaaaaa) {}", 2635 OnePerLine); 2636 verifyFormat("Constructor()\n" 2637 " : aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n" 2638 " aaaaaaaaaaaaaaaaaaaaaa) {}", 2639 OnePerLine); 2640 OnePerLine.BinPackParameters = false; 2641 verifyFormat( 2642 "Constructor()\n" 2643 " : aaaaaaaaaaaaaaaaaaaaaaaa(\n" 2644 " aaaaaaaaaaa().aaa(),\n" 2645 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 2646 OnePerLine); 2647 OnePerLine.ColumnLimit = 60; 2648 verifyFormat("Constructor()\n" 2649 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 2650 " bbbbbbbbbbbbbbbbbbbbbbbb(b) {}", 2651 OnePerLine); 2652 2653 EXPECT_EQ("Constructor()\n" 2654 " : // Comment forcing unwanted break.\n" 2655 " aaaa(aaaa) {}", 2656 format("Constructor() :\n" 2657 " // Comment forcing unwanted break.\n" 2658 " aaaa(aaaa) {}")); 2659 } 2660 2661 TEST_F(FormatTest, MemoizationTests) { 2662 // This breaks if the memoization lookup does not take \c Indent and 2663 // \c LastSpace into account. 2664 verifyFormat( 2665 "extern CFRunLoopTimerRef\n" 2666 "CFRunLoopTimerCreate(CFAllocatorRef allocato, CFAbsoluteTime fireDate,\n" 2667 " CFTimeInterval interval, CFOptionFlags flags,\n" 2668 " CFIndex order, CFRunLoopTimerCallBack callout,\n" 2669 " CFRunLoopTimerContext *context) {}"); 2670 2671 // Deep nesting somewhat works around our memoization. 2672 verifyFormat( 2673 "aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 2674 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 2675 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 2676 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 2677 " aaaaa())))))))))))))))))))))))))))))))))))))));", 2678 getLLVMStyleWithColumns(65)); 2679 verifyFormat( 2680 "aaaaa(\n" 2681 " aaaaa,\n" 2682 " aaaaa(\n" 2683 " aaaaa,\n" 2684 " aaaaa(\n" 2685 " aaaaa,\n" 2686 " aaaaa(\n" 2687 " aaaaa,\n" 2688 " aaaaa(\n" 2689 " aaaaa,\n" 2690 " aaaaa(\n" 2691 " aaaaa,\n" 2692 " aaaaa(\n" 2693 " aaaaa,\n" 2694 " aaaaa(\n" 2695 " aaaaa,\n" 2696 " aaaaa(\n" 2697 " aaaaa,\n" 2698 " aaaaa(\n" 2699 " aaaaa,\n" 2700 " aaaaa(\n" 2701 " aaaaa,\n" 2702 " aaaaa(\n" 2703 " aaaaa,\n" 2704 " aaaaa))))))))))));", 2705 getLLVMStyleWithColumns(65)); 2706 verifyFormat( 2707 "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" 2708 " a),\n" 2709 " a),\n" 2710 " a),\n" 2711 " a),\n" 2712 " a),\n" 2713 " a),\n" 2714 " a),\n" 2715 " a),\n" 2716 " a),\n" 2717 " a),\n" 2718 " a),\n" 2719 " a),\n" 2720 " a),\n" 2721 " a),\n" 2722 " a),\n" 2723 " a),\n" 2724 " a)", 2725 getLLVMStyleWithColumns(65)); 2726 2727 // This test takes VERY long when memoization is broken. 2728 FormatStyle OnePerLine = getLLVMStyle(); 2729 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 2730 OnePerLine.BinPackParameters = false; 2731 std::string input = "Constructor()\n" 2732 " : aaaa(a,\n"; 2733 for (unsigned i = 0, e = 80; i != e; ++i) { 2734 input += " a,\n"; 2735 } 2736 input += " a) {}"; 2737 verifyFormat(input, OnePerLine); 2738 } 2739 2740 TEST_F(FormatTest, BreaksAsHighAsPossible) { 2741 verifyFormat( 2742 "void f() {\n" 2743 " if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaaaaaaaa) ||\n" 2744 " (bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb && bbbbbbbbbbbbbbbbbbbbbbbbbb))\n" 2745 " f();\n" 2746 "}"); 2747 verifyFormat("if (Intervals[i].getRange().getFirst() <\n" 2748 " Intervals[i - 1].getRange().getLast()) {\n}"); 2749 } 2750 2751 TEST_F(FormatTest, BreaksFunctionDeclarations) { 2752 // Principially, we break function declarations in a certain order: 2753 // 1) break amongst arguments. 2754 verifyFormat("Aaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccc,\n" 2755 " Cccccccccccccc cccccccccccccc);"); 2756 verifyFormat("template <class TemplateIt>\n" 2757 "SomeReturnType SomeFunction(TemplateIt begin, TemplateIt end,\n" 2758 " TemplateIt *stop) {}"); 2759 2760 // 2) break after return type. 2761 verifyFormat( 2762 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2763 "bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccccccccccccccc);", 2764 getGoogleStyle()); 2765 2766 // 3) break after (. 2767 verifyFormat( 2768 "Aaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbb(\n" 2769 " Cccccccccccccccccccccccccccccc cccccccccccccccccccccccccccccccc);", 2770 getGoogleStyle()); 2771 2772 // 4) break before after nested name specifiers. 2773 verifyFormat( 2774 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2775 "SomeClasssssssssssssssssssssssssssssssssssssss::\n" 2776 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc);", 2777 getGoogleStyle()); 2778 2779 // However, there are exceptions, if a sufficient amount of lines can be 2780 // saved. 2781 // FIXME: The precise cut-offs wrt. the number of saved lines might need some 2782 // more adjusting. 2783 verifyFormat("Aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n" 2784 " Cccccccccccccc cccccccccc,\n" 2785 " Cccccccccccccc cccccccccc,\n" 2786 " Cccccccccccccc cccccccccc,\n" 2787 " Cccccccccccccc cccccccccc);"); 2788 verifyFormat( 2789 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2790 "bbbbbbbbbbb(Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 2791 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 2792 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);", 2793 getGoogleStyle()); 2794 verifyFormat( 2795 "Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n" 2796 " Cccccccccccccc cccccccccc,\n" 2797 " Cccccccccccccc cccccccccc,\n" 2798 " Cccccccccccccc cccccccccc,\n" 2799 " Cccccccccccccc cccccccccc,\n" 2800 " Cccccccccccccc cccccccccc,\n" 2801 " Cccccccccccccc cccccccccc);"); 2802 verifyFormat("Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 2803 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 2804 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 2805 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 2806 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);"); 2807 2808 // Break after multi-line parameters. 2809 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 2810 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2811 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 2812 " bbbb bbbb);"); 2813 verifyFormat("void SomeLoooooooooooongFunction(\n" 2814 " std::unique_ptr<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n" 2815 " aaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 2816 " int bbbbbbbbbbbbb);"); 2817 2818 // Treat overloaded operators like other functions. 2819 verifyFormat("SomeLoooooooooooooooooooooooooogType\n" 2820 "operator>(const SomeLoooooooooooooooooooooooooogType &other);"); 2821 verifyFormat("SomeLoooooooooooooooooooooooooogType\n" 2822 "operator>>(const SomeLooooooooooooooooooooooooogType &other);"); 2823 verifyFormat("SomeLoooooooooooooooooooooooooogType\n" 2824 "operator<<(const SomeLooooooooooooooooooooooooogType &other);"); 2825 verifyGoogleFormat( 2826 "SomeLoooooooooooooooooooooooooooooogType operator>>(\n" 2827 " const SomeLooooooooogType &a, const SomeLooooooooogType &b);"); 2828 verifyGoogleFormat( 2829 "SomeLoooooooooooooooooooooooooooooogType operator<<(\n" 2830 " const SomeLooooooooogType &a, const SomeLooooooooogType &b);"); 2831 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 2832 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = 1);"); 2833 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa\n" 2834 "aaaaaaaaaaaaaaaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaa = 1);"); 2835 verifyGoogleFormat( 2836 "typename aaaaaaaaaa<aaaaaa>::aaaaaaaaaaa\n" 2837 "aaaaaaaaaa<aaaaaa>::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 2838 " bool *aaaaaaaaaaaaaaaaaa, bool *aa) {}"); 2839 verifyGoogleFormat( 2840 "template <typename T>\n" 2841 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2842 "aaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaaaaa(\n" 2843 " aaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaa);"); 2844 2845 FormatStyle Style = getLLVMStyle(); 2846 Style.PointerAlignment = FormatStyle::PAS_Left; 2847 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 2848 " aaaaaaaaaaaaaaaaaaaaaaaaa* const aaaaaaaaaaaa) {}", 2849 Style); 2850 verifyFormat("void aaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*\n" 2851 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 2852 Style); 2853 } 2854 2855 TEST_F(FormatTest, TrailingReturnType) { 2856 verifyFormat("auto foo() -> int;\n"); 2857 verifyFormat("struct S {\n" 2858 " auto bar() const -> int;\n" 2859 "};"); 2860 verifyFormat("template <size_t Order, typename T>\n" 2861 "auto load_img(const std::string &filename)\n" 2862 " -> alias::tensor<Order, T, mem::tag::cpu> {}"); 2863 verifyFormat("auto SomeFunction(A aaaaaaaaaaaaaaaaaaaaa) const\n" 2864 " -> decltype(f(aaaaaaaaaaaaaaaaaaaaa)) {}"); 2865 verifyFormat("auto doSomething(Aaaaaa *aaaaaa) -> decltype(aaaaaa->f()) {}"); 2866 verifyFormat("template <typename T>\n" 2867 "auto aaaaaaaaaaaaaaaaaaaaaa(T t)\n" 2868 " -> decltype(eaaaaaaaaaaaaaaa<T>(t.a).aaaaaaaa());"); 2869 2870 // Not trailing return types. 2871 verifyFormat("void f() { auto a = b->c(); }"); 2872 } 2873 2874 TEST_F(FormatTest, BreaksFunctionDeclarationsWithTrailingTokens) { 2875 // Avoid breaking before trailing 'const' or other trailing annotations, if 2876 // they are not function-like. 2877 FormatStyle Style = getGoogleStyle(); 2878 Style.ColumnLimit = 47; 2879 verifyFormat("void someLongFunction(\n" 2880 " int someLoooooooooooooongParameter) const {\n}", 2881 getLLVMStyleWithColumns(47)); 2882 verifyFormat("LoooooongReturnType\n" 2883 "someLoooooooongFunction() const {}", 2884 getLLVMStyleWithColumns(47)); 2885 verifyFormat("LoooooongReturnType someLoooooooongFunction()\n" 2886 " const {}", 2887 Style); 2888 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n" 2889 " aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE;"); 2890 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n" 2891 " aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE FINAL;"); 2892 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n" 2893 " aaaaa aaaaaaaaaaaaaaaaaaaa) override final;"); 2894 verifyFormat("virtual void aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa,\n" 2895 " aaaaaaaaaaa aaaaa) const override;"); 2896 verifyGoogleFormat( 2897 "virtual void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 2898 " const override;"); 2899 2900 // Even if the first parameter has to be wrapped. 2901 verifyFormat("void someLongFunction(\n" 2902 " int someLongParameter) const {}", 2903 getLLVMStyleWithColumns(46)); 2904 verifyFormat("void someLongFunction(\n" 2905 " int someLongParameter) const {}", 2906 Style); 2907 verifyFormat("void someLongFunction(\n" 2908 " int someLongParameter) override {}", 2909 Style); 2910 verifyFormat("void someLongFunction(\n" 2911 " int someLongParameter) OVERRIDE {}", 2912 Style); 2913 verifyFormat("void someLongFunction(\n" 2914 " int someLongParameter) final {}", 2915 Style); 2916 verifyFormat("void someLongFunction(\n" 2917 " int someLongParameter) FINAL {}", 2918 Style); 2919 verifyFormat("void someLongFunction(\n" 2920 " int parameter) const override {}", 2921 Style); 2922 2923 Style.BreakBeforeBraces = FormatStyle::BS_Allman; 2924 verifyFormat("void someLongFunction(\n" 2925 " int someLongParameter) const\n" 2926 "{\n" 2927 "}", 2928 Style); 2929 2930 // Unless these are unknown annotations. 2931 verifyFormat("void SomeFunction(aaaaaaaaaa aaaaaaaaaaaaaaa,\n" 2932 " aaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 2933 " LONG_AND_UGLY_ANNOTATION;"); 2934 2935 // Breaking before function-like trailing annotations is fine to keep them 2936 // close to their arguments. 2937 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 2938 " LOCKS_EXCLUDED(aaaaaaaaaaaaa);"); 2939 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n" 2940 " LOCKS_EXCLUDED(aaaaaaaaaaaaa);"); 2941 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n" 2942 " LOCKS_EXCLUDED(aaaaaaaaaaaaa) {}"); 2943 verifyGoogleFormat("void aaaaaaaaaaaaaa(aaaaaaaa aaa) override\n" 2944 " AAAAAAAAAAAAAAAAAAAAAAAA(aaaaaaaaaaaaaaa);"); 2945 verifyFormat("SomeFunction([](int i) LOCKS_EXCLUDED(a) {});"); 2946 2947 verifyFormat( 2948 "void aaaaaaaaaaaaaaaaaa()\n" 2949 " __attribute__((aaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaa,\n" 2950 " aaaaaaaaaaaaaaaaaaaaaaaaa));"); 2951 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2952 " __attribute__((unused));"); 2953 verifyGoogleFormat( 2954 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2955 " GUARDED_BY(aaaaaaaaaaaa);"); 2956 verifyGoogleFormat( 2957 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2958 " GUARDED_BY(aaaaaaaaaaaa);"); 2959 verifyGoogleFormat( 2960 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n" 2961 " aaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 2962 verifyGoogleFormat( 2963 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n" 2964 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 2965 } 2966 2967 TEST_F(FormatTest, FunctionAnnotations) { 2968 verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n" 2969 "int OldFunction(const string ¶meter) {}"); 2970 verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n" 2971 "string OldFunction(const string ¶meter) {}"); 2972 verifyFormat("template <typename T>\n" 2973 "DEPRECATED(\"Use NewClass::NewFunction instead.\")\n" 2974 "string OldFunction(const string ¶meter) {}"); 2975 2976 // Not function annotations. 2977 verifyFormat("ASSERT(\"aaaaa\") << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2978 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"); 2979 verifyFormat("TEST_F(ThisIsATestFixtureeeeeeeeeeeee,\n" 2980 " ThisIsATestWithAReallyReallyReallyReallyLongName) {}"); 2981 verifyFormat("MACRO(abc).function() // wrap\n" 2982 " << abc;"); 2983 verifyFormat("MACRO(abc)->function() // wrap\n" 2984 " << abc;"); 2985 verifyFormat("MACRO(abc)::function() // wrap\n" 2986 " << abc;"); 2987 } 2988 2989 TEST_F(FormatTest, BreaksDesireably) { 2990 verifyFormat("if (aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n" 2991 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n" 2992 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa)) {\n}"); 2993 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 2994 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n" 2995 "}"); 2996 2997 verifyFormat( 2998 "aaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 2999 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); 3000 3001 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3002 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3003 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 3004 3005 verifyFormat( 3006 "aaaaaaaa(aaaaaaaaaaaaa,\n" 3007 " aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3008 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n" 3009 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3010 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));"); 3011 3012 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 3013 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 3014 3015 verifyFormat( 3016 "void f() {\n" 3017 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&\n" 3018 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 3019 "}"); 3020 verifyFormat( 3021 "aaaaaa(new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3022 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 3023 verifyFormat( 3024 "aaaaaa(aaa, new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3025 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 3026 verifyFormat( 3027 "aaaaaa(aaa,\n" 3028 " new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3029 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 3030 " aaaa);"); 3031 verifyFormat("aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3032 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 3033 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 3034 3035 // Indent consistently independent of call expression and unary operator. 3036 verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 3037 " dddddddddddddddddddddddddddddd));"); 3038 verifyFormat("aaaaaaaaaaa(!bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 3039 " dddddddddddddddddddddddddddddd));"); 3040 verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbb.ccccccccccccccccc(\n" 3041 " dddddddddddddddddddddddddddddd));"); 3042 3043 // This test case breaks on an incorrect memoization, i.e. an optimization not 3044 // taking into account the StopAt value. 3045 verifyFormat( 3046 "return aaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 3047 " aaaaaaaaaaa(aaaaaaaaa) || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 3048 " aaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 3049 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 3050 3051 verifyFormat("{\n {\n {\n" 3052 " Annotation.SpaceRequiredBefore =\n" 3053 " Line.Tokens[i - 1].Tok.isNot(tok::l_paren) &&\n" 3054 " Line.Tokens[i - 1].Tok.isNot(tok::l_square);\n" 3055 " }\n }\n}"); 3056 3057 // Break on an outer level if there was a break on an inner level. 3058 EXPECT_EQ("f(g(h(a, // comment\n" 3059 " b, c),\n" 3060 " d, e),\n" 3061 " x, y);", 3062 format("f(g(h(a, // comment\n" 3063 " b, c), d, e), x, y);")); 3064 3065 // Prefer breaking similar line breaks. 3066 verifyFormat( 3067 "const int kTrackingOptions = NSTrackingMouseMoved |\n" 3068 " NSTrackingMouseEnteredAndExited |\n" 3069 " NSTrackingActiveAlways;"); 3070 } 3071 3072 TEST_F(FormatTest, FormatsDeclarationsOnePerLine) { 3073 FormatStyle NoBinPacking = getGoogleStyle(); 3074 NoBinPacking.BinPackParameters = false; 3075 NoBinPacking.BinPackArguments = true; 3076 verifyFormat("void f() {\n" 3077 " f(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa,\n" 3078 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 3079 "}", 3080 NoBinPacking); 3081 verifyFormat("void f(int aaaaaaaaaaaaaaaaaaaa,\n" 3082 " int aaaaaaaaaaaaaaaaaaaa,\n" 3083 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 3084 NoBinPacking); 3085 3086 NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false; 3087 verifyFormat("void aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 3088 " vector<int> bbbbbbbbbbbbbbb);", 3089 NoBinPacking); 3090 // FIXME: This behavior difference is probably not wanted. However, currently 3091 // we cannot distinguish BreakBeforeParameter being set because of the wrapped 3092 // template arguments from BreakBeforeParameter being set because of the 3093 // one-per-line formatting. 3094 verifyFormat( 3095 "void fffffffffff(aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa,\n" 3096 " aaaaaaaaaa> aaaaaaaaaa);", 3097 NoBinPacking); 3098 verifyFormat( 3099 "void fffffffffff(\n" 3100 " aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaa>\n" 3101 " aaaaaaaaaa);"); 3102 } 3103 3104 TEST_F(FormatTest, FormatsOneParameterPerLineIfNecessary) { 3105 FormatStyle NoBinPacking = getGoogleStyle(); 3106 NoBinPacking.BinPackParameters = false; 3107 NoBinPacking.BinPackArguments = false; 3108 verifyFormat("f(aaaaaaaaaaaaaaaaaaaa,\n" 3109 " aaaaaaaaaaaaaaaaaaaa,\n" 3110 " aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaa);", 3111 NoBinPacking); 3112 verifyFormat("aaaaaaa(aaaaaaaaaaaaa,\n" 3113 " aaaaaaaaaaaaa,\n" 3114 " aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));", 3115 NoBinPacking); 3116 verifyFormat( 3117 "aaaaaaaa(aaaaaaaaaaaaa,\n" 3118 " aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3119 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n" 3120 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3121 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));", 3122 NoBinPacking); 3123 verifyFormat("aaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n" 3124 " .aaaaaaaaaaaaaaaaaa();", 3125 NoBinPacking); 3126 verifyFormat("void f() {\n" 3127 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3128 " aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaa);\n" 3129 "}", 3130 NoBinPacking); 3131 3132 verifyFormat( 3133 "aaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 3134 " aaaaaaaaaaaa,\n" 3135 " aaaaaaaaaaaa);", 3136 NoBinPacking); 3137 verifyFormat( 3138 "somefunction(someotherFunction(ddddddddddddddddddddddddddddddddddd,\n" 3139 " ddddddddddddddddddddddddddddd),\n" 3140 " test);", 3141 NoBinPacking); 3142 3143 verifyFormat("std::vector<aaaaaaaaaaaaaaaaaaaaaaa,\n" 3144 " aaaaaaaaaaaaaaaaaaaaaaa,\n" 3145 " aaaaaaaaaaaaaaaaaaaaaaa>\n" 3146 " aaaaaaaaaaaaaaaaaa;", 3147 NoBinPacking); 3148 verifyFormat("a(\"a\"\n" 3149 " \"a\",\n" 3150 " a);"); 3151 3152 NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false; 3153 verifyFormat("void aaaaaaaaaa(aaaaaaaaa,\n" 3154 " aaaaaaaaa,\n" 3155 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 3156 NoBinPacking); 3157 verifyFormat( 3158 "void f() {\n" 3159 " aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n" 3160 " .aaaaaaa();\n" 3161 "}", 3162 NoBinPacking); 3163 verifyFormat( 3164 "template <class SomeType, class SomeOtherType>\n" 3165 "SomeType SomeFunction(SomeType Type, SomeOtherType OtherType) {}", 3166 NoBinPacking); 3167 } 3168 3169 TEST_F(FormatTest, AdaptiveOnePerLineFormatting) { 3170 FormatStyle Style = getLLVMStyleWithColumns(15); 3171 Style.ExperimentalAutoDetectBinPacking = true; 3172 EXPECT_EQ("aaa(aaaa,\n" 3173 " aaaa,\n" 3174 " aaaa);\n" 3175 "aaa(aaaa,\n" 3176 " aaaa,\n" 3177 " aaaa);", 3178 format("aaa(aaaa,\n" // one-per-line 3179 " aaaa,\n" 3180 " aaaa );\n" 3181 "aaa(aaaa, aaaa, aaaa);", // inconclusive 3182 Style)); 3183 EXPECT_EQ("aaa(aaaa, aaaa,\n" 3184 " aaaa);\n" 3185 "aaa(aaaa, aaaa,\n" 3186 " aaaa);", 3187 format("aaa(aaaa, aaaa,\n" // bin-packed 3188 " aaaa );\n" 3189 "aaa(aaaa, aaaa, aaaa);", // inconclusive 3190 Style)); 3191 } 3192 3193 TEST_F(FormatTest, FormatsBuilderPattern) { 3194 verifyFormat("return llvm::StringSwitch<Reference::Kind>(name)\n" 3195 " .StartsWith(\".eh_frame_hdr\", ORDER_EH_FRAMEHDR)\n" 3196 " .StartsWith(\".eh_frame\", ORDER_EH_FRAME)\n" 3197 " .StartsWith(\".init\", ORDER_INIT)\n" 3198 " .StartsWith(\".fini\", ORDER_FINI)\n" 3199 " .StartsWith(\".hash\", ORDER_HASH)\n" 3200 " .Default(ORDER_TEXT);\n"); 3201 3202 verifyFormat("return aaaaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa() <\n" 3203 " aaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa();"); 3204 verifyFormat( 3205 "aaaaaaa->aaaaaaa\n" 3206 " ->aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3207 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 3208 " ->aaaaaaaa(aaaaaaaaaaaaaaa);"); 3209 verifyFormat( 3210 "aaaaaaa->aaaaaaa\n" 3211 " ->aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 3212 " ->aaaaaaaa(aaaaaaaaaaaaaaa);"); 3213 verifyFormat( 3214 "aaaaaaaaaaaaaaaaaaa()->aaaaaa(bbbbb)->aaaaaaaaaaaaaaaaaaa( // break\n" 3215 " aaaaaaaaaaaaaa);"); 3216 verifyFormat( 3217 "aaaaaaaaaaaaaaaaaaaaaaa *aaaaaaaaa =\n" 3218 " aaaaaa->aaaaaaaaaaaa()\n" 3219 " ->aaaaaaaaaaaaaaaa(\n" 3220 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 3221 " ->aaaaaaaaaaaaaaaaa();"); 3222 verifyGoogleFormat( 3223 "void f() {\n" 3224 " someo->Add((new util::filetools::Handler(dir))\n" 3225 " ->OnEvent1(NewPermanentCallback(\n" 3226 " this, &HandlerHolderClass::EventHandlerCBA))\n" 3227 " ->OnEvent2(NewPermanentCallback(\n" 3228 " this, &HandlerHolderClass::EventHandlerCBB))\n" 3229 " ->OnEvent3(NewPermanentCallback(\n" 3230 " this, &HandlerHolderClass::EventHandlerCBC))\n" 3231 " ->OnEvent5(NewPermanentCallback(\n" 3232 " this, &HandlerHolderClass::EventHandlerCBD))\n" 3233 " ->OnEvent6(NewPermanentCallback(\n" 3234 " this, &HandlerHolderClass::EventHandlerCBE)));\n" 3235 "}"); 3236 3237 verifyFormat( 3238 "aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa();"); 3239 verifyFormat("aaaaaaaaaaaaaaa()\n" 3240 " .aaaaaaaaaaaaaaa()\n" 3241 " .aaaaaaaaaaaaaaa()\n" 3242 " .aaaaaaaaaaaaaaa()\n" 3243 " .aaaaaaaaaaaaaaa();"); 3244 verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n" 3245 " .aaaaaaaaaaaaaaa()\n" 3246 " .aaaaaaaaaaaaaaa()\n" 3247 " .aaaaaaaaaaaaaaa();"); 3248 verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n" 3249 " .aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n" 3250 " .aaaaaaaaaaaaaaa();"); 3251 verifyFormat("aaaaaaaaaaaaa->aaaaaaaaaaaaaaaaaaaaaaaa()\n" 3252 " ->aaaaaaaaaaaaaae(0)\n" 3253 " ->aaaaaaaaaaaaaaa();"); 3254 3255 // Don't linewrap after very short segments. 3256 verifyFormat("a().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 3257 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 3258 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 3259 verifyFormat("aa().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 3260 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 3261 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 3262 verifyFormat("aaa()\n" 3263 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 3264 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 3265 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 3266 3267 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n" 3268 " .aaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 3269 " .has<bbbbbbbbbbbbbbbbbbbbb>();"); 3270 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n" 3271 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n" 3272 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>();"); 3273 3274 // Prefer not to break after empty parentheses. 3275 verifyFormat("FirstToken->WhitespaceRange.getBegin().getLocWithOffset(\n" 3276 " First->LastNewlineOffset);"); 3277 3278 // Prefer not to create "hanging" indents. 3279 verifyFormat( 3280 "return !soooooooooooooome_map\n" 3281 " .insert(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 3282 " .second;"); 3283 verifyFormat( 3284 "return aaaaaaaaaaaaaaaa\n" 3285 " .aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa)\n" 3286 " .aaaa(aaaaaaaaaaaaaa);"); 3287 // No hanging indent here. 3288 verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa.aaaaaaaaaaaaaaa(\n" 3289 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 3290 verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa().aaaaaaaaaaaaaaa(\n" 3291 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 3292 verifyFormat("aaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n" 3293 " .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 3294 getLLVMStyleWithColumns(60)); 3295 verifyFormat("aaaaaaaaaaaaaaaaaa\n" 3296 " .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n" 3297 " .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 3298 getLLVMStyleWithColumns(59)); 3299 verifyFormat("aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3300 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 3301 " .aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 3302 } 3303 3304 TEST_F(FormatTest, BreaksAccordingToOperatorPrecedence) { 3305 verifyFormat( 3306 "if (aaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 3307 " bbbbbbbbbbbbbbbbbbbbbbbbb && ccccccccccccccccccccccccc) {\n}"); 3308 verifyFormat( 3309 "if (aaaaaaaaaaaaaaaaaaaaaaaaa or\n" 3310 " bbbbbbbbbbbbbbbbbbbbbbbbb and cccccccccccccccccccccccc) {\n}"); 3311 3312 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa && bbbbbbbbbbbbbbbbbbbbbbbbb ||\n" 3313 " ccccccccccccccccccccccccc) {\n}"); 3314 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa and bbbbbbbbbbbbbbbbbbbbbbbb or\n" 3315 " ccccccccccccccccccccccccc) {\n}"); 3316 3317 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb ||\n" 3318 " ccccccccccccccccccccccccc) {\n}"); 3319 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb or\n" 3320 " ccccccccccccccccccccccccc) {\n}"); 3321 3322 verifyFormat( 3323 "if ((aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb) &&\n" 3324 " ccccccccccccccccccccccccc) {\n}"); 3325 verifyFormat( 3326 "if ((aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb) and\n" 3327 " ccccccccccccccccccccccccc) {\n}"); 3328 3329 verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA ||\n" 3330 " bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB ||\n" 3331 " cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC ||\n" 3332 " dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;"); 3333 verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA or\n" 3334 " bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB or\n" 3335 " cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC or\n" 3336 " dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;"); 3337 3338 verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa ||\n" 3339 " aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) &&\n" 3340 " aaaaaaaaaaaaaaa != aa) {\n}"); 3341 verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa or\n" 3342 " aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) and\n" 3343 " aaaaaaaaaaaaaaa != aa) {\n}"); 3344 } 3345 3346 TEST_F(FormatTest, BreaksAfterAssignments) { 3347 verifyFormat( 3348 "unsigned Cost =\n" 3349 " TTI.getMemoryOpCost(I->getOpcode(), VectorTy, SI->getAlignment(),\n" 3350 " SI->getPointerAddressSpaceee());\n"); 3351 verifyFormat( 3352 "CharSourceRange LineRange = CharSourceRange::getTokenRange(\n" 3353 " Line.Tokens.front().Tok.getLo(), Line.Tokens.back().Tok.getLoc());"); 3354 3355 verifyFormat( 3356 "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa = aaaaaaaaaaaaaa(0).aaaa().aaaaaaaaa(\n" 3357 " aaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaa);"); 3358 verifyFormat("unsigned OriginalStartColumn =\n" 3359 " SourceMgr.getSpellingColumnNumber(\n" 3360 " Current.FormatTok.getStartOfNonWhitespace()) -\n" 3361 " 1;"); 3362 } 3363 3364 TEST_F(FormatTest, AlignsAfterAssignments) { 3365 verifyFormat( 3366 "int Result = aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3367 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 3368 verifyFormat( 3369 "Result += aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3370 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 3371 verifyFormat( 3372 "Result >>= aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3373 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 3374 verifyFormat( 3375 "int Result = (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3376 " aaaaaaaaaaaaaaaaaaaaaaaaa);"); 3377 verifyFormat( 3378 "double LooooooooooooooooooooooooongResult = aaaaaaaaaaaaaaaaaaaaaaaa +\n" 3379 " aaaaaaaaaaaaaaaaaaaaaaaa +\n" 3380 " aaaaaaaaaaaaaaaaaaaaaaaa;"); 3381 } 3382 3383 TEST_F(FormatTest, AlignsAfterReturn) { 3384 verifyFormat( 3385 "return aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3386 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 3387 verifyFormat( 3388 "return (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3389 " aaaaaaaaaaaaaaaaaaaaaaaaa);"); 3390 verifyFormat( 3391 "return aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n" 3392 " aaaaaaaaaaaaaaaaaaaaaa();"); 3393 verifyFormat( 3394 "return (aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n" 3395 " aaaaaaaaaaaaaaaaaaaaaa());"); 3396 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3397 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 3398 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3399 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) &&\n" 3400 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 3401 verifyFormat("return\n" 3402 " // true if code is one of a or b.\n" 3403 " code == a || code == b;"); 3404 } 3405 3406 TEST_F(FormatTest, AlignsAfterOpenBracket) { 3407 verifyFormat( 3408 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n" 3409 " aaaaaaaaa aaaaaaa) {}"); 3410 verifyFormat( 3411 "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n" 3412 " aaaaaaaaaaa aaaaaaaaa);"); 3413 verifyFormat( 3414 "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n" 3415 " aaaaaaaaaaaaaaaaaaaaa));"); 3416 FormatStyle Style = getLLVMStyle(); 3417 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 3418 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3419 " aaaaaaaaaaa aaaaaaaa, aaaaaaaaa aaaaaaa) {}", 3420 Style); 3421 verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n" 3422 " aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaa aaaaaaaaa);", 3423 Style); 3424 verifyFormat("SomeLongVariableName->someFunction(\n" 3425 " foooooooo(aaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa));", 3426 Style); 3427 verifyFormat( 3428 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n" 3429 " aaaaaaaaa aaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 3430 Style); 3431 verifyFormat( 3432 "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n" 3433 " aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 3434 Style); 3435 verifyFormat( 3436 "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n" 3437 " aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));", 3438 Style); 3439 3440 verifyFormat("bbbbbbbbbbbb(aaaaaaaaaaaaaaaaaaaaaaaa, //\n" 3441 " ccccccc(aaaaaaaaaaaaaaaaa, //\n" 3442 " b));", 3443 Style); 3444 3445 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 3446 Style.BinPackArguments = false; 3447 Style.BinPackParameters = false; 3448 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3449 " aaaaaaaaaaa aaaaaaaa,\n" 3450 " aaaaaaaaa aaaaaaa,\n" 3451 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 3452 Style); 3453 verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n" 3454 " aaaaaaaaaaa aaaaaaaaa,\n" 3455 " aaaaaaaaaaa aaaaaaaaa,\n" 3456 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 3457 Style); 3458 verifyFormat("SomeLongVariableName->someFunction(foooooooo(\n" 3459 " aaaaaaaaaaaaaaa,\n" 3460 " aaaaaaaaaaaaaaaaaaaaa,\n" 3461 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));", 3462 Style); 3463 verifyFormat( 3464 "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa(\n" 3465 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));", 3466 Style); 3467 verifyFormat( 3468 "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaa.aaaaaaaaaa(\n" 3469 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));", 3470 Style); 3471 verifyFormat( 3472 "aaaaaaaaaaaaaaaaaaaaaaaa(\n" 3473 " aaaaaaaaaaaaaaaaaaaaa(\n" 3474 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)),\n" 3475 " aaaaaaaaaaaaaaaa);", 3476 Style); 3477 verifyFormat( 3478 "aaaaaaaaaaaaaaaaaaaaaaaa(\n" 3479 " aaaaaaaaaaaaaaaaaaaaa(\n" 3480 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)) &&\n" 3481 " aaaaaaaaaaaaaaaa);", 3482 Style); 3483 } 3484 3485 TEST_F(FormatTest, ParenthesesAndOperandAlignment) { 3486 FormatStyle Style = getLLVMStyleWithColumns(40); 3487 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 3488 " bbbbbbbbbbbbbbbbbbbbbb);", 3489 Style); 3490 Style.AlignAfterOpenBracket = FormatStyle::BAS_Align; 3491 Style.AlignOperands = false; 3492 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 3493 " bbbbbbbbbbbbbbbbbbbbbb);", 3494 Style); 3495 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 3496 Style.AlignOperands = true; 3497 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 3498 " bbbbbbbbbbbbbbbbbbbbbb);", 3499 Style); 3500 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 3501 Style.AlignOperands = false; 3502 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 3503 " bbbbbbbbbbbbbbbbbbbbbb);", 3504 Style); 3505 } 3506 3507 TEST_F(FormatTest, BreaksConditionalExpressions) { 3508 verifyFormat( 3509 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3510 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3511 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 3512 verifyFormat( 3513 "aaaa(aaaaaaaaaa, aaaaaaaa,\n" 3514 " aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3515 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 3516 verifyFormat( 3517 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3518 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 3519 verifyFormat( 3520 "aaaa(aaaaaaaaa, aaaaaaaaa,\n" 3521 " aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3522 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 3523 verifyFormat( 3524 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa)\n" 3525 " : aaaaaaaaaaaaa);"); 3526 verifyFormat( 3527 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 3528 " aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3529 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 3530 " aaaaaaaaaaaaa);"); 3531 verifyFormat( 3532 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 3533 " aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 3534 " aaaaaaaaaaaaa);"); 3535 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3536 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3537 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 3538 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3539 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 3540 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 3541 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3542 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3543 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 3544 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3545 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 3546 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 3547 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 3548 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3549 " ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3550 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 3551 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 3552 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3553 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3554 " : aaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 3555 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n" 3556 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3557 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3558 " : aaaaaaaaaaaaaaaa;"); 3559 verifyFormat( 3560 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3561 " ? aaaaaaaaaaaaaaa\n" 3562 " : aaaaaaaaaaaaaaa;"); 3563 verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n" 3564 " aaaaaaaaa\n" 3565 " ? b\n" 3566 " : c);"); 3567 verifyFormat("return aaaa == bbbb\n" 3568 " // comment\n" 3569 " ? aaaa\n" 3570 " : bbbb;"); 3571 verifyFormat("unsigned Indent =\n" 3572 " format(TheLine.First,\n" 3573 " IndentForLevel[TheLine.Level] >= 0\n" 3574 " ? IndentForLevel[TheLine.Level]\n" 3575 " : TheLine * 2,\n" 3576 " TheLine.InPPDirective, PreviousEndOfLineColumn);", 3577 getLLVMStyleWithColumns(60)); 3578 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n" 3579 " ? aaaaaaaaaaaaaaa\n" 3580 " : bbbbbbbbbbbbbbb //\n" 3581 " ? ccccccccccccccc\n" 3582 " : ddddddddddddddd;"); 3583 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n" 3584 " ? aaaaaaaaaaaaaaa\n" 3585 " : (bbbbbbbbbbbbbbb //\n" 3586 " ? ccccccccccccccc\n" 3587 " : ddddddddddddddd);"); 3588 verifyFormat( 3589 "int aaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3590 " ? aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3591 " aaaaaaaaaaaaaaaaaaaaa +\n" 3592 " aaaaaaaaaaaaaaaaaaaaa\n" 3593 " : aaaaaaaaaa;"); 3594 verifyFormat( 3595 "aaaaaa = aaaaaaaaaaaa ? aaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3596 " : aaaaaaaaaaaaaaaaaaaaaa\n" 3597 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 3598 3599 FormatStyle NoBinPacking = getLLVMStyle(); 3600 NoBinPacking.BinPackArguments = false; 3601 verifyFormat( 3602 "void f() {\n" 3603 " g(aaa,\n" 3604 " aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n" 3605 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3606 " ? aaaaaaaaaaaaaaa\n" 3607 " : aaaaaaaaaaaaaaa);\n" 3608 "}", 3609 NoBinPacking); 3610 verifyFormat( 3611 "void f() {\n" 3612 " g(aaa,\n" 3613 " aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n" 3614 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3615 " ?: aaaaaaaaaaaaaaa);\n" 3616 "}", 3617 NoBinPacking); 3618 3619 verifyFormat("SomeFunction(aaaaaaaaaaaaaaaaa,\n" 3620 " // comment.\n" 3621 " ccccccccccccccccccccccccccccccccccccccc\n" 3622 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3623 " : bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);"); 3624 3625 // Assignments in conditional expressions. Apparently not uncommon :-(. 3626 verifyFormat("return a != b\n" 3627 " // comment\n" 3628 " ? a = b\n" 3629 " : a = b;"); 3630 verifyFormat("return a != b\n" 3631 " // comment\n" 3632 " ? a = a != b\n" 3633 " // comment\n" 3634 " ? a = b\n" 3635 " : a\n" 3636 " : a;\n"); 3637 verifyFormat("return a != b\n" 3638 " // comment\n" 3639 " ? a\n" 3640 " : a = a != b\n" 3641 " // comment\n" 3642 " ? a = b\n" 3643 " : a;"); 3644 } 3645 3646 TEST_F(FormatTest, BreaksConditionalExpressionsAfterOperator) { 3647 FormatStyle Style = getLLVMStyle(); 3648 Style.BreakBeforeTernaryOperators = false; 3649 Style.ColumnLimit = 70; 3650 verifyFormat( 3651 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 3652 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 3653 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 3654 Style); 3655 verifyFormat( 3656 "aaaa(aaaaaaaaaa, aaaaaaaa,\n" 3657 " aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 3658 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 3659 Style); 3660 verifyFormat( 3661 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 3662 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 3663 Style); 3664 verifyFormat( 3665 "aaaa(aaaaaaaa, aaaaaaaaaa,\n" 3666 " aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 3667 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 3668 Style); 3669 verifyFormat( 3670 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa) :\n" 3671 " aaaaaaaaaaaaa);", 3672 Style); 3673 verifyFormat( 3674 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 3675 " aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 3676 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 3677 " aaaaaaaaaaaaa);", 3678 Style); 3679 verifyFormat( 3680 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 3681 " aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 3682 " aaaaaaaaaaaaa);", 3683 Style); 3684 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 3685 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3686 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n" 3687 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3688 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 3689 Style); 3690 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 3691 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 3692 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3693 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n" 3694 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3695 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 3696 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);", 3697 Style); 3698 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 3699 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?:\n" 3700 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3701 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 3702 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);", 3703 Style); 3704 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 3705 " aaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 3706 " aaaaaaaaaaaaaaaaaaaaaaaaaaa;", 3707 Style); 3708 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n" 3709 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 3710 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 3711 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 3712 Style); 3713 verifyFormat( 3714 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 3715 " aaaaaaaaaaaaaaa :\n" 3716 " aaaaaaaaaaaaaaa;", 3717 Style); 3718 verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n" 3719 " aaaaaaaaa ?\n" 3720 " b :\n" 3721 " c);", 3722 Style); 3723 verifyFormat("unsigned Indent =\n" 3724 " format(TheLine.First,\n" 3725 " IndentForLevel[TheLine.Level] >= 0 ?\n" 3726 " IndentForLevel[TheLine.Level] :\n" 3727 " TheLine * 2,\n" 3728 " TheLine.InPPDirective, PreviousEndOfLineColumn);", 3729 Style); 3730 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n" 3731 " aaaaaaaaaaaaaaa :\n" 3732 " bbbbbbbbbbbbbbb ? //\n" 3733 " ccccccccccccccc :\n" 3734 " ddddddddddddddd;", 3735 Style); 3736 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n" 3737 " aaaaaaaaaaaaaaa :\n" 3738 " (bbbbbbbbbbbbbbb ? //\n" 3739 " ccccccccccccccc :\n" 3740 " ddddddddddddddd);", 3741 Style); 3742 verifyFormat("int i = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 3743 " /*bbbbbbbbbbbbbbb=*/bbbbbbbbbbbbbbbbbbbbbbbbb :\n" 3744 " ccccccccccccccccccccccccccc;", 3745 Style); 3746 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 3747 " aaaaa :\n" 3748 " bbbbbbbbbbbbbbb + cccccccccccccccc;", 3749 Style); 3750 } 3751 3752 TEST_F(FormatTest, DeclarationsOfMultipleVariables) { 3753 verifyFormat("bool aaaaaaaaaaaaaaaaa = aaaaaa->aaaaaaaaaaaaaaaaa(),\n" 3754 " aaaaaaaaaaa = aaaaaa->aaaaaaaaaaa();"); 3755 verifyFormat("bool a = true, b = false;"); 3756 3757 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaa =\n" 3758 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa),\n" 3759 " bbbbbbbbbbbbbbbbbbbbbbbbb =\n" 3760 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(bbbbbbbbbbbbbbbb);"); 3761 verifyFormat( 3762 "bool aaaaaaaaaaaaaaaaaaaaa =\n" 3763 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb && cccccccccccccccccccccccccccc,\n" 3764 " d = e && f;"); 3765 verifyFormat("aaaaaaaaa a = aaaaaaaaaaaaaaaaaaaa, b = bbbbbbbbbbbbbbbbbbbb,\n" 3766 " c = cccccccccccccccccccc, d = dddddddddddddddddddd;"); 3767 verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n" 3768 " *c = ccccccccccccccccccc, *d = ddddddddddddddddddd;"); 3769 verifyFormat("aaaaaaaaa ***a = aaaaaaaaaaaaaaaaaaa, ***b = bbbbbbbbbbbbbbb,\n" 3770 " ***c = ccccccccccccccccccc, ***d = ddddddddddddddd;"); 3771 3772 FormatStyle Style = getGoogleStyle(); 3773 Style.PointerAlignment = FormatStyle::PAS_Left; 3774 Style.DerivePointerAlignment = false; 3775 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3776 " *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaa,\n" 3777 " *b = bbbbbbbbbbbbbbbbbbb;", 3778 Style); 3779 verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n" 3780 " *b = bbbbbbbbbbbbbbbbbbb, *d = ddddddddddddddddddd;", 3781 Style); 3782 verifyFormat("vector<int*> a, b;", Style); 3783 verifyFormat("for (int *p, *q; p != q; p = p->next) {\n}", Style); 3784 } 3785 3786 TEST_F(FormatTest, ConditionalExpressionsInBrackets) { 3787 verifyFormat("arr[foo ? bar : baz];"); 3788 verifyFormat("f()[foo ? bar : baz];"); 3789 verifyFormat("(a + b)[foo ? bar : baz];"); 3790 verifyFormat("arr[foo ? (4 > 5 ? 4 : 5) : 5 < 5 ? 5 : 7];"); 3791 } 3792 3793 TEST_F(FormatTest, AlignsStringLiterals) { 3794 verifyFormat("loooooooooooooooooooooooooongFunction(\"short literal \"\n" 3795 " \"short literal\");"); 3796 verifyFormat( 3797 "looooooooooooooooooooooooongFunction(\n" 3798 " \"short literal\"\n" 3799 " \"looooooooooooooooooooooooooooooooooooooooooooooooong literal\");"); 3800 verifyFormat("someFunction(\"Always break between multi-line\"\n" 3801 " \" string literals\",\n" 3802 " and, other, parameters);"); 3803 EXPECT_EQ("fun + \"1243\" /* comment */\n" 3804 " \"5678\";", 3805 format("fun + \"1243\" /* comment */\n" 3806 " \"5678\";", 3807 getLLVMStyleWithColumns(28))); 3808 EXPECT_EQ( 3809 "aaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 3810 " \"aaaaaaaaaaaaaaaaaaaaa\"\n" 3811 " \"aaaaaaaaaaaaaaaa\";", 3812 format("aaaaaa =" 3813 "\"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa " 3814 "aaaaaaaaaaaaaaaaaaaaa\" " 3815 "\"aaaaaaaaaaaaaaaa\";")); 3816 verifyFormat("a = a + \"a\"\n" 3817 " \"a\"\n" 3818 " \"a\";"); 3819 verifyFormat("f(\"a\", \"b\"\n" 3820 " \"c\");"); 3821 3822 verifyFormat( 3823 "#define LL_FORMAT \"ll\"\n" 3824 "printf(\"aaaaa: %d, bbbbbb: %\" LL_FORMAT \"d, cccccccc: %\" LL_FORMAT\n" 3825 " \"d, ddddddddd: %\" LL_FORMAT \"d\");"); 3826 3827 verifyFormat("#define A(X) \\\n" 3828 " \"aaaaa\" #X \"bbbbbb\" \\\n" 3829 " \"ccccc\"", 3830 getLLVMStyleWithColumns(23)); 3831 verifyFormat("#define A \"def\"\n" 3832 "f(\"abc\" A \"ghi\"\n" 3833 " \"jkl\");"); 3834 3835 verifyFormat("f(L\"a\"\n" 3836 " L\"b\");"); 3837 verifyFormat("#define A(X) \\\n" 3838 " L\"aaaaa\" #X L\"bbbbbb\" \\\n" 3839 " L\"ccccc\"", 3840 getLLVMStyleWithColumns(25)); 3841 3842 verifyFormat("f(@\"a\"\n" 3843 " @\"b\");"); 3844 verifyFormat("NSString s = @\"a\"\n" 3845 " @\"b\"\n" 3846 " @\"c\";"); 3847 verifyFormat("NSString s = @\"a\"\n" 3848 " \"b\"\n" 3849 " \"c\";"); 3850 } 3851 3852 TEST_F(FormatTest, ReturnTypeBreakingStyle) { 3853 FormatStyle Style = getLLVMStyle(); 3854 // No declarations or definitions should be moved to own line. 3855 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_None; 3856 verifyFormat("class A {\n" 3857 " int f() { return 1; }\n" 3858 " int g();\n" 3859 "};\n" 3860 "int f() { return 1; }\n" 3861 "int g();\n", 3862 Style); 3863 3864 // All declarations and definitions should have the return type moved to its 3865 // own 3866 // line. 3867 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All; 3868 verifyFormat("class E {\n" 3869 " int\n" 3870 " f() {\n" 3871 " return 1;\n" 3872 " }\n" 3873 " int\n" 3874 " g();\n" 3875 "};\n" 3876 "int\n" 3877 "f() {\n" 3878 " return 1;\n" 3879 "}\n" 3880 "int\n" 3881 "g();\n", 3882 Style); 3883 3884 // Top-level definitions, and no kinds of declarations should have the 3885 // return type moved to its own line. 3886 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevelDefinitions; 3887 verifyFormat("class B {\n" 3888 " int f() { return 1; }\n" 3889 " int g();\n" 3890 "};\n" 3891 "int\n" 3892 "f() {\n" 3893 " return 1;\n" 3894 "}\n" 3895 "int g();\n", 3896 Style); 3897 3898 // Top-level definitions and declarations should have the return type moved 3899 // to its own line. 3900 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevel; 3901 verifyFormat("class C {\n" 3902 " int f() { return 1; }\n" 3903 " int g();\n" 3904 "};\n" 3905 "int\n" 3906 "f() {\n" 3907 " return 1;\n" 3908 "}\n" 3909 "int\n" 3910 "g();\n", 3911 Style); 3912 3913 // All definitions should have the return type moved to its own line, but no 3914 // kinds of declarations. 3915 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions; 3916 verifyFormat("class D {\n" 3917 " int\n" 3918 " f() {\n" 3919 " return 1;\n" 3920 " }\n" 3921 " int g();\n" 3922 "};\n" 3923 "int\n" 3924 "f() {\n" 3925 " return 1;\n" 3926 "}\n" 3927 "int g();\n", 3928 Style); 3929 verifyFormat("const char *\n" 3930 "f(void) {\n" // Break here. 3931 " return \"\";\n" 3932 "}\n" 3933 "const char *bar(void);\n", // No break here. 3934 Style); 3935 verifyFormat("template <class T>\n" 3936 "T *\n" 3937 "f(T &c) {\n" // Break here. 3938 " return NULL;\n" 3939 "}\n" 3940 "template <class T> T *f(T &c);\n", // No break here. 3941 Style); 3942 verifyFormat("class C {\n" 3943 " int\n" 3944 " operator+() {\n" 3945 " return 1;\n" 3946 " }\n" 3947 " int\n" 3948 " operator()() {\n" 3949 " return 1;\n" 3950 " }\n" 3951 "};\n", 3952 Style); 3953 verifyFormat("void\n" 3954 "A::operator()() {}\n" 3955 "void\n" 3956 "A::operator>>() {}\n" 3957 "void\n" 3958 "A::operator+() {}\n", 3959 Style); 3960 verifyFormat("void *operator new(std::size_t s);", // No break here. 3961 Style); 3962 verifyFormat("void *\n" 3963 "operator new(std::size_t s) {}", 3964 Style); 3965 verifyFormat("void *\n" 3966 "operator delete[](void *ptr) {}", 3967 Style); 3968 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 3969 verifyFormat("const char *\n" 3970 "f(void)\n" // Break here. 3971 "{\n" 3972 " return \"\";\n" 3973 "}\n" 3974 "const char *bar(void);\n", // No break here. 3975 Style); 3976 verifyFormat("template <class T>\n" 3977 "T *\n" // Problem here: no line break 3978 "f(T &c)\n" // Break here. 3979 "{\n" 3980 " return NULL;\n" 3981 "}\n" 3982 "template <class T> T *f(T &c);\n", // No break here. 3983 Style); 3984 } 3985 3986 TEST_F(FormatTest, AlwaysBreakBeforeMultilineStrings) { 3987 FormatStyle NoBreak = getLLVMStyle(); 3988 NoBreak.AlwaysBreakBeforeMultilineStrings = false; 3989 FormatStyle Break = getLLVMStyle(); 3990 Break.AlwaysBreakBeforeMultilineStrings = true; 3991 verifyFormat("aaaa = \"bbbb\"\n" 3992 " \"cccc\";", 3993 NoBreak); 3994 verifyFormat("aaaa =\n" 3995 " \"bbbb\"\n" 3996 " \"cccc\";", 3997 Break); 3998 verifyFormat("aaaa(\"bbbb\"\n" 3999 " \"cccc\");", 4000 NoBreak); 4001 verifyFormat("aaaa(\n" 4002 " \"bbbb\"\n" 4003 " \"cccc\");", 4004 Break); 4005 verifyFormat("aaaa(qqq, \"bbbb\"\n" 4006 " \"cccc\");", 4007 NoBreak); 4008 verifyFormat("aaaa(qqq,\n" 4009 " \"bbbb\"\n" 4010 " \"cccc\");", 4011 Break); 4012 verifyFormat("aaaa(qqq,\n" 4013 " L\"bbbb\"\n" 4014 " L\"cccc\");", 4015 Break); 4016 verifyFormat("aaaaa(aaaaaa, aaaaaaa(\"aaaa\"\n" 4017 " \"bbbb\"));", 4018 Break); 4019 verifyFormat("string s = someFunction(\n" 4020 " \"abc\"\n" 4021 " \"abc\");", 4022 Break); 4023 4024 // As we break before unary operators, breaking right after them is bad. 4025 verifyFormat("string foo = abc ? \"x\"\n" 4026 " \"blah blah blah blah blah blah\"\n" 4027 " : \"y\";", 4028 Break); 4029 4030 // Don't break if there is no column gain. 4031 verifyFormat("f(\"aaaa\"\n" 4032 " \"bbbb\");", 4033 Break); 4034 4035 // Treat literals with escaped newlines like multi-line string literals. 4036 EXPECT_EQ("x = \"a\\\n" 4037 "b\\\n" 4038 "c\";", 4039 format("x = \"a\\\n" 4040 "b\\\n" 4041 "c\";", 4042 NoBreak)); 4043 EXPECT_EQ("xxxx =\n" 4044 " \"a\\\n" 4045 "b\\\n" 4046 "c\";", 4047 format("xxxx = \"a\\\n" 4048 "b\\\n" 4049 "c\";", 4050 Break)); 4051 4052 // Exempt ObjC strings for now. 4053 EXPECT_EQ("NSString *const kString = @\"aaaa\"\n" 4054 " @\"bbbb\";", 4055 format("NSString *const kString = @\"aaaa\"\n" 4056 "@\"bbbb\";", 4057 Break)); 4058 4059 Break.ColumnLimit = 0; 4060 verifyFormat("const char *hello = \"hello llvm\";", Break); 4061 } 4062 4063 TEST_F(FormatTest, AlignsPipes) { 4064 verifyFormat( 4065 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4066 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4067 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 4068 verifyFormat( 4069 "aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa\n" 4070 " << aaaaaaaaaaaaaaaaaaaa;"); 4071 verifyFormat( 4072 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4073 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 4074 verifyFormat( 4075 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 4076 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 4077 verifyFormat( 4078 "llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"\n" 4079 " \"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\"\n" 4080 " << \"ccccccccccccccccccccccccccccccccccccccccccccccccc\";"); 4081 verifyFormat( 4082 "aaaaaaaa << (aaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4083 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 4084 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 4085 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4086 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4087 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 4088 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 4089 verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaaaaaa: \"\n" 4090 " << aaaaaaaaaaaaaaaaa(aaaaaaaa, aaaaaaaaaaa);"); 4091 verifyFormat( 4092 "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4093 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 4094 4095 verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \"\n" 4096 " << aaaaaaaa.aaaaaaaaaaaa(aaa)->aaaaaaaaaaaaaa();"); 4097 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4098 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4099 " aaaaaaaaaaaaaaaaaaaaa)\n" 4100 " << aaaaaaaaaaaaaaaaaaaaaaaaaa;"); 4101 verifyFormat("LOG_IF(aaa == //\n" 4102 " bbb)\n" 4103 " << a << b;"); 4104 4105 // But sometimes, breaking before the first "<<" is desirable. 4106 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n" 4107 " << aaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaa);"); 4108 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbb)\n" 4109 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4110 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 4111 verifyFormat("SemaRef.Diag(Loc, diag::note_for_range_begin_end)\n" 4112 " << BEF << IsTemplate << Description << E->getType();"); 4113 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n" 4114 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4115 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 4116 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n" 4117 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4118 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 4119 " << aaa;"); 4120 4121 verifyFormat( 4122 "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4123 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 4124 4125 // Incomplete string literal. 4126 EXPECT_EQ("llvm::errs() << \"\n" 4127 " << a;", 4128 format("llvm::errs() << \"\n<<a;")); 4129 4130 verifyFormat("void f() {\n" 4131 " CHECK_EQ(aaaa, (*bbbbbbbbb)->cccccc)\n" 4132 " << \"qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\";\n" 4133 "}"); 4134 4135 // Handle 'endl'. 4136 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << endl\n" 4137 " << bbbbbbbbbbbbbbbbbbbbbb << endl;"); 4138 verifyFormat("llvm::errs() << endl << bbbbbbbbbbbbbbbbbbbbbb << endl;"); 4139 4140 // Handle '\n'. 4141 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \"\\n\"\n" 4142 " << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";"); 4143 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \'\\n\'\n" 4144 " << bbbbbbbbbbbbbbbbbbbbbb << \'\\n\';"); 4145 verifyFormat("llvm::errs() << aaaa << \"aaaaaaaaaaaaaaaaaa\\n\"\n" 4146 " << bbbb << \"bbbbbbbbbbbbbbbbbb\\n\";"); 4147 verifyFormat("llvm::errs() << \"\\n\" << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";"); 4148 } 4149 4150 TEST_F(FormatTest, KeepStringLabelValuePairsOnALine) { 4151 verifyFormat("return out << \"somepacket = {\\n\"\n" 4152 " << \" aaaaaa = \" << pkt.aaaaaa << \"\\n\"\n" 4153 " << \" bbbb = \" << pkt.bbbb << \"\\n\"\n" 4154 " << \" cccccc = \" << pkt.cccccc << \"\\n\"\n" 4155 " << \" ddd = [\" << pkt.ddd << \"]\\n\"\n" 4156 " << \"}\";"); 4157 4158 verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n" 4159 " << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n" 4160 " << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa;"); 4161 verifyFormat( 4162 "llvm::outs() << \"aaaaaaaaaaaaaaaaa = \" << aaaaaaaaaaaaaaaaa\n" 4163 " << \"bbbbbbbbbbbbbbbbb = \" << bbbbbbbbbbbbbbbbb\n" 4164 " << \"ccccccccccccccccc = \" << ccccccccccccccccc\n" 4165 " << \"ddddddddddddddddd = \" << ddddddddddddddddd\n" 4166 " << \"eeeeeeeeeeeeeeeee = \" << eeeeeeeeeeeeeeeee;"); 4167 verifyFormat("llvm::outs() << aaaaaaaaaaaaaaaaaaaaaaaa << \"=\"\n" 4168 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 4169 verifyFormat( 4170 "void f() {\n" 4171 " llvm::outs() << \"aaaaaaaaaaaaaaaaaaaa: \"\n" 4172 " << aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 4173 "}"); 4174 4175 // Breaking before the first "<<" is generally not desirable. 4176 verifyFormat( 4177 "llvm::errs()\n" 4178 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4179 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4180 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4181 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 4182 getLLVMStyleWithColumns(70)); 4183 verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaa: \"\n" 4184 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4185 " << \"aaaaaaaaaaaaaaaaaaa: \"\n" 4186 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4187 " << \"aaaaaaaaaaaaaaaaaaa: \"\n" 4188 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 4189 getLLVMStyleWithColumns(70)); 4190 4191 verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n" 4192 " \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n" 4193 " \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa;"); 4194 verifyFormat("string v = StrCat(\"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n" 4195 " \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n" 4196 " \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa);"); 4197 verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" +\n" 4198 " (aaaa + aaaa);", 4199 getLLVMStyleWithColumns(40)); 4200 verifyFormat("string v = StrCat(\"aaaaaaaaaaaa: \" +\n" 4201 " (aaaaaaa + aaaaa));", 4202 getLLVMStyleWithColumns(40)); 4203 verifyFormat( 4204 "string v = StrCat(\"aaaaaaaaaaaaaaaaaaaaaaaaaaa: \",\n" 4205 " SomeFunction(aaaaaaaaaaaa, aaaaaaaa.aaaaaaa),\n" 4206 " bbbbbbbbbbbbbbbbbbbbbbb);"); 4207 } 4208 4209 TEST_F(FormatTest, UnderstandsEquals) { 4210 verifyFormat( 4211 "aaaaaaaaaaaaaaaaa =\n" 4212 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 4213 verifyFormat( 4214 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 4215 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 4216 verifyFormat( 4217 "if (a) {\n" 4218 " f();\n" 4219 "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 4220 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 4221 "}"); 4222 4223 verifyFormat("if (int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 4224 " 100000000 + 10000000) {\n}"); 4225 } 4226 4227 TEST_F(FormatTest, WrapsAtFunctionCallsIfNecessary) { 4228 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n" 4229 " .looooooooooooooooooooooooooooooooooooooongFunction();"); 4230 4231 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n" 4232 " ->looooooooooooooooooooooooooooooooooooooongFunction();"); 4233 4234 verifyFormat( 4235 "LooooooooooooooooooooooooooooooooongObject->shortFunction(Parameter1,\n" 4236 " Parameter2);"); 4237 4238 verifyFormat( 4239 "ShortObject->shortFunction(\n" 4240 " LooooooooooooooooooooooooooooooooooooooooooooooongParameter1,\n" 4241 " LooooooooooooooooooooooooooooooooooooooooooooooongParameter2);"); 4242 4243 verifyFormat("loooooooooooooongFunction(\n" 4244 " LoooooooooooooongObject->looooooooooooooooongFunction());"); 4245 4246 verifyFormat( 4247 "function(LoooooooooooooooooooooooooooooooooooongObject\n" 4248 " ->loooooooooooooooooooooooooooooooooooooooongFunction());"); 4249 4250 verifyFormat("EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n" 4251 " .WillRepeatedly(Return(SomeValue));"); 4252 verifyFormat("void f() {\n" 4253 " EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n" 4254 " .Times(2)\n" 4255 " .WillRepeatedly(Return(SomeValue));\n" 4256 "}"); 4257 verifyFormat("SomeMap[std::pair(aaaaaaaaaaaa, bbbbbbbbbbbbbbb)].insert(\n" 4258 " ccccccccccccccccccccccc);"); 4259 verifyFormat("aaaaa(aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4260 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 4261 " .aaaaa(aaaaa),\n" 4262 " aaaaaaaaaaaaaaaaaaaaa);"); 4263 verifyFormat("void f() {\n" 4264 " aaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4265 " aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa)->aaaaaaaaa());\n" 4266 "}"); 4267 verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4268 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 4269 " .aaaaaaaaaaaaaaa(aa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4270 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4271 " aaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 4272 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4273 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4274 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4275 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()) {\n" 4276 "}"); 4277 4278 // Here, it is not necessary to wrap at "." or "->". 4279 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaa) ||\n" 4280 " aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 4281 verifyFormat( 4282 "aaaaaaaaaaa->aaaaaaaaa(\n" 4283 " aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4284 " aaaaaaaaaaaaaaaaaa->aaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa));\n"); 4285 4286 verifyFormat( 4287 "aaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4288 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa().aaaaaaaaaaaaaaaaa());"); 4289 verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() *\n" 4290 " aaaaaaaaa()->aaaaaa()->aaaaa());"); 4291 verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() ||\n" 4292 " aaaaaaaaa()->aaaaaa()->aaaaa());"); 4293 4294 verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4295 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 4296 " .a();"); 4297 4298 FormatStyle NoBinPacking = getLLVMStyle(); 4299 NoBinPacking.BinPackParameters = false; 4300 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n" 4301 " .aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n" 4302 " .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa,\n" 4303 " aaaaaaaaaaaaaaaaaaa,\n" 4304 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 4305 NoBinPacking); 4306 4307 // If there is a subsequent call, change to hanging indentation. 4308 verifyFormat( 4309 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4310 " aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa))\n" 4311 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 4312 verifyFormat( 4313 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4314 " aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa));"); 4315 verifyFormat("aaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4316 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 4317 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 4318 verifyFormat("aaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4319 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 4320 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());"); 4321 } 4322 4323 TEST_F(FormatTest, WrapsTemplateDeclarations) { 4324 verifyFormat("template <typename T>\n" 4325 "virtual void loooooooooooongFunction(int Param1, int Param2);"); 4326 verifyFormat("template <typename T>\n" 4327 "// T should be one of {A, B}.\n" 4328 "virtual void loooooooooooongFunction(int Param1, int Param2);"); 4329 verifyFormat( 4330 "template <typename T>\n" 4331 "using comment_to_xml_conversion = comment_to_xml_conversion<T, int>;"); 4332 verifyFormat("template <typename T>\n" 4333 "void f(int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram1,\n" 4334 " int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram2);"); 4335 verifyFormat( 4336 "template <typename T>\n" 4337 "void looooooooooooooooooooongFunction(int Paaaaaaaaaaaaaaaaaaaaram1,\n" 4338 " int Paaaaaaaaaaaaaaaaaaaaram2);"); 4339 verifyFormat( 4340 "template <typename T>\n" 4341 "aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaa,\n" 4342 " aaaaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaa,\n" 4343 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 4344 verifyFormat("template <typename T>\n" 4345 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4346 " int aaaaaaaaaaaaaaaaaaaaaa);"); 4347 verifyFormat( 4348 "template <typename T1, typename T2 = char, typename T3 = char,\n" 4349 " typename T4 = char>\n" 4350 "void f();"); 4351 verifyFormat("template <typename aaaaaaaaaaa, typename bbbbbbbbbbbbb,\n" 4352 " template <typename> class cccccccccccccccccccccc,\n" 4353 " typename ddddddddddddd>\n" 4354 "class C {};"); 4355 verifyFormat( 4356 "aaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>(\n" 4357 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 4358 4359 verifyFormat("void f() {\n" 4360 " a<aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaa>(\n" 4361 " a(aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));\n" 4362 "}"); 4363 4364 verifyFormat("template <typename T> class C {};"); 4365 verifyFormat("template <typename T> void f();"); 4366 verifyFormat("template <typename T> void f() {}"); 4367 verifyFormat( 4368 "aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n" 4369 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4370 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> *aaaa =\n" 4371 " new aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n" 4372 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4373 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>(\n" 4374 " bbbbbbbbbbbbbbbbbbbbbbbb);", 4375 getLLVMStyleWithColumns(72)); 4376 EXPECT_EQ("static_cast<A< //\n" 4377 " B> *>(\n" 4378 "\n" 4379 " );", 4380 format("static_cast<A<//\n" 4381 " B>*>(\n" 4382 "\n" 4383 " );")); 4384 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4385 " const typename aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaa);"); 4386 4387 FormatStyle AlwaysBreak = getLLVMStyle(); 4388 AlwaysBreak.AlwaysBreakTemplateDeclarations = true; 4389 verifyFormat("template <typename T>\nclass C {};", AlwaysBreak); 4390 verifyFormat("template <typename T>\nvoid f();", AlwaysBreak); 4391 verifyFormat("template <typename T>\nvoid f() {}", AlwaysBreak); 4392 verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4393 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n" 4394 " ccccccccccccccccccccccccccccccccccccccccccccccc);"); 4395 verifyFormat("template <template <typename> class Fooooooo,\n" 4396 " template <typename> class Baaaaaaar>\n" 4397 "struct C {};", 4398 AlwaysBreak); 4399 verifyFormat("template <typename T> // T can be A, B or C.\n" 4400 "struct C {};", 4401 AlwaysBreak); 4402 verifyFormat("template <enum E> class A {\n" 4403 "public:\n" 4404 " E *f();\n" 4405 "};"); 4406 } 4407 4408 TEST_F(FormatTest, WrapsTemplateParameters) { 4409 FormatStyle Style = getLLVMStyle(); 4410 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 4411 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 4412 verifyFormat( 4413 "template <typename... a> struct q {};\n" 4414 "extern q<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n" 4415 " aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n" 4416 " y;", 4417 Style); 4418 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 4419 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 4420 verifyFormat( 4421 "template <typename... a> struct r {};\n" 4422 "extern r<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n" 4423 " aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n" 4424 " y;", 4425 Style); 4426 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 4427 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 4428 verifyFormat( 4429 "template <typename... a> struct s {};\n" 4430 "extern s<\n" 4431 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n" 4432 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa>\n" 4433 " y;", 4434 Style); 4435 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 4436 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 4437 verifyFormat( 4438 "template <typename... a> struct t {};\n" 4439 "extern t<\n" 4440 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n" 4441 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa>\n" 4442 " y;", 4443 Style); 4444 } 4445 4446 TEST_F(FormatTest, WrapsAtNestedNameSpecifiers) { 4447 verifyFormat( 4448 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 4449 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 4450 verifyFormat( 4451 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 4452 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4453 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());"); 4454 4455 // FIXME: Should we have the extra indent after the second break? 4456 verifyFormat( 4457 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 4458 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 4459 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 4460 4461 verifyFormat( 4462 "aaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb::\n" 4463 " cccccccccccccccccccccccccccccccccccccccccccccc());"); 4464 4465 // Breaking at nested name specifiers is generally not desirable. 4466 verifyFormat( 4467 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4468 " aaaaaaaaaaaaaaaaaaaaaaa);"); 4469 4470 verifyFormat( 4471 "aaaaaaaaaaaaaaaaaa(aaaaaaaa,\n" 4472 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 4473 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4474 " aaaaaaaaaaaaaaaaaaaaa);", 4475 getLLVMStyleWithColumns(74)); 4476 4477 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 4478 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4479 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 4480 } 4481 4482 TEST_F(FormatTest, UnderstandsTemplateParameters) { 4483 verifyFormat("A<int> a;"); 4484 verifyFormat("A<A<A<int>>> a;"); 4485 verifyFormat("A<A<A<int, 2>, 3>, 4> a;"); 4486 verifyFormat("bool x = a < 1 || 2 > a;"); 4487 verifyFormat("bool x = 5 < f<int>();"); 4488 verifyFormat("bool x = f<int>() > 5;"); 4489 verifyFormat("bool x = 5 < a<int>::x;"); 4490 verifyFormat("bool x = a < 4 ? a > 2 : false;"); 4491 verifyFormat("bool x = f() ? a < 2 : a > 2;"); 4492 4493 verifyGoogleFormat("A<A<int>> a;"); 4494 verifyGoogleFormat("A<A<A<int>>> a;"); 4495 verifyGoogleFormat("A<A<A<A<int>>>> a;"); 4496 verifyGoogleFormat("A<A<int> > a;"); 4497 verifyGoogleFormat("A<A<A<int> > > a;"); 4498 verifyGoogleFormat("A<A<A<A<int> > > > a;"); 4499 verifyGoogleFormat("A<::A<int>> a;"); 4500 verifyGoogleFormat("A<::A> a;"); 4501 verifyGoogleFormat("A< ::A> a;"); 4502 verifyGoogleFormat("A< ::A<int> > a;"); 4503 EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A> >> a;", getGoogleStyle())); 4504 EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A>> > a;", getGoogleStyle())); 4505 EXPECT_EQ("A<::A<int>> a;", format("A< ::A<int>> a;", getGoogleStyle())); 4506 EXPECT_EQ("A<::A<int>> a;", format("A<::A<int> > a;", getGoogleStyle())); 4507 EXPECT_EQ("auto x = [] { A<A<A<A>>> a; };", 4508 format("auto x=[]{A<A<A<A> >> a;};", getGoogleStyle())); 4509 4510 verifyFormat("A<A>> a;", getChromiumStyle(FormatStyle::LK_Cpp)); 4511 4512 verifyFormat("test >> a >> b;"); 4513 verifyFormat("test << a >> b;"); 4514 4515 verifyFormat("f<int>();"); 4516 verifyFormat("template <typename T> void f() {}"); 4517 verifyFormat("struct A<std::enable_if<sizeof(T2) < sizeof(int32)>::type>;"); 4518 verifyFormat("struct A<std::enable_if<sizeof(T2) ? sizeof(int32) : " 4519 "sizeof(char)>::type>;"); 4520 verifyFormat("template <class T> struct S<std::is_arithmetic<T>{}> {};"); 4521 verifyFormat("f(a.operator()<A>());"); 4522 verifyFormat("f(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4523 " .template operator()<A>());", 4524 getLLVMStyleWithColumns(35)); 4525 4526 // Not template parameters. 4527 verifyFormat("return a < b && c > d;"); 4528 verifyFormat("void f() {\n" 4529 " while (a < b && c > d) {\n" 4530 " }\n" 4531 "}"); 4532 verifyFormat("template <typename... Types>\n" 4533 "typename enable_if<0 < sizeof...(Types)>::type Foo() {}"); 4534 4535 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4536 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa >> aaaaa);", 4537 getLLVMStyleWithColumns(60)); 4538 verifyFormat("static_assert(is_convertible<A &&, B>::value, \"AAA\");"); 4539 verifyFormat("Constructor(A... a) : a_(X<A>{std::forward<A>(a)}...) {}"); 4540 verifyFormat("< < < < < < < < < < < < < < < < < < < < < < < < < < < < < <"); 4541 } 4542 4543 TEST_F(FormatTest, BitshiftOperatorWidth) { 4544 EXPECT_EQ("int a = 1 << 2; /* foo\n" 4545 " bar */", 4546 format("int a=1<<2; /* foo\n" 4547 " bar */")); 4548 4549 EXPECT_EQ("int b = 256 >> 1; /* foo\n" 4550 " bar */", 4551 format("int b =256>>1 ; /* foo\n" 4552 " bar */")); 4553 } 4554 4555 TEST_F(FormatTest, UnderstandsBinaryOperators) { 4556 verifyFormat("COMPARE(a, ==, b);"); 4557 verifyFormat("auto s = sizeof...(Ts) - 1;"); 4558 } 4559 4560 TEST_F(FormatTest, UnderstandsPointersToMembers) { 4561 verifyFormat("int A::*x;"); 4562 verifyFormat("int (S::*func)(void *);"); 4563 verifyFormat("void f() { int (S::*func)(void *); }"); 4564 verifyFormat("typedef bool *(Class::*Member)() const;"); 4565 verifyFormat("void f() {\n" 4566 " (a->*f)();\n" 4567 " a->*x;\n" 4568 " (a.*f)();\n" 4569 " ((*a).*f)();\n" 4570 " a.*x;\n" 4571 "}"); 4572 verifyFormat("void f() {\n" 4573 " (a->*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n" 4574 " aaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);\n" 4575 "}"); 4576 verifyFormat( 4577 "(aaaaaaaaaa->*bbbbbbb)(\n" 4578 " aaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 4579 FormatStyle Style = getLLVMStyle(); 4580 Style.PointerAlignment = FormatStyle::PAS_Left; 4581 verifyFormat("typedef bool* (Class::*Member)() const;", Style); 4582 } 4583 4584 TEST_F(FormatTest, UnderstandsUnaryOperators) { 4585 verifyFormat("int a = -2;"); 4586 verifyFormat("f(-1, -2, -3);"); 4587 verifyFormat("a[-1] = 5;"); 4588 verifyFormat("int a = 5 + -2;"); 4589 verifyFormat("if (i == -1) {\n}"); 4590 verifyFormat("if (i != -1) {\n}"); 4591 verifyFormat("if (i > -1) {\n}"); 4592 verifyFormat("if (i < -1) {\n}"); 4593 verifyFormat("++(a->f());"); 4594 verifyFormat("--(a->f());"); 4595 verifyFormat("(a->f())++;"); 4596 verifyFormat("a[42]++;"); 4597 verifyFormat("if (!(a->f())) {\n}"); 4598 4599 verifyFormat("a-- > b;"); 4600 verifyFormat("b ? -a : c;"); 4601 verifyFormat("n * sizeof char16;"); 4602 verifyFormat("n * alignof char16;", getGoogleStyle()); 4603 verifyFormat("sizeof(char);"); 4604 verifyFormat("alignof(char);", getGoogleStyle()); 4605 4606 verifyFormat("return -1;"); 4607 verifyFormat("switch (a) {\n" 4608 "case -1:\n" 4609 " break;\n" 4610 "}"); 4611 verifyFormat("#define X -1"); 4612 verifyFormat("#define X -kConstant"); 4613 4614 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {-5, +3};"); 4615 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {+5, -3};"); 4616 4617 verifyFormat("int a = /* confusing comment */ -1;"); 4618 // FIXME: The space after 'i' is wrong, but hopefully, this is a rare case. 4619 verifyFormat("int a = i /* confusing comment */++;"); 4620 } 4621 4622 TEST_F(FormatTest, DoesNotIndentRelativeToUnaryOperators) { 4623 verifyFormat("if (!aaaaaaaaaa( // break\n" 4624 " aaaaa)) {\n" 4625 "}"); 4626 verifyFormat("aaaaaaaaaa(!aaaaaaaaaa( // break\n" 4627 " aaaaa));"); 4628 verifyFormat("*aaa = aaaaaaa( // break\n" 4629 " bbbbbb);"); 4630 } 4631 4632 TEST_F(FormatTest, UnderstandsOverloadedOperators) { 4633 verifyFormat("bool operator<();"); 4634 verifyFormat("bool operator>();"); 4635 verifyFormat("bool operator=();"); 4636 verifyFormat("bool operator==();"); 4637 verifyFormat("bool operator!=();"); 4638 verifyFormat("int operator+();"); 4639 verifyFormat("int operator++();"); 4640 verifyFormat("bool operator,();"); 4641 verifyFormat("bool operator();"); 4642 verifyFormat("bool operator()();"); 4643 verifyFormat("bool operator[]();"); 4644 verifyFormat("operator bool();"); 4645 verifyFormat("operator int();"); 4646 verifyFormat("operator void *();"); 4647 verifyFormat("operator SomeType<int>();"); 4648 verifyFormat("operator SomeType<int, int>();"); 4649 verifyFormat("operator SomeType<SomeType<int>>();"); 4650 verifyFormat("void *operator new(std::size_t size);"); 4651 verifyFormat("void *operator new[](std::size_t size);"); 4652 verifyFormat("void operator delete(void *ptr);"); 4653 verifyFormat("void operator delete[](void *ptr);"); 4654 verifyFormat("template <typename AAAAAAA, typename BBBBBBB>\n" 4655 "AAAAAAA operator/(const AAAAAAA &a, BBBBBBB &b);"); 4656 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa operator,(\n" 4657 " aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaaaaaaaaaaaaaaaaaaa) const;"); 4658 4659 verifyFormat( 4660 "ostream &operator<<(ostream &OutputStream,\n" 4661 " SomeReallyLongType WithSomeReallyLongValue);"); 4662 verifyFormat("bool operator<(const aaaaaaaaaaaaaaaaaaaaa &left,\n" 4663 " const aaaaaaaaaaaaaaaaaaaaa &right) {\n" 4664 " return left.group < right.group;\n" 4665 "}"); 4666 verifyFormat("SomeType &operator=(const SomeType &S);"); 4667 verifyFormat("f.template operator()<int>();"); 4668 4669 verifyGoogleFormat("operator void*();"); 4670 verifyGoogleFormat("operator SomeType<SomeType<int>>();"); 4671 verifyGoogleFormat("operator ::A();"); 4672 4673 verifyFormat("using A::operator+;"); 4674 verifyFormat("inline A operator^(const A &lhs, const A &rhs) {}\n" 4675 "int i;"); 4676 } 4677 4678 TEST_F(FormatTest, UnderstandsFunctionRefQualification) { 4679 verifyFormat("Deleted &operator=(const Deleted &) & = default;"); 4680 verifyFormat("Deleted &operator=(const Deleted &) && = delete;"); 4681 verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;"); 4682 verifyFormat("SomeType MemberFunction(const Deleted &) && = delete;"); 4683 verifyFormat("Deleted &operator=(const Deleted &) &;"); 4684 verifyFormat("Deleted &operator=(const Deleted &) &&;"); 4685 verifyFormat("SomeType MemberFunction(const Deleted &) &;"); 4686 verifyFormat("SomeType MemberFunction(const Deleted &) &&;"); 4687 verifyFormat("SomeType MemberFunction(const Deleted &) && {}"); 4688 verifyFormat("SomeType MemberFunction(const Deleted &) && final {}"); 4689 verifyFormat("SomeType MemberFunction(const Deleted &) && override {}"); 4690 verifyFormat("SomeType MemberFunction(const Deleted &) const &;"); 4691 verifyFormat("template <typename T>\n" 4692 "void F(T) && = delete;", 4693 getGoogleStyle()); 4694 4695 FormatStyle AlignLeft = getLLVMStyle(); 4696 AlignLeft.PointerAlignment = FormatStyle::PAS_Left; 4697 verifyFormat("void A::b() && {}", AlignLeft); 4698 verifyFormat("Deleted& operator=(const Deleted&) & = default;", AlignLeft); 4699 verifyFormat("SomeType MemberFunction(const Deleted&) & = delete;", 4700 AlignLeft); 4701 verifyFormat("Deleted& operator=(const Deleted&) &;", AlignLeft); 4702 verifyFormat("SomeType MemberFunction(const Deleted&) &;", AlignLeft); 4703 verifyFormat("auto Function(T t) & -> void {}", AlignLeft); 4704 verifyFormat("auto Function(T... t) & -> void {}", AlignLeft); 4705 verifyFormat("auto Function(T) & -> void {}", AlignLeft); 4706 verifyFormat("auto Function(T) & -> void;", AlignLeft); 4707 verifyFormat("SomeType MemberFunction(const Deleted&) const &;", AlignLeft); 4708 4709 FormatStyle Spaces = getLLVMStyle(); 4710 Spaces.SpacesInCStyleCastParentheses = true; 4711 verifyFormat("Deleted &operator=(const Deleted &) & = default;", Spaces); 4712 verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;", Spaces); 4713 verifyFormat("Deleted &operator=(const Deleted &) &;", Spaces); 4714 verifyFormat("SomeType MemberFunction(const Deleted &) &;", Spaces); 4715 4716 Spaces.SpacesInCStyleCastParentheses = false; 4717 Spaces.SpacesInParentheses = true; 4718 verifyFormat("Deleted &operator=( const Deleted & ) & = default;", Spaces); 4719 verifyFormat("SomeType MemberFunction( const Deleted & ) & = delete;", Spaces); 4720 verifyFormat("Deleted &operator=( const Deleted & ) &;", Spaces); 4721 verifyFormat("SomeType MemberFunction( const Deleted & ) &;", Spaces); 4722 } 4723 4724 TEST_F(FormatTest, UnderstandsNewAndDelete) { 4725 verifyFormat("void f() {\n" 4726 " A *a = new A;\n" 4727 " A *a = new (placement) A;\n" 4728 " delete a;\n" 4729 " delete (A *)a;\n" 4730 "}"); 4731 verifyFormat("new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n" 4732 " typename aaaaaaaaaaaaaaaaaaaaaaaa();"); 4733 verifyFormat("auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 4734 " new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n" 4735 " typename aaaaaaaaaaaaaaaaaaaaaaaa();"); 4736 verifyFormat("delete[] h->p;"); 4737 } 4738 4739 TEST_F(FormatTest, UnderstandsUsesOfStarAndAmp) { 4740 verifyFormat("int *f(int *a) {}"); 4741 verifyFormat("int main(int argc, char **argv) {}"); 4742 verifyFormat("Test::Test(int b) : a(b * b) {}"); 4743 verifyIndependentOfContext("f(a, *a);"); 4744 verifyFormat("void g() { f(*a); }"); 4745 verifyIndependentOfContext("int a = b * 10;"); 4746 verifyIndependentOfContext("int a = 10 * b;"); 4747 verifyIndependentOfContext("int a = b * c;"); 4748 verifyIndependentOfContext("int a += b * c;"); 4749 verifyIndependentOfContext("int a -= b * c;"); 4750 verifyIndependentOfContext("int a *= b * c;"); 4751 verifyIndependentOfContext("int a /= b * c;"); 4752 verifyIndependentOfContext("int a = *b;"); 4753 verifyIndependentOfContext("int a = *b * c;"); 4754 verifyIndependentOfContext("int a = b * *c;"); 4755 verifyIndependentOfContext("int a = b * (10);"); 4756 verifyIndependentOfContext("S << b * (10);"); 4757 verifyIndependentOfContext("return 10 * b;"); 4758 verifyIndependentOfContext("return *b * *c;"); 4759 verifyIndependentOfContext("return a & ~b;"); 4760 verifyIndependentOfContext("f(b ? *c : *d);"); 4761 verifyIndependentOfContext("int a = b ? *c : *d;"); 4762 verifyIndependentOfContext("*b = a;"); 4763 verifyIndependentOfContext("a * ~b;"); 4764 verifyIndependentOfContext("a * !b;"); 4765 verifyIndependentOfContext("a * +b;"); 4766 verifyIndependentOfContext("a * -b;"); 4767 verifyIndependentOfContext("a * ++b;"); 4768 verifyIndependentOfContext("a * --b;"); 4769 verifyIndependentOfContext("a[4] * b;"); 4770 verifyIndependentOfContext("a[a * a] = 1;"); 4771 verifyIndependentOfContext("f() * b;"); 4772 verifyIndependentOfContext("a * [self dostuff];"); 4773 verifyIndependentOfContext("int x = a * (a + b);"); 4774 verifyIndependentOfContext("(a *)(a + b);"); 4775 verifyIndependentOfContext("*(int *)(p & ~3UL) = 0;"); 4776 verifyIndependentOfContext("int *pa = (int *)&a;"); 4777 verifyIndependentOfContext("return sizeof(int **);"); 4778 verifyIndependentOfContext("return sizeof(int ******);"); 4779 verifyIndependentOfContext("return (int **&)a;"); 4780 verifyIndependentOfContext("f((*PointerToArray)[10]);"); 4781 verifyFormat("void f(Type (*parameter)[10]) {}"); 4782 verifyFormat("void f(Type (¶meter)[10]) {}"); 4783 verifyGoogleFormat("return sizeof(int**);"); 4784 verifyIndependentOfContext("Type **A = static_cast<Type **>(P);"); 4785 verifyGoogleFormat("Type** A = static_cast<Type**>(P);"); 4786 verifyFormat("auto a = [](int **&, int ***) {};"); 4787 verifyFormat("auto PointerBinding = [](const char *S) {};"); 4788 verifyFormat("typedef typeof(int(int, int)) *MyFunc;"); 4789 verifyFormat("[](const decltype(*a) &value) {}"); 4790 verifyFormat("decltype(a * b) F();"); 4791 verifyFormat("#define MACRO() [](A *a) { return 1; }"); 4792 verifyFormat("Constructor() : member([](A *a, B *b) {}) {}"); 4793 verifyIndependentOfContext("typedef void (*f)(int *a);"); 4794 verifyIndependentOfContext("int i{a * b};"); 4795 verifyIndependentOfContext("aaa && aaa->f();"); 4796 verifyIndependentOfContext("int x = ~*p;"); 4797 verifyFormat("Constructor() : a(a), area(width * height) {}"); 4798 verifyFormat("Constructor() : a(a), area(a, width * height) {}"); 4799 verifyGoogleFormat("MACRO Constructor(const int& i) : a(a), b(b) {}"); 4800 verifyFormat("void f() { f(a, c * d); }"); 4801 verifyFormat("void f() { f(new a(), c * d); }"); 4802 verifyFormat("void f(const MyOverride &override);"); 4803 verifyFormat("void f(const MyFinal &final);"); 4804 verifyIndependentOfContext("bool a = f() && override.f();"); 4805 verifyIndependentOfContext("bool a = f() && final.f();"); 4806 4807 verifyIndependentOfContext("InvalidRegions[*R] = 0;"); 4808 4809 verifyIndependentOfContext("A<int *> a;"); 4810 verifyIndependentOfContext("A<int **> a;"); 4811 verifyIndependentOfContext("A<int *, int *> a;"); 4812 verifyIndependentOfContext("A<int *[]> a;"); 4813 verifyIndependentOfContext( 4814 "const char *const p = reinterpret_cast<const char *const>(q);"); 4815 verifyIndependentOfContext("A<int **, int **> a;"); 4816 verifyIndependentOfContext("void f(int *a = d * e, int *b = c * d);"); 4817 verifyFormat("for (char **a = b; *a; ++a) {\n}"); 4818 verifyFormat("for (; a && b;) {\n}"); 4819 verifyFormat("bool foo = true && [] { return false; }();"); 4820 4821 verifyFormat( 4822 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4823 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa, *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 4824 4825 verifyGoogleFormat("int const* a = &b;"); 4826 verifyGoogleFormat("**outparam = 1;"); 4827 verifyGoogleFormat("*outparam = a * b;"); 4828 verifyGoogleFormat("int main(int argc, char** argv) {}"); 4829 verifyGoogleFormat("A<int*> a;"); 4830 verifyGoogleFormat("A<int**> a;"); 4831 verifyGoogleFormat("A<int*, int*> a;"); 4832 verifyGoogleFormat("A<int**, int**> a;"); 4833 verifyGoogleFormat("f(b ? *c : *d);"); 4834 verifyGoogleFormat("int a = b ? *c : *d;"); 4835 verifyGoogleFormat("Type* t = **x;"); 4836 verifyGoogleFormat("Type* t = *++*x;"); 4837 verifyGoogleFormat("*++*x;"); 4838 verifyGoogleFormat("Type* t = const_cast<T*>(&*x);"); 4839 verifyGoogleFormat("Type* t = x++ * y;"); 4840 verifyGoogleFormat( 4841 "const char* const p = reinterpret_cast<const char* const>(q);"); 4842 verifyGoogleFormat("void f(int i = 0, SomeType** temps = NULL);"); 4843 verifyGoogleFormat("void f(Bar* a = nullptr, Bar* b);"); 4844 verifyGoogleFormat("template <typename T>\n" 4845 "void f(int i = 0, SomeType** temps = NULL);"); 4846 4847 FormatStyle Left = getLLVMStyle(); 4848 Left.PointerAlignment = FormatStyle::PAS_Left; 4849 verifyFormat("x = *a(x) = *a(y);", Left); 4850 verifyFormat("for (;; *a = b) {\n}", Left); 4851 verifyFormat("return *this += 1;", Left); 4852 4853 verifyIndependentOfContext("a = *(x + y);"); 4854 verifyIndependentOfContext("a = &(x + y);"); 4855 verifyIndependentOfContext("*(x + y).call();"); 4856 verifyIndependentOfContext("&(x + y)->call();"); 4857 verifyFormat("void f() { &(*I).first; }"); 4858 4859 verifyIndependentOfContext("f(b * /* confusing comment */ ++c);"); 4860 verifyFormat( 4861 "int *MyValues = {\n" 4862 " *A, // Operator detection might be confused by the '{'\n" 4863 " *BB // Operator detection might be confused by previous comment\n" 4864 "};"); 4865 4866 verifyIndependentOfContext("if (int *a = &b)"); 4867 verifyIndependentOfContext("if (int &a = *b)"); 4868 verifyIndependentOfContext("if (a & b[i])"); 4869 verifyIndependentOfContext("if (a::b::c::d & b[i])"); 4870 verifyIndependentOfContext("if (*b[i])"); 4871 verifyIndependentOfContext("if (int *a = (&b))"); 4872 verifyIndependentOfContext("while (int *a = &b)"); 4873 verifyIndependentOfContext("size = sizeof *a;"); 4874 verifyIndependentOfContext("if (a && (b = c))"); 4875 verifyFormat("void f() {\n" 4876 " for (const int &v : Values) {\n" 4877 " }\n" 4878 "}"); 4879 verifyFormat("for (int i = a * a; i < 10; ++i) {\n}"); 4880 verifyFormat("for (int i = 0; i < a * a; ++i) {\n}"); 4881 verifyGoogleFormat("for (int i = 0; i * 2 < z; i *= 2) {\n}"); 4882 4883 verifyFormat("#define A (!a * b)"); 4884 verifyFormat("#define MACRO \\\n" 4885 " int *i = a * b; \\\n" 4886 " void f(a *b);", 4887 getLLVMStyleWithColumns(19)); 4888 4889 verifyIndependentOfContext("A = new SomeType *[Length];"); 4890 verifyIndependentOfContext("A = new SomeType *[Length]();"); 4891 verifyIndependentOfContext("T **t = new T *;"); 4892 verifyIndependentOfContext("T **t = new T *();"); 4893 verifyGoogleFormat("A = new SomeType*[Length]();"); 4894 verifyGoogleFormat("A = new SomeType*[Length];"); 4895 verifyGoogleFormat("T** t = new T*;"); 4896 verifyGoogleFormat("T** t = new T*();"); 4897 4898 FormatStyle PointerLeft = getLLVMStyle(); 4899 PointerLeft.PointerAlignment = FormatStyle::PAS_Left; 4900 verifyFormat("delete *x;", PointerLeft); 4901 verifyFormat("STATIC_ASSERT((a & b) == 0);"); 4902 verifyFormat("STATIC_ASSERT(0 == (a & b));"); 4903 verifyFormat("template <bool a, bool b> " 4904 "typename t::if<x && y>::type f() {}"); 4905 verifyFormat("template <int *y> f() {}"); 4906 verifyFormat("vector<int *> v;"); 4907 verifyFormat("vector<int *const> v;"); 4908 verifyFormat("vector<int *const **const *> v;"); 4909 verifyFormat("vector<int *volatile> v;"); 4910 verifyFormat("vector<a * b> v;"); 4911 verifyFormat("foo<b && false>();"); 4912 verifyFormat("foo<b & 1>();"); 4913 verifyFormat("decltype(*::std::declval<const T &>()) void F();"); 4914 verifyFormat( 4915 "template <class T, class = typename std::enable_if<\n" 4916 " std::is_integral<T>::value &&\n" 4917 " (sizeof(T) > 1 || sizeof(T) < 8)>::type>\n" 4918 "void F();", 4919 getLLVMStyleWithColumns(70)); 4920 verifyFormat( 4921 "template <class T,\n" 4922 " class = typename std::enable_if<\n" 4923 " std::is_integral<T>::value &&\n" 4924 " (sizeof(T) > 1 || sizeof(T) < 8)>::type,\n" 4925 " class U>\n" 4926 "void F();", 4927 getLLVMStyleWithColumns(70)); 4928 verifyFormat( 4929 "template <class T,\n" 4930 " class = typename ::std::enable_if<\n" 4931 " ::std::is_array<T>{} && ::std::is_array<T>{}>::type>\n" 4932 "void F();", 4933 getGoogleStyleWithColumns(68)); 4934 4935 verifyIndependentOfContext("MACRO(int *i);"); 4936 verifyIndependentOfContext("MACRO(auto *a);"); 4937 verifyIndependentOfContext("MACRO(const A *a);"); 4938 verifyIndependentOfContext("MACRO('0' <= c && c <= '9');"); 4939 verifyFormat("void f() { f(float{1}, a * a); }"); 4940 // FIXME: Is there a way to make this work? 4941 // verifyIndependentOfContext("MACRO(A *a);"); 4942 4943 verifyFormat("DatumHandle const *operator->() const { return input_; }"); 4944 verifyFormat("return options != nullptr && operator==(*options);"); 4945 4946 EXPECT_EQ("#define OP(x) \\\n" 4947 " ostream &operator<<(ostream &s, const A &a) { \\\n" 4948 " return s << a.DebugString(); \\\n" 4949 " }", 4950 format("#define OP(x) \\\n" 4951 " ostream &operator<<(ostream &s, const A &a) { \\\n" 4952 " return s << a.DebugString(); \\\n" 4953 " }", 4954 getLLVMStyleWithColumns(50))); 4955 4956 // FIXME: We cannot handle this case yet; we might be able to figure out that 4957 // foo<x> d > v; doesn't make sense. 4958 verifyFormat("foo<a<b && c> d> v;"); 4959 4960 FormatStyle PointerMiddle = getLLVMStyle(); 4961 PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle; 4962 verifyFormat("delete *x;", PointerMiddle); 4963 verifyFormat("int * x;", PointerMiddle); 4964 verifyFormat("template <int * y> f() {}", PointerMiddle); 4965 verifyFormat("int * f(int * a) {}", PointerMiddle); 4966 verifyFormat("int main(int argc, char ** argv) {}", PointerMiddle); 4967 verifyFormat("Test::Test(int b) : a(b * b) {}", PointerMiddle); 4968 verifyFormat("A<int *> a;", PointerMiddle); 4969 verifyFormat("A<int **> a;", PointerMiddle); 4970 verifyFormat("A<int *, int *> a;", PointerMiddle); 4971 verifyFormat("A<int * []> a;", PointerMiddle); 4972 verifyFormat("A = new SomeType *[Length]();", PointerMiddle); 4973 verifyFormat("A = new SomeType *[Length];", PointerMiddle); 4974 verifyFormat("T ** t = new T *;", PointerMiddle); 4975 4976 // Member function reference qualifiers aren't binary operators. 4977 verifyFormat("string // break\n" 4978 "operator()() & {}"); 4979 verifyFormat("string // break\n" 4980 "operator()() && {}"); 4981 verifyGoogleFormat("template <typename T>\n" 4982 "auto x() & -> int {}"); 4983 } 4984 4985 TEST_F(FormatTest, UnderstandsAttributes) { 4986 verifyFormat("SomeType s __attribute__((unused)) (InitValue);"); 4987 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa __attribute__((unused))\n" 4988 "aaaaaaaaaaaaaaaaaaaaaaa(int i);"); 4989 FormatStyle AfterType = getLLVMStyle(); 4990 AfterType.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions; 4991 verifyFormat("__attribute__((nodebug)) void\n" 4992 "foo() {}\n", 4993 AfterType); 4994 } 4995 4996 TEST_F(FormatTest, UnderstandsEllipsis) { 4997 verifyFormat("int printf(const char *fmt, ...);"); 4998 verifyFormat("template <class... Ts> void Foo(Ts... ts) { Foo(ts...); }"); 4999 verifyFormat("template <class... Ts> void Foo(Ts *... ts) {}"); 5000 5001 FormatStyle PointersLeft = getLLVMStyle(); 5002 PointersLeft.PointerAlignment = FormatStyle::PAS_Left; 5003 verifyFormat("template <class... Ts> void Foo(Ts*... ts) {}", PointersLeft); 5004 } 5005 5006 TEST_F(FormatTest, AdaptivelyFormatsPointersAndReferences) { 5007 EXPECT_EQ("int *a;\n" 5008 "int *a;\n" 5009 "int *a;", 5010 format("int *a;\n" 5011 "int* a;\n" 5012 "int *a;", 5013 getGoogleStyle())); 5014 EXPECT_EQ("int* a;\n" 5015 "int* a;\n" 5016 "int* a;", 5017 format("int* a;\n" 5018 "int* a;\n" 5019 "int *a;", 5020 getGoogleStyle())); 5021 EXPECT_EQ("int *a;\n" 5022 "int *a;\n" 5023 "int *a;", 5024 format("int *a;\n" 5025 "int * a;\n" 5026 "int * a;", 5027 getGoogleStyle())); 5028 EXPECT_EQ("auto x = [] {\n" 5029 " int *a;\n" 5030 " int *a;\n" 5031 " int *a;\n" 5032 "};", 5033 format("auto x=[]{int *a;\n" 5034 "int * a;\n" 5035 "int * a;};", 5036 getGoogleStyle())); 5037 } 5038 5039 TEST_F(FormatTest, UnderstandsRvalueReferences) { 5040 verifyFormat("int f(int &&a) {}"); 5041 verifyFormat("int f(int a, char &&b) {}"); 5042 verifyFormat("void f() { int &&a = b; }"); 5043 verifyGoogleFormat("int f(int a, char&& b) {}"); 5044 verifyGoogleFormat("void f() { int&& a = b; }"); 5045 5046 verifyIndependentOfContext("A<int &&> a;"); 5047 verifyIndependentOfContext("A<int &&, int &&> a;"); 5048 verifyGoogleFormat("A<int&&> a;"); 5049 verifyGoogleFormat("A<int&&, int&&> a;"); 5050 5051 // Not rvalue references: 5052 verifyFormat("template <bool B, bool C> class A {\n" 5053 " static_assert(B && C, \"Something is wrong\");\n" 5054 "};"); 5055 verifyGoogleFormat("#define IF(a, b, c) if (a && (b == c))"); 5056 verifyGoogleFormat("#define WHILE(a, b, c) while (a && (b == c))"); 5057 verifyFormat("#define A(a, b) (a && b)"); 5058 } 5059 5060 TEST_F(FormatTest, FormatsBinaryOperatorsPrecedingEquals) { 5061 verifyFormat("void f() {\n" 5062 " x[aaaaaaaaa -\n" 5063 " b] = 23;\n" 5064 "}", 5065 getLLVMStyleWithColumns(15)); 5066 } 5067 5068 TEST_F(FormatTest, FormatsCasts) { 5069 verifyFormat("Type *A = static_cast<Type *>(P);"); 5070 verifyFormat("Type *A = (Type *)P;"); 5071 verifyFormat("Type *A = (vector<Type *, int *>)P;"); 5072 verifyFormat("int a = (int)(2.0f);"); 5073 verifyFormat("int a = (int)2.0f;"); 5074 verifyFormat("x[(int32)y];"); 5075 verifyFormat("x = (int32)y;"); 5076 verifyFormat("#define AA(X) sizeof(((X *)NULL)->a)"); 5077 verifyFormat("int a = (int)*b;"); 5078 verifyFormat("int a = (int)2.0f;"); 5079 verifyFormat("int a = (int)~0;"); 5080 verifyFormat("int a = (int)++a;"); 5081 verifyFormat("int a = (int)sizeof(int);"); 5082 verifyFormat("int a = (int)+2;"); 5083 verifyFormat("my_int a = (my_int)2.0f;"); 5084 verifyFormat("my_int a = (my_int)sizeof(int);"); 5085 verifyFormat("return (my_int)aaa;"); 5086 verifyFormat("#define x ((int)-1)"); 5087 verifyFormat("#define LENGTH(x, y) (x) - (y) + 1"); 5088 verifyFormat("#define p(q) ((int *)&q)"); 5089 verifyFormat("fn(a)(b) + 1;"); 5090 5091 verifyFormat("void f() { my_int a = (my_int)*b; }"); 5092 verifyFormat("void f() { return P ? (my_int)*P : (my_int)0; }"); 5093 verifyFormat("my_int a = (my_int)~0;"); 5094 verifyFormat("my_int a = (my_int)++a;"); 5095 verifyFormat("my_int a = (my_int)-2;"); 5096 verifyFormat("my_int a = (my_int)1;"); 5097 verifyFormat("my_int a = (my_int *)1;"); 5098 verifyFormat("my_int a = (const my_int)-1;"); 5099 verifyFormat("my_int a = (const my_int *)-1;"); 5100 verifyFormat("my_int a = (my_int)(my_int)-1;"); 5101 verifyFormat("my_int a = (ns::my_int)-2;"); 5102 verifyFormat("case (my_int)ONE:"); 5103 verifyFormat("auto x = (X)this;"); 5104 5105 // FIXME: single value wrapped with paren will be treated as cast. 5106 verifyFormat("void f(int i = (kValue)*kMask) {}"); 5107 5108 verifyFormat("{ (void)F; }"); 5109 5110 // Don't break after a cast's 5111 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 5112 " (aaaaaaaaaaaaaaaaaaaaaaaaaa *)(aaaaaaaaaaaaaaaaaaaaaa +\n" 5113 " bbbbbbbbbbbbbbbbbbbbbb);"); 5114 5115 // These are not casts. 5116 verifyFormat("void f(int *) {}"); 5117 verifyFormat("f(foo)->b;"); 5118 verifyFormat("f(foo).b;"); 5119 verifyFormat("f(foo)(b);"); 5120 verifyFormat("f(foo)[b];"); 5121 verifyFormat("[](foo) { return 4; }(bar);"); 5122 verifyFormat("(*funptr)(foo)[4];"); 5123 verifyFormat("funptrs[4](foo)[4];"); 5124 verifyFormat("void f(int *);"); 5125 verifyFormat("void f(int *) = 0;"); 5126 verifyFormat("void f(SmallVector<int>) {}"); 5127 verifyFormat("void f(SmallVector<int>);"); 5128 verifyFormat("void f(SmallVector<int>) = 0;"); 5129 verifyFormat("void f(int i = (kA * kB) & kMask) {}"); 5130 verifyFormat("int a = sizeof(int) * b;"); 5131 verifyFormat("int a = alignof(int) * b;", getGoogleStyle()); 5132 verifyFormat("template <> void f<int>(int i) SOME_ANNOTATION;"); 5133 verifyFormat("f(\"%\" SOME_MACRO(ll) \"d\");"); 5134 verifyFormat("aaaaa &operator=(const aaaaa &) LLVM_DELETED_FUNCTION;"); 5135 5136 // These are not casts, but at some point were confused with casts. 5137 verifyFormat("virtual void foo(int *) override;"); 5138 verifyFormat("virtual void foo(char &) const;"); 5139 verifyFormat("virtual void foo(int *a, char *) const;"); 5140 verifyFormat("int a = sizeof(int *) + b;"); 5141 verifyFormat("int a = alignof(int *) + b;", getGoogleStyle()); 5142 verifyFormat("bool b = f(g<int>) && c;"); 5143 verifyFormat("typedef void (*f)(int i) func;"); 5144 5145 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *foo = (aaaaaaaaaaaaaaaaa *)\n" 5146 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 5147 // FIXME: The indentation here is not ideal. 5148 verifyFormat( 5149 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5150 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = (*cccccccccccccccc)\n" 5151 " [dddddddddddddddddddddddddddddddddddddddddddddddddddddddd];"); 5152 } 5153 5154 TEST_F(FormatTest, FormatsFunctionTypes) { 5155 verifyFormat("A<bool()> a;"); 5156 verifyFormat("A<SomeType()> a;"); 5157 verifyFormat("A<void (*)(int, std::string)> a;"); 5158 verifyFormat("A<void *(int)>;"); 5159 verifyFormat("void *(*a)(int *, SomeType *);"); 5160 verifyFormat("int (*func)(void *);"); 5161 verifyFormat("void f() { int (*func)(void *); }"); 5162 verifyFormat("template <class CallbackClass>\n" 5163 "using MyCallback = void (CallbackClass::*)(SomeObject *Data);"); 5164 5165 verifyGoogleFormat("A<void*(int*, SomeType*)>;"); 5166 verifyGoogleFormat("void* (*a)(int);"); 5167 verifyGoogleFormat( 5168 "template <class CallbackClass>\n" 5169 "using MyCallback = void (CallbackClass::*)(SomeObject* Data);"); 5170 5171 // Other constructs can look somewhat like function types: 5172 verifyFormat("A<sizeof(*x)> a;"); 5173 verifyFormat("#define DEREF_AND_CALL_F(x) f(*x)"); 5174 verifyFormat("some_var = function(*some_pointer_var)[0];"); 5175 verifyFormat("void f() { function(*some_pointer_var)[0] = 10; }"); 5176 verifyFormat("int x = f(&h)();"); 5177 verifyFormat("returnsFunction(¶m1, ¶m2)(param);"); 5178 } 5179 5180 TEST_F(FormatTest, FormatsPointersToArrayTypes) { 5181 verifyFormat("A (*foo_)[6];"); 5182 verifyFormat("vector<int> (*foo_)[6];"); 5183 } 5184 5185 TEST_F(FormatTest, BreaksLongVariableDeclarations) { 5186 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 5187 " LoooooooooooooooooooooooooooooooooooooooongVariable;"); 5188 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType const\n" 5189 " LoooooooooooooooooooooooooooooooooooooooongVariable;"); 5190 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 5191 " *LoooooooooooooooooooooooooooooooooooooooongVariable;"); 5192 5193 // Different ways of ()-initializiation. 5194 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 5195 " LoooooooooooooooooooooooooooooooooooooooongVariable(1);"); 5196 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 5197 " LoooooooooooooooooooooooooooooooooooooooongVariable(a);"); 5198 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 5199 " LoooooooooooooooooooooooooooooooooooooooongVariable({});"); 5200 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 5201 " LoooooooooooooooooooooooooooooooooooooongVariable([A a]);"); 5202 5203 // Lambdas should not confuse the variable declaration heuristic. 5204 verifyFormat("LooooooooooooooooongType\n" 5205 " variable(nullptr, [](A *a) {});", 5206 getLLVMStyleWithColumns(40)); 5207 } 5208 5209 TEST_F(FormatTest, BreaksLongDeclarations) { 5210 verifyFormat("typedef LoooooooooooooooooooooooooooooooooooooooongType\n" 5211 " AnotherNameForTheLongType;"); 5212 verifyFormat("typedef LongTemplateType<aaaaaaaaaaaaaaaaaaa()>\n" 5213 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5214 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 5215 "LoooooooooooooooooooooooooooooooongFunctionDeclaration();"); 5216 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType *\n" 5217 "LoooooooooooooooooooooooooooooooongFunctionDeclaration();"); 5218 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 5219 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 5220 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType MACRO\n" 5221 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 5222 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType const\n" 5223 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 5224 verifyFormat("decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n" 5225 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 5226 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 5227 "LooooooooooooooooooooooooooongFunctionDeclaration(T... t);"); 5228 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 5229 "LooooooooooooooooooooooooooongFunctionDeclaration(T /*t*/) {}"); 5230 FormatStyle Indented = getLLVMStyle(); 5231 Indented.IndentWrappedFunctionNames = true; 5232 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 5233 " LoooooooooooooooooooooooooooooooongFunctionDeclaration();", 5234 Indented); 5235 verifyFormat( 5236 "LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 5237 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}", 5238 Indented); 5239 verifyFormat( 5240 "LoooooooooooooooooooooooooooooooooooooooongReturnType const\n" 5241 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}", 5242 Indented); 5243 verifyFormat( 5244 "decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n" 5245 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}", 5246 Indented); 5247 5248 // FIXME: Without the comment, this breaks after "(". 5249 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType // break\n" 5250 " (*LoooooooooooooooooooooooooooongFunctionTypeVarialbe)();", 5251 getGoogleStyle()); 5252 5253 verifyFormat("int *someFunction(int LoooooooooooooooooooongParam1,\n" 5254 " int LoooooooooooooooooooongParam2) {}"); 5255 verifyFormat( 5256 "TypeSpecDecl *TypeSpecDecl::Create(ASTContext &C, DeclContext *DC,\n" 5257 " SourceLocation L, IdentifierIn *II,\n" 5258 " Type *T) {}"); 5259 verifyFormat("ReallyLongReturnType<TemplateParam1, TemplateParam2>\n" 5260 "ReallyReaaallyLongFunctionName(\n" 5261 " const std::string &SomeParameter,\n" 5262 " const SomeType<string, SomeOtherTemplateParameter>\n" 5263 " &ReallyReallyLongParameterName,\n" 5264 " const SomeType<string, SomeOtherTemplateParameter>\n" 5265 " &AnotherLongParameterName) {}"); 5266 verifyFormat("template <typename A>\n" 5267 "SomeLoooooooooooooooooooooongType<\n" 5268 " typename some_namespace::SomeOtherType<A>::Type>\n" 5269 "Function() {}"); 5270 5271 verifyGoogleFormat( 5272 "aaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaa<aaaaaaaaaaaaa, aaaaaaaaaaaa>\n" 5273 " aaaaaaaaaaaaaaaaaaaaaaa;"); 5274 verifyGoogleFormat( 5275 "TypeSpecDecl* TypeSpecDecl::Create(ASTContext& C, DeclContext* DC,\n" 5276 " SourceLocation L) {}"); 5277 verifyGoogleFormat( 5278 "some_namespace::LongReturnType\n" 5279 "long_namespace::SomeVeryLongClass::SomeVeryLongFunction(\n" 5280 " int first_long_parameter, int second_parameter) {}"); 5281 5282 verifyGoogleFormat("template <typename T>\n" 5283 "aaaaaaaa::aaaaa::aaaaaa<T, aaaaaaaaaaaaaaaaaaaaaaaaa>\n" 5284 "aaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaa() {}"); 5285 verifyGoogleFormat("A<A<A>> aaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5286 " int aaaaaaaaaaaaaaaaaaaaaaa);"); 5287 5288 verifyFormat("typedef size_t (*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n" 5289 " const aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5290 " *aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5291 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5292 " vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n" 5293 " aaaaaaaaaaaaaaaaaaaaaaaa);"); 5294 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5295 " vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n" 5296 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>>\n" 5297 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5298 } 5299 5300 TEST_F(FormatTest, FormatsArrays) { 5301 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaaaaaaaaaa]\n" 5302 " [bbbbbbbbbbbbbbbbbbbbbbbbb] = c;"); 5303 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaa(aaaaaaaaaaaa)]\n" 5304 " [bbbbbbbbbbb(bbbbbbbbbbbb)] = c;"); 5305 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaa &&\n" 5306 " aaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaa][aaaaaaaaaaaaa]) {\n}"); 5307 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5308 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;"); 5309 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5310 " [a][bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = cccccccc;"); 5311 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5312 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n" 5313 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;"); 5314 verifyFormat( 5315 "llvm::outs() << \"aaaaaaaaaaaa: \"\n" 5316 " << (*aaaaaaaiaaaaaaa)[aaaaaaaaaaaaaaaaaaaaaaaaa]\n" 5317 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa];"); 5318 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaa][a]\n" 5319 " .aaaaaaaaaaaaaaaaaaaaaa();"); 5320 5321 verifyGoogleFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<int>\n" 5322 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaa];"); 5323 verifyFormat( 5324 "aaaaaaaaaaa aaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaa->aaaaaaaaa[0]\n" 5325 " .aaaaaaa[0]\n" 5326 " .aaaaaaaaaaaaaaaaaaaaaa();"); 5327 verifyFormat("a[::b::c];"); 5328 5329 verifyNoCrash("a[,Y?)]", getLLVMStyleWithColumns(10)); 5330 5331 FormatStyle NoColumnLimit = getLLVMStyleWithColumns(0); 5332 verifyFormat("aaaaa[bbbbbb].cccccc()", NoColumnLimit); 5333 } 5334 5335 TEST_F(FormatTest, LineStartsWithSpecialCharacter) { 5336 verifyFormat("(a)->b();"); 5337 verifyFormat("--a;"); 5338 } 5339 5340 TEST_F(FormatTest, HandlesIncludeDirectives) { 5341 verifyFormat("#include <string>\n" 5342 "#include <a/b/c.h>\n" 5343 "#include \"a/b/string\"\n" 5344 "#include \"string.h\"\n" 5345 "#include \"string.h\"\n" 5346 "#include <a-a>\n" 5347 "#include < path with space >\n" 5348 "#include_next <test.h>" 5349 "#include \"abc.h\" // this is included for ABC\n" 5350 "#include \"some long include\" // with a comment\n" 5351 "#include \"some very long include paaaaaaaaaaaaaaaaaaaaaaath\"", 5352 getLLVMStyleWithColumns(35)); 5353 EXPECT_EQ("#include \"a.h\"", format("#include \"a.h\"")); 5354 EXPECT_EQ("#include <a>", format("#include<a>")); 5355 5356 verifyFormat("#import <string>"); 5357 verifyFormat("#import <a/b/c.h>"); 5358 verifyFormat("#import \"a/b/string\""); 5359 verifyFormat("#import \"string.h\""); 5360 verifyFormat("#import \"string.h\""); 5361 verifyFormat("#if __has_include(<strstream>)\n" 5362 "#include <strstream>\n" 5363 "#endif"); 5364 5365 verifyFormat("#define MY_IMPORT <a/b>"); 5366 5367 verifyFormat("#if __has_include(<a/b>)"); 5368 verifyFormat("#if __has_include_next(<a/b>)"); 5369 verifyFormat("#define F __has_include(<a/b>)"); 5370 verifyFormat("#define F __has_include_next(<a/b>)"); 5371 5372 // Protocol buffer definition or missing "#". 5373 verifyFormat("import \"aaaaaaaaaaaaaaaaa/aaaaaaaaaaaaaaa\";", 5374 getLLVMStyleWithColumns(30)); 5375 5376 FormatStyle Style = getLLVMStyle(); 5377 Style.AlwaysBreakBeforeMultilineStrings = true; 5378 Style.ColumnLimit = 0; 5379 verifyFormat("#import \"abc.h\"", Style); 5380 5381 // But 'import' might also be a regular C++ namespace. 5382 verifyFormat("import::SomeFunction(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5383 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5384 } 5385 5386 //===----------------------------------------------------------------------===// 5387 // Error recovery tests. 5388 //===----------------------------------------------------------------------===// 5389 5390 TEST_F(FormatTest, IncompleteParameterLists) { 5391 FormatStyle NoBinPacking = getLLVMStyle(); 5392 NoBinPacking.BinPackParameters = false; 5393 verifyFormat("void aaaaaaaaaaaaaaaaaa(int level,\n" 5394 " double *min_x,\n" 5395 " double *max_x,\n" 5396 " double *min_y,\n" 5397 " double *max_y,\n" 5398 " double *min_z,\n" 5399 " double *max_z, ) {}", 5400 NoBinPacking); 5401 } 5402 5403 TEST_F(FormatTest, IncorrectCodeTrailingStuff) { 5404 verifyFormat("void f() { return; }\n42"); 5405 verifyFormat("void f() {\n" 5406 " if (0)\n" 5407 " return;\n" 5408 "}\n" 5409 "42"); 5410 verifyFormat("void f() { return }\n42"); 5411 verifyFormat("void f() {\n" 5412 " if (0)\n" 5413 " return\n" 5414 "}\n" 5415 "42"); 5416 } 5417 5418 TEST_F(FormatTest, IncorrectCodeMissingSemicolon) { 5419 EXPECT_EQ("void f() { return }", format("void f ( ) { return }")); 5420 EXPECT_EQ("void f() {\n" 5421 " if (a)\n" 5422 " return\n" 5423 "}", 5424 format("void f ( ) { if ( a ) return }")); 5425 EXPECT_EQ("namespace N {\n" 5426 "void f()\n" 5427 "}", 5428 format("namespace N { void f() }")); 5429 EXPECT_EQ("namespace N {\n" 5430 "void f() {}\n" 5431 "void g()\n" 5432 "}", 5433 format("namespace N { void f( ) { } void g( ) }")); 5434 } 5435 5436 TEST_F(FormatTest, IndentationWithinColumnLimitNotPossible) { 5437 verifyFormat("int aaaaaaaa =\n" 5438 " // Overlylongcomment\n" 5439 " b;", 5440 getLLVMStyleWithColumns(20)); 5441 verifyFormat("function(\n" 5442 " ShortArgument,\n" 5443 " LoooooooooooongArgument);\n", 5444 getLLVMStyleWithColumns(20)); 5445 } 5446 5447 TEST_F(FormatTest, IncorrectAccessSpecifier) { 5448 verifyFormat("public:"); 5449 verifyFormat("class A {\n" 5450 "public\n" 5451 " void f() {}\n" 5452 "};"); 5453 verifyFormat("public\n" 5454 "int qwerty;"); 5455 verifyFormat("public\n" 5456 "B {}"); 5457 verifyFormat("public\n" 5458 "{}"); 5459 verifyFormat("public\n" 5460 "B { int x; }"); 5461 } 5462 5463 TEST_F(FormatTest, IncorrectCodeUnbalancedBraces) { 5464 verifyFormat("{"); 5465 verifyFormat("#})"); 5466 verifyNoCrash("(/**/[:!] ?[)."); 5467 } 5468 5469 TEST_F(FormatTest, IncorrectCodeDoNoWhile) { 5470 verifyFormat("do {\n}"); 5471 verifyFormat("do {\n}\n" 5472 "f();"); 5473 verifyFormat("do {\n}\n" 5474 "wheeee(fun);"); 5475 verifyFormat("do {\n" 5476 " f();\n" 5477 "}"); 5478 } 5479 5480 TEST_F(FormatTest, IncorrectCodeMissingParens) { 5481 verifyFormat("if {\n foo;\n foo();\n}"); 5482 verifyFormat("switch {\n foo;\n foo();\n}"); 5483 verifyIncompleteFormat("for {\n foo;\n foo();\n}"); 5484 verifyFormat("while {\n foo;\n foo();\n}"); 5485 verifyFormat("do {\n foo;\n foo();\n} while;"); 5486 } 5487 5488 TEST_F(FormatTest, DoesNotTouchUnwrappedLinesWithErrors) { 5489 verifyIncompleteFormat("namespace {\n" 5490 "class Foo { Foo (\n" 5491 "};\n" 5492 "} // comment"); 5493 } 5494 5495 TEST_F(FormatTest, IncorrectCodeErrorDetection) { 5496 EXPECT_EQ("{\n {}\n", format("{\n{\n}\n")); 5497 EXPECT_EQ("{\n {}\n", format("{\n {\n}\n")); 5498 EXPECT_EQ("{\n {}\n", format("{\n {\n }\n")); 5499 EXPECT_EQ("{\n {}\n}\n}\n", format("{\n {\n }\n }\n}\n")); 5500 5501 EXPECT_EQ("{\n" 5502 " {\n" 5503 " breakme(\n" 5504 " qwe);\n" 5505 " }\n", 5506 format("{\n" 5507 " {\n" 5508 " breakme(qwe);\n" 5509 "}\n", 5510 getLLVMStyleWithColumns(10))); 5511 } 5512 5513 TEST_F(FormatTest, LayoutCallsInsideBraceInitializers) { 5514 verifyFormat("int x = {\n" 5515 " avariable,\n" 5516 " b(alongervariable)};", 5517 getLLVMStyleWithColumns(25)); 5518 } 5519 5520 TEST_F(FormatTest, LayoutBraceInitializersInReturnStatement) { 5521 verifyFormat("return (a)(b){1, 2, 3};"); 5522 } 5523 5524 TEST_F(FormatTest, LayoutCxx11BraceInitializers) { 5525 verifyFormat("vector<int> x{1, 2, 3, 4};"); 5526 verifyFormat("vector<int> x{\n" 5527 " 1, 2, 3, 4,\n" 5528 "};"); 5529 verifyFormat("vector<T> x{{}, {}, {}, {}};"); 5530 verifyFormat("f({1, 2});"); 5531 verifyFormat("auto v = Foo{-1};"); 5532 verifyFormat("f({1, 2}, {{2, 3}, {4, 5}}, c, {d});"); 5533 verifyFormat("Class::Class : member{1, 2, 3} {}"); 5534 verifyFormat("new vector<int>{1, 2, 3};"); 5535 verifyFormat("new int[3]{1, 2, 3};"); 5536 verifyFormat("new int{1};"); 5537 verifyFormat("return {arg1, arg2};"); 5538 verifyFormat("return {arg1, SomeType{parameter}};"); 5539 verifyFormat("int count = set<int>{f(), g(), h()}.size();"); 5540 verifyFormat("new T{arg1, arg2};"); 5541 verifyFormat("f(MyMap[{composite, key}]);"); 5542 verifyFormat("class Class {\n" 5543 " T member = {arg1, arg2};\n" 5544 "};"); 5545 verifyFormat("vector<int> foo = {::SomeGlobalFunction()};"); 5546 verifyFormat("static_assert(std::is_integral<int>{} + 0, \"\");"); 5547 verifyFormat("int a = std::is_integral<int>{} + 0;"); 5548 5549 verifyFormat("int foo(int i) { return fo1{}(i); }"); 5550 verifyFormat("int foo(int i) { return fo1{}(i); }"); 5551 verifyFormat("auto i = decltype(x){};"); 5552 verifyFormat("std::vector<int> v = {1, 0 /* comment */};"); 5553 verifyFormat("Node n{1, Node{1000}, //\n" 5554 " 2};"); 5555 verifyFormat("Aaaa aaaaaaa{\n" 5556 " {\n" 5557 " aaaa,\n" 5558 " },\n" 5559 "};"); 5560 verifyFormat("class C : public D {\n" 5561 " SomeClass SC{2};\n" 5562 "};"); 5563 verifyFormat("class C : public A {\n" 5564 " class D : public B {\n" 5565 " void f() { int i{2}; }\n" 5566 " };\n" 5567 "};"); 5568 verifyFormat("#define A {a, a},"); 5569 5570 // Cases where distinguising braced lists and blocks is hard. 5571 verifyFormat("vector<int> v{12} GUARDED_BY(mutex);"); 5572 verifyFormat("void f() {\n" 5573 " return; // comment\n" 5574 "}\n" 5575 "SomeType t;"); 5576 verifyFormat("void f() {\n" 5577 " if (a) {\n" 5578 " f();\n" 5579 " }\n" 5580 "}\n" 5581 "SomeType t;"); 5582 5583 // In combination with BinPackArguments = false. 5584 FormatStyle NoBinPacking = getLLVMStyle(); 5585 NoBinPacking.BinPackArguments = false; 5586 verifyFormat("const Aaaaaa aaaaa = {aaaaa,\n" 5587 " bbbbb,\n" 5588 " ccccc,\n" 5589 " ddddd,\n" 5590 " eeeee,\n" 5591 " ffffff,\n" 5592 " ggggg,\n" 5593 " hhhhhh,\n" 5594 " iiiiii,\n" 5595 " jjjjjj,\n" 5596 " kkkkkk};", 5597 NoBinPacking); 5598 verifyFormat("const Aaaaaa aaaaa = {\n" 5599 " aaaaa,\n" 5600 " bbbbb,\n" 5601 " ccccc,\n" 5602 " ddddd,\n" 5603 " eeeee,\n" 5604 " ffffff,\n" 5605 " ggggg,\n" 5606 " hhhhhh,\n" 5607 " iiiiii,\n" 5608 " jjjjjj,\n" 5609 " kkkkkk,\n" 5610 "};", 5611 NoBinPacking); 5612 verifyFormat( 5613 "const Aaaaaa aaaaa = {\n" 5614 " aaaaa, bbbbb, ccccc, ddddd, eeeee, ffffff, ggggg, hhhhhh,\n" 5615 " iiiiii, jjjjjj, kkkkkk, aaaaa, bbbbb, ccccc, ddddd, eeeee,\n" 5616 " ffffff, ggggg, hhhhhh, iiiiii, jjjjjj, kkkkkk,\n" 5617 "};", 5618 NoBinPacking); 5619 5620 // FIXME: The alignment of these trailing comments might be bad. Then again, 5621 // this might be utterly useless in real code. 5622 verifyFormat("Constructor::Constructor()\n" 5623 " : some_value{ //\n" 5624 " aaaaaaa, //\n" 5625 " bbbbbbb} {}"); 5626 5627 // In braced lists, the first comment is always assumed to belong to the 5628 // first element. Thus, it can be moved to the next or previous line as 5629 // appropriate. 5630 EXPECT_EQ("function({// First element:\n" 5631 " 1,\n" 5632 " // Second element:\n" 5633 " 2});", 5634 format("function({\n" 5635 " // First element:\n" 5636 " 1,\n" 5637 " // Second element:\n" 5638 " 2});")); 5639 EXPECT_EQ("std::vector<int> MyNumbers{\n" 5640 " // First element:\n" 5641 " 1,\n" 5642 " // Second element:\n" 5643 " 2};", 5644 format("std::vector<int> MyNumbers{// First element:\n" 5645 " 1,\n" 5646 " // Second element:\n" 5647 " 2};", 5648 getLLVMStyleWithColumns(30))); 5649 // A trailing comma should still lead to an enforced line break. 5650 EXPECT_EQ("vector<int> SomeVector = {\n" 5651 " // aaa\n" 5652 " 1, 2,\n" 5653 "};", 5654 format("vector<int> SomeVector = { // aaa\n" 5655 " 1, 2, };")); 5656 5657 FormatStyle ExtraSpaces = getLLVMStyle(); 5658 ExtraSpaces.Cpp11BracedListStyle = false; 5659 ExtraSpaces.ColumnLimit = 75; 5660 verifyFormat("vector<int> x{ 1, 2, 3, 4 };", ExtraSpaces); 5661 verifyFormat("vector<T> x{ {}, {}, {}, {} };", ExtraSpaces); 5662 verifyFormat("f({ 1, 2 });", ExtraSpaces); 5663 verifyFormat("auto v = Foo{ 1 };", ExtraSpaces); 5664 verifyFormat("f({ 1, 2 }, { { 2, 3 }, { 4, 5 } }, c, { d });", ExtraSpaces); 5665 verifyFormat("Class::Class : member{ 1, 2, 3 } {}", ExtraSpaces); 5666 verifyFormat("new vector<int>{ 1, 2, 3 };", ExtraSpaces); 5667 verifyFormat("new int[3]{ 1, 2, 3 };", ExtraSpaces); 5668 verifyFormat("return { arg1, arg2 };", ExtraSpaces); 5669 verifyFormat("return { arg1, SomeType{ parameter } };", ExtraSpaces); 5670 verifyFormat("int count = set<int>{ f(), g(), h() }.size();", ExtraSpaces); 5671 verifyFormat("new T{ arg1, arg2 };", ExtraSpaces); 5672 verifyFormat("f(MyMap[{ composite, key }]);", ExtraSpaces); 5673 verifyFormat("class Class {\n" 5674 " T member = { arg1, arg2 };\n" 5675 "};", 5676 ExtraSpaces); 5677 verifyFormat( 5678 "foo = aaaaaaaaaaa ? vector<int>{ aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5679 " aaaaaaaaaaaaaaaaaaaa, aaaaa }\n" 5680 " : vector<int>{ bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" 5681 " bbbbbbbbbbbbbbbbbbbb, bbbbb };", 5682 ExtraSpaces); 5683 verifyFormat("DoSomethingWithVector({} /* No data */);", ExtraSpaces); 5684 verifyFormat("DoSomethingWithVector({ {} /* No data */ }, { { 1, 2 } });", 5685 ExtraSpaces); 5686 verifyFormat( 5687 "someFunction(OtherParam,\n" 5688 " BracedList{ // comment 1 (Forcing interesting break)\n" 5689 " param1, param2,\n" 5690 " // comment 2\n" 5691 " param3, param4 });", 5692 ExtraSpaces); 5693 verifyFormat( 5694 "std::this_thread::sleep_for(\n" 5695 " std::chrono::nanoseconds{ std::chrono::seconds{ 1 } } / 5);", 5696 ExtraSpaces); 5697 verifyFormat("std::vector<MyValues> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa{\n" 5698 " aaaaaaa,\n" 5699 " aaaaaaaaaa,\n" 5700 " aaaaa,\n" 5701 " aaaaaaaaaaaaaaa,\n" 5702 " aaa,\n" 5703 " aaaaaaaaaa,\n" 5704 " a,\n" 5705 " aaaaaaaaaaaaaaaaaaaaa,\n" 5706 " aaaaaaaaaaaa,\n" 5707 " aaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaa,\n" 5708 " aaaaaaa,\n" 5709 " a};"); 5710 verifyFormat("vector<int> foo = { ::SomeGlobalFunction() };", ExtraSpaces); 5711 } 5712 5713 TEST_F(FormatTest, FormatsBracedListsInColumnLayout) { 5714 verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n" 5715 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 5716 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 5717 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 5718 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 5719 " 1, 22, 333, 4444, 55555, 666666, 7777777};"); 5720 verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777, //\n" 5721 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 5722 " 1, 22, 333, 4444, 55555, //\n" 5723 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 5724 " 1, 22, 333, 4444, 55555, 666666, 7777777};"); 5725 verifyFormat( 5726 "vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n" 5727 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 5728 " 1, 22, 333, 4444, 55555, 666666, // comment\n" 5729 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 5730 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 5731 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 5732 " 7777777};"); 5733 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n" 5734 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n" 5735 " X86::R8, X86::R9, X86::R10, X86::R11, 0};"); 5736 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n" 5737 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n" 5738 " // Separating comment.\n" 5739 " X86::R8, X86::R9, X86::R10, X86::R11, 0};"); 5740 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n" 5741 " // Leading comment\n" 5742 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n" 5743 " X86::R8, X86::R9, X86::R10, X86::R11, 0};"); 5744 verifyFormat("vector<int> x = {1, 1, 1, 1,\n" 5745 " 1, 1, 1, 1};", 5746 getLLVMStyleWithColumns(39)); 5747 verifyFormat("vector<int> x = {1, 1, 1, 1,\n" 5748 " 1, 1, 1, 1};", 5749 getLLVMStyleWithColumns(38)); 5750 verifyFormat("vector<int> aaaaaaaaaaaaaaaaaaaaaa = {\n" 5751 " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};", 5752 getLLVMStyleWithColumns(43)); 5753 verifyFormat( 5754 "static unsigned SomeValues[10][3] = {\n" 5755 " {1, 4, 0}, {4, 9, 0}, {4, 5, 9}, {8, 5, 4}, {1, 8, 4},\n" 5756 " {10, 1, 6}, {11, 0, 9}, {2, 11, 9}, {5, 2, 9}, {11, 2, 7}};"); 5757 verifyFormat("static auto fields = new vector<string>{\n" 5758 " \"aaaaaaaaaaaaa\",\n" 5759 " \"aaaaaaaaaaaaa\",\n" 5760 " \"aaaaaaaaaaaa\",\n" 5761 " \"aaaaaaaaaaaaaa\",\n" 5762 " \"aaaaaaaaaaaaaaaaaaaaaaaaa\",\n" 5763 " \"aaaaaaaaaaaa\",\n" 5764 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",\n" 5765 "};"); 5766 verifyFormat("vector<int> x = {1, 2, 3, 4, aaaaaaaaaaaaaaaaa, 6};"); 5767 verifyFormat("vector<int> x = {1, aaaaaaaaaaaaaaaaaaaaaa,\n" 5768 " 2, bbbbbbbbbbbbbbbbbbbbbb,\n" 5769 " 3, cccccccccccccccccccccc};", 5770 getLLVMStyleWithColumns(60)); 5771 5772 // Trailing commas. 5773 verifyFormat("vector<int> x = {\n" 5774 " 1, 1, 1, 1, 1, 1, 1, 1,\n" 5775 "};", 5776 getLLVMStyleWithColumns(39)); 5777 verifyFormat("vector<int> x = {\n" 5778 " 1, 1, 1, 1, 1, 1, 1, 1, //\n" 5779 "};", 5780 getLLVMStyleWithColumns(39)); 5781 verifyFormat("vector<int> x = {1, 1, 1, 1,\n" 5782 " 1, 1, 1, 1,\n" 5783 " /**/ /**/};", 5784 getLLVMStyleWithColumns(39)); 5785 5786 // Trailing comment in the first line. 5787 verifyFormat("vector<int> iiiiiiiiiiiiiii = { //\n" 5788 " 1111111111, 2222222222, 33333333333, 4444444444, //\n" 5789 " 111111111, 222222222, 3333333333, 444444444, //\n" 5790 " 11111111, 22222222, 333333333, 44444444};"); 5791 // Trailing comment in the last line. 5792 verifyFormat("int aaaaa[] = {\n" 5793 " 1, 2, 3, // comment\n" 5794 " 4, 5, 6 // comment\n" 5795 "};"); 5796 5797 // With nested lists, we should either format one item per line or all nested 5798 // lists one on line. 5799 // FIXME: For some nested lists, we can do better. 5800 verifyFormat("return {{aaaaaaaaaaaaaaaaaaaaa},\n" 5801 " {aaaaaaaaaaaaaaaaaaa},\n" 5802 " {aaaaaaaaaaaaaaaaaaaaa},\n" 5803 " {aaaaaaaaaaaaaaaaa}};", 5804 getLLVMStyleWithColumns(60)); 5805 verifyFormat( 5806 "SomeStruct my_struct_array = {\n" 5807 " {aaaaaa, aaaaaaaa, aaaaaaaaaa, aaaaaaaaa, aaaaaaaaa, aaaaaaaaaa,\n" 5808 " aaaaaaaaaaaaa, aaaaaaa, aaa},\n" 5809 " {aaa, aaa},\n" 5810 " {aaa, aaa},\n" 5811 " {aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaa},\n" 5812 " {aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaa,\n" 5813 " aaaaaaaaaaaa, a, aaaaaaaaaa, aaaaaaaaa, aaa}};"); 5814 5815 // No column layout should be used here. 5816 verifyFormat("aaaaaaaaaaaaaaa = {aaaaaaaaaaaaaaaaaaaaaaaaaaa, 0, 0,\n" 5817 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb};"); 5818 5819 verifyNoCrash("a<,"); 5820 5821 // No braced initializer here. 5822 verifyFormat("void f() {\n" 5823 " struct Dummy {};\n" 5824 " f(v);\n" 5825 "}"); 5826 5827 // Long lists should be formatted in columns even if they are nested. 5828 verifyFormat( 5829 "vector<int> x = function({1, 22, 333, 4444, 55555, 666666, 7777777,\n" 5830 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 5831 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 5832 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 5833 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 5834 " 1, 22, 333, 4444, 55555, 666666, 7777777});"); 5835 5836 // Allow "single-column" layout even if that violates the column limit. There 5837 // isn't going to be a better way. 5838 verifyFormat("std::vector<int> a = {\n" 5839 " aaaaaaaa,\n" 5840 " aaaaaaaa,\n" 5841 " aaaaaaaa,\n" 5842 " aaaaaaaa,\n" 5843 " aaaaaaaaaa,\n" 5844 " aaaaaaaa,\n" 5845 " aaaaaaaaaaaaaaaaaaaaaaaaaaa};", 5846 getLLVMStyleWithColumns(30)); 5847 verifyFormat("vector<int> aaaa = {\n" 5848 " aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5849 " aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5850 " aaaaaa.aaaaaaa,\n" 5851 " aaaaaa.aaaaaaa,\n" 5852 " aaaaaa.aaaaaaa,\n" 5853 " aaaaaa.aaaaaaa,\n" 5854 "};"); 5855 5856 // Don't create hanging lists. 5857 verifyFormat("someFunction(Param, {List1, List2,\n" 5858 " List3});", 5859 getLLVMStyleWithColumns(35)); 5860 verifyFormat("someFunction(Param, Param,\n" 5861 " {List1, List2,\n" 5862 " List3});", 5863 getLLVMStyleWithColumns(35)); 5864 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa, {},\n" 5865 " aaaaaaaaaaaaaaaaaaaaaaa);"); 5866 } 5867 5868 TEST_F(FormatTest, PullTrivialFunctionDefinitionsIntoSingleLine) { 5869 FormatStyle DoNotMerge = getLLVMStyle(); 5870 DoNotMerge.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 5871 5872 verifyFormat("void f() { return 42; }"); 5873 verifyFormat("void f() {\n" 5874 " return 42;\n" 5875 "}", 5876 DoNotMerge); 5877 verifyFormat("void f() {\n" 5878 " // Comment\n" 5879 "}"); 5880 verifyFormat("{\n" 5881 "#error {\n" 5882 " int a;\n" 5883 "}"); 5884 verifyFormat("{\n" 5885 " int a;\n" 5886 "#error {\n" 5887 "}"); 5888 verifyFormat("void f() {} // comment"); 5889 verifyFormat("void f() { int a; } // comment"); 5890 verifyFormat("void f() {\n" 5891 "} // comment", 5892 DoNotMerge); 5893 verifyFormat("void f() {\n" 5894 " int a;\n" 5895 "} // comment", 5896 DoNotMerge); 5897 verifyFormat("void f() {\n" 5898 "} // comment", 5899 getLLVMStyleWithColumns(15)); 5900 5901 verifyFormat("void f() { return 42; }", getLLVMStyleWithColumns(23)); 5902 verifyFormat("void f() {\n return 42;\n}", getLLVMStyleWithColumns(22)); 5903 5904 verifyFormat("void f() {}", getLLVMStyleWithColumns(11)); 5905 verifyFormat("void f() {\n}", getLLVMStyleWithColumns(10)); 5906 verifyFormat("class C {\n" 5907 " C()\n" 5908 " : iiiiiiii(nullptr),\n" 5909 " kkkkkkk(nullptr),\n" 5910 " mmmmmmm(nullptr),\n" 5911 " nnnnnnn(nullptr) {}\n" 5912 "};", 5913 getGoogleStyle()); 5914 5915 FormatStyle NoColumnLimit = getLLVMStyle(); 5916 NoColumnLimit.ColumnLimit = 0; 5917 EXPECT_EQ("A() : b(0) {}", format("A():b(0){}", NoColumnLimit)); 5918 EXPECT_EQ("class C {\n" 5919 " A() : b(0) {}\n" 5920 "};", 5921 format("class C{A():b(0){}};", NoColumnLimit)); 5922 EXPECT_EQ("A()\n" 5923 " : b(0) {\n" 5924 "}", 5925 format("A()\n:b(0)\n{\n}", NoColumnLimit)); 5926 5927 FormatStyle DoNotMergeNoColumnLimit = NoColumnLimit; 5928 DoNotMergeNoColumnLimit.AllowShortFunctionsOnASingleLine = 5929 FormatStyle::SFS_None; 5930 EXPECT_EQ("A()\n" 5931 " : b(0) {\n" 5932 "}", 5933 format("A():b(0){}", DoNotMergeNoColumnLimit)); 5934 EXPECT_EQ("A()\n" 5935 " : b(0) {\n" 5936 "}", 5937 format("A()\n:b(0)\n{\n}", DoNotMergeNoColumnLimit)); 5938 5939 verifyFormat("#define A \\\n" 5940 " void f() { \\\n" 5941 " int i; \\\n" 5942 " }", 5943 getLLVMStyleWithColumns(20)); 5944 verifyFormat("#define A \\\n" 5945 " void f() { int i; }", 5946 getLLVMStyleWithColumns(21)); 5947 verifyFormat("#define A \\\n" 5948 " void f() { \\\n" 5949 " int i; \\\n" 5950 " } \\\n" 5951 " int j;", 5952 getLLVMStyleWithColumns(22)); 5953 verifyFormat("#define A \\\n" 5954 " void f() { int i; } \\\n" 5955 " int j;", 5956 getLLVMStyleWithColumns(23)); 5957 } 5958 5959 TEST_F(FormatTest, PullInlineFunctionDefinitionsIntoSingleLine) { 5960 FormatStyle MergeInlineOnly = getLLVMStyle(); 5961 MergeInlineOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; 5962 verifyFormat("class C {\n" 5963 " int f() { return 42; }\n" 5964 "};", 5965 MergeInlineOnly); 5966 verifyFormat("int f() {\n" 5967 " return 42;\n" 5968 "}", 5969 MergeInlineOnly); 5970 } 5971 5972 TEST_F(FormatTest, UnderstandContextOfRecordTypeKeywords) { 5973 // Elaborate type variable declarations. 5974 verifyFormat("struct foo a = {bar};\nint n;"); 5975 verifyFormat("class foo a = {bar};\nint n;"); 5976 verifyFormat("union foo a = {bar};\nint n;"); 5977 5978 // Elaborate types inside function definitions. 5979 verifyFormat("struct foo f() {}\nint n;"); 5980 verifyFormat("class foo f() {}\nint n;"); 5981 verifyFormat("union foo f() {}\nint n;"); 5982 5983 // Templates. 5984 verifyFormat("template <class X> void f() {}\nint n;"); 5985 verifyFormat("template <struct X> void f() {}\nint n;"); 5986 verifyFormat("template <union X> void f() {}\nint n;"); 5987 5988 // Actual definitions... 5989 verifyFormat("struct {\n} n;"); 5990 verifyFormat( 5991 "template <template <class T, class Y>, class Z> class X {\n} n;"); 5992 verifyFormat("union Z {\n int n;\n} x;"); 5993 verifyFormat("class MACRO Z {\n} n;"); 5994 verifyFormat("class MACRO(X) Z {\n} n;"); 5995 verifyFormat("class __attribute__(X) Z {\n} n;"); 5996 verifyFormat("class __declspec(X) Z {\n} n;"); 5997 verifyFormat("class A##B##C {\n} n;"); 5998 verifyFormat("class alignas(16) Z {\n} n;"); 5999 verifyFormat("class MACRO(X) alignas(16) Z {\n} n;"); 6000 verifyFormat("class MACROA MACRO(X) Z {\n} n;"); 6001 6002 // Redefinition from nested context: 6003 verifyFormat("class A::B::C {\n} n;"); 6004 6005 // Template definitions. 6006 verifyFormat( 6007 "template <typename F>\n" 6008 "Matcher(const Matcher<F> &Other,\n" 6009 " typename enable_if_c<is_base_of<F, T>::value &&\n" 6010 " !is_same<F, T>::value>::type * = 0)\n" 6011 " : Implementation(new ImplicitCastMatcher<F>(Other)) {}"); 6012 6013 // FIXME: This is still incorrectly handled at the formatter side. 6014 verifyFormat("template <> struct X < 15, i<3 && 42 < 50 && 33 < 28> {};"); 6015 verifyFormat("int i = SomeFunction(a<b, a> b);"); 6016 6017 // FIXME: 6018 // This now gets parsed incorrectly as class definition. 6019 // verifyFormat("class A<int> f() {\n}\nint n;"); 6020 6021 // Elaborate types where incorrectly parsing the structural element would 6022 // break the indent. 6023 verifyFormat("if (true)\n" 6024 " class X x;\n" 6025 "else\n" 6026 " f();\n"); 6027 6028 // This is simply incomplete. Formatting is not important, but must not crash. 6029 verifyFormat("class A:"); 6030 } 6031 6032 TEST_F(FormatTest, DoNotInterfereWithErrorAndWarning) { 6033 EXPECT_EQ("#error Leave all white!!!!! space* alone!\n", 6034 format("#error Leave all white!!!!! space* alone!\n")); 6035 EXPECT_EQ( 6036 "#warning Leave all white!!!!! space* alone!\n", 6037 format("#warning Leave all white!!!!! space* alone!\n")); 6038 EXPECT_EQ("#error 1", format(" # error 1")); 6039 EXPECT_EQ("#warning 1", format(" # warning 1")); 6040 } 6041 6042 TEST_F(FormatTest, FormatHashIfExpressions) { 6043 verifyFormat("#if AAAA && BBBB"); 6044 verifyFormat("#if (AAAA && BBBB)"); 6045 verifyFormat("#elif (AAAA && BBBB)"); 6046 // FIXME: Come up with a better indentation for #elif. 6047 verifyFormat( 6048 "#if !defined(AAAAAAA) && (defined CCCCCC || defined DDDDDD) && \\\n" 6049 " defined(BBBBBBBB)\n" 6050 "#elif !defined(AAAAAA) && (defined CCCCC || defined DDDDDD) && \\\n" 6051 " defined(BBBBBBBB)\n" 6052 "#endif", 6053 getLLVMStyleWithColumns(65)); 6054 } 6055 6056 TEST_F(FormatTest, MergeHandlingInTheFaceOfPreprocessorDirectives) { 6057 FormatStyle AllowsMergedIf = getGoogleStyle(); 6058 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = true; 6059 verifyFormat("void f() { f(); }\n#error E", AllowsMergedIf); 6060 verifyFormat("if (true) return 42;\n#error E", AllowsMergedIf); 6061 verifyFormat("if (true)\n#error E\n return 42;", AllowsMergedIf); 6062 EXPECT_EQ("if (true) return 42;", 6063 format("if (true)\nreturn 42;", AllowsMergedIf)); 6064 FormatStyle ShortMergedIf = AllowsMergedIf; 6065 ShortMergedIf.ColumnLimit = 25; 6066 verifyFormat("#define A \\\n" 6067 " if (true) return 42;", 6068 ShortMergedIf); 6069 verifyFormat("#define A \\\n" 6070 " f(); \\\n" 6071 " if (true)\n" 6072 "#define B", 6073 ShortMergedIf); 6074 verifyFormat("#define A \\\n" 6075 " f(); \\\n" 6076 " if (true)\n" 6077 "g();", 6078 ShortMergedIf); 6079 verifyFormat("{\n" 6080 "#ifdef A\n" 6081 " // Comment\n" 6082 " if (true) continue;\n" 6083 "#endif\n" 6084 " // Comment\n" 6085 " if (true) continue;\n" 6086 "}", 6087 ShortMergedIf); 6088 ShortMergedIf.ColumnLimit = 29; 6089 verifyFormat("#define A \\\n" 6090 " if (aaaaaaaaaa) return 1; \\\n" 6091 " return 2;", 6092 ShortMergedIf); 6093 ShortMergedIf.ColumnLimit = 28; 6094 verifyFormat("#define A \\\n" 6095 " if (aaaaaaaaaa) \\\n" 6096 " return 1; \\\n" 6097 " return 2;", 6098 ShortMergedIf); 6099 } 6100 6101 TEST_F(FormatTest, FormatStarDependingOnContext) { 6102 verifyFormat("void f(int *a);"); 6103 verifyFormat("void f() { f(fint * b); }"); 6104 verifyFormat("class A {\n void f(int *a);\n};"); 6105 verifyFormat("class A {\n int *a;\n};"); 6106 verifyFormat("namespace a {\n" 6107 "namespace b {\n" 6108 "class A {\n" 6109 " void f() {}\n" 6110 " int *a;\n" 6111 "};\n" 6112 "}\n" 6113 "}"); 6114 } 6115 6116 TEST_F(FormatTest, SpecialTokensAtEndOfLine) { 6117 verifyFormat("while"); 6118 verifyFormat("operator"); 6119 } 6120 6121 TEST_F(FormatTest, SkipsDeeplyNestedLines) { 6122 // This code would be painfully slow to format if we didn't skip it. 6123 std::string Code("A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" // 20x 6124 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 6125 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 6126 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 6127 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 6128 "A(1, 1)\n" 6129 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" // 10x 6130 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 6131 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 6132 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 6133 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 6134 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 6135 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 6136 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 6137 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 6138 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1);\n"); 6139 // Deeply nested part is untouched, rest is formatted. 6140 EXPECT_EQ(std::string("int i;\n") + Code + "int j;\n", 6141 format(std::string("int i;\n") + Code + "int j;\n", 6142 getLLVMStyle(), IC_ExpectIncomplete)); 6143 } 6144 6145 //===----------------------------------------------------------------------===// 6146 // Objective-C tests. 6147 //===----------------------------------------------------------------------===// 6148 6149 TEST_F(FormatTest, FormatForObjectiveCMethodDecls) { 6150 verifyFormat("- (void)sendAction:(SEL)aSelector to:(BOOL)anObject;"); 6151 EXPECT_EQ("- (NSUInteger)indexOfObject:(id)anObject;", 6152 format("-(NSUInteger)indexOfObject:(id)anObject;")); 6153 EXPECT_EQ("- (NSInteger)Mthod1;", format("-(NSInteger)Mthod1;")); 6154 EXPECT_EQ("+ (id)Mthod2;", format("+(id)Mthod2;")); 6155 EXPECT_EQ("- (NSInteger)Method3:(id)anObject;", 6156 format("-(NSInteger)Method3:(id)anObject;")); 6157 EXPECT_EQ("- (NSInteger)Method4:(id)anObject;", 6158 format("-(NSInteger)Method4:(id)anObject;")); 6159 EXPECT_EQ("- (NSInteger)Method5:(id)anObject:(id)AnotherObject;", 6160 format("-(NSInteger)Method5:(id)anObject:(id)AnotherObject;")); 6161 EXPECT_EQ("- (id)Method6:(id)A:(id)B:(id)C:(id)D;", 6162 format("- (id)Method6:(id)A:(id)B:(id)C:(id)D;")); 6163 EXPECT_EQ("- (void)sendAction:(SEL)aSelector to:(id)anObject " 6164 "forAllCells:(BOOL)flag;", 6165 format("- (void)sendAction:(SEL)aSelector to:(id)anObject " 6166 "forAllCells:(BOOL)flag;")); 6167 6168 // Very long objectiveC method declaration. 6169 verifyFormat("- (void)aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n" 6170 " (SoooooooooooooooooooooomeType *)bbbbbbbbbb;"); 6171 verifyFormat("- (NSUInteger)indexOfObject:(id)anObject\n" 6172 " inRange:(NSRange)range\n" 6173 " outRange:(NSRange)out_range\n" 6174 " outRange1:(NSRange)out_range1\n" 6175 " outRange2:(NSRange)out_range2\n" 6176 " outRange3:(NSRange)out_range3\n" 6177 " outRange4:(NSRange)out_range4\n" 6178 " outRange5:(NSRange)out_range5\n" 6179 " outRange6:(NSRange)out_range6\n" 6180 " outRange7:(NSRange)out_range7\n" 6181 " outRange8:(NSRange)out_range8\n" 6182 " outRange9:(NSRange)out_range9;"); 6183 6184 // When the function name has to be wrapped. 6185 FormatStyle Style = getLLVMStyle(); 6186 Style.IndentWrappedFunctionNames = false; 6187 verifyFormat("- (SomeLooooooooooooooooooooongType *)\n" 6188 "veryLooooooooooongName:(NSString)aaaaaaaaaaaaaa\n" 6189 " anotherName:(NSString)bbbbbbbbbbbbbb {\n" 6190 "}", 6191 Style); 6192 Style.IndentWrappedFunctionNames = true; 6193 verifyFormat("- (SomeLooooooooooooooooooooongType *)\n" 6194 " veryLooooooooooongName:(NSString)aaaaaaaaaaaaaa\n" 6195 " anotherName:(NSString)bbbbbbbbbbbbbb {\n" 6196 "}", 6197 Style); 6198 6199 verifyFormat("- (int)sum:(vector<int>)numbers;"); 6200 verifyGoogleFormat("- (void)setDelegate:(id<Protocol>)delegate;"); 6201 // FIXME: In LLVM style, there should be a space in front of a '<' for ObjC 6202 // protocol lists (but not for template classes): 6203 // verifyFormat("- (void)setDelegate:(id <Protocol>)delegate;"); 6204 6205 verifyFormat("- (int (*)())foo:(int (*)())f;"); 6206 verifyGoogleFormat("- (int (*)())foo:(int (*)())foo;"); 6207 6208 // If there's no return type (very rare in practice!), LLVM and Google style 6209 // agree. 6210 verifyFormat("- foo;"); 6211 verifyFormat("- foo:(int)f;"); 6212 verifyGoogleFormat("- foo:(int)foo;"); 6213 } 6214 6215 6216 TEST_F(FormatTest, BreaksStringLiterals) { 6217 EXPECT_EQ("\"some text \"\n" 6218 "\"other\";", 6219 format("\"some text other\";", getLLVMStyleWithColumns(12))); 6220 EXPECT_EQ("\"some text \"\n" 6221 "\"other\";", 6222 format("\\\n\"some text other\";", getLLVMStyleWithColumns(12))); 6223 EXPECT_EQ( 6224 "#define A \\\n" 6225 " \"some \" \\\n" 6226 " \"text \" \\\n" 6227 " \"other\";", 6228 format("#define A \"some text other\";", getLLVMStyleWithColumns(12))); 6229 EXPECT_EQ( 6230 "#define A \\\n" 6231 " \"so \" \\\n" 6232 " \"text \" \\\n" 6233 " \"other\";", 6234 format("#define A \"so text other\";", getLLVMStyleWithColumns(12))); 6235 6236 EXPECT_EQ("\"some text\"", 6237 format("\"some text\"", getLLVMStyleWithColumns(1))); 6238 EXPECT_EQ("\"some text\"", 6239 format("\"some text\"", getLLVMStyleWithColumns(11))); 6240 EXPECT_EQ("\"some \"\n" 6241 "\"text\"", 6242 format("\"some text\"", getLLVMStyleWithColumns(10))); 6243 EXPECT_EQ("\"some \"\n" 6244 "\"text\"", 6245 format("\"some text\"", getLLVMStyleWithColumns(7))); 6246 EXPECT_EQ("\"some\"\n" 6247 "\" tex\"\n" 6248 "\"t\"", 6249 format("\"some text\"", getLLVMStyleWithColumns(6))); 6250 EXPECT_EQ("\"some\"\n" 6251 "\" tex\"\n" 6252 "\" and\"", 6253 format("\"some tex and\"", getLLVMStyleWithColumns(6))); 6254 EXPECT_EQ("\"some\"\n" 6255 "\"/tex\"\n" 6256 "\"/and\"", 6257 format("\"some/tex/and\"", getLLVMStyleWithColumns(6))); 6258 6259 EXPECT_EQ("variable =\n" 6260 " \"long string \"\n" 6261 " \"literal\";", 6262 format("variable = \"long string literal\";", 6263 getLLVMStyleWithColumns(20))); 6264 6265 EXPECT_EQ("variable = f(\n" 6266 " \"long string \"\n" 6267 " \"literal\",\n" 6268 " short,\n" 6269 " loooooooooooooooooooong);", 6270 format("variable = f(\"long string literal\", short, " 6271 "loooooooooooooooooooong);", 6272 getLLVMStyleWithColumns(20))); 6273 6274 EXPECT_EQ( 6275 "f(g(\"long string \"\n" 6276 " \"literal\"),\n" 6277 " b);", 6278 format("f(g(\"long string literal\"), b);", getLLVMStyleWithColumns(20))); 6279 EXPECT_EQ("f(g(\"long string \"\n" 6280 " \"literal\",\n" 6281 " a),\n" 6282 " b);", 6283 format("f(g(\"long string literal\", a), b);", 6284 getLLVMStyleWithColumns(20))); 6285 EXPECT_EQ( 6286 "f(\"one two\".split(\n" 6287 " variable));", 6288 format("f(\"one two\".split(variable));", getLLVMStyleWithColumns(20))); 6289 EXPECT_EQ("f(\"one two three four five six \"\n" 6290 " \"seven\".split(\n" 6291 " really_looooong_variable));", 6292 format("f(\"one two three four five six seven\"." 6293 "split(really_looooong_variable));", 6294 getLLVMStyleWithColumns(33))); 6295 6296 EXPECT_EQ("f(\"some \"\n" 6297 " \"text\",\n" 6298 " other);", 6299 format("f(\"some text\", other);", getLLVMStyleWithColumns(10))); 6300 6301 // Only break as a last resort. 6302 verifyFormat( 6303 "aaaaaaaaaaaaaaaaaaaa(\n" 6304 " aaaaaaaaaaaaaaaaaaaa,\n" 6305 " aaaaaa(\"aaa aaaaa aaa aaa aaaaa aaa aaaaa aaa aaa aaaaaa\"));"); 6306 6307 EXPECT_EQ("\"splitmea\"\n" 6308 "\"trandomp\"\n" 6309 "\"oint\"", 6310 format("\"splitmeatrandompoint\"", getLLVMStyleWithColumns(10))); 6311 6312 EXPECT_EQ("\"split/\"\n" 6313 "\"pathat/\"\n" 6314 "\"slashes\"", 6315 format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10))); 6316 6317 EXPECT_EQ("\"split/\"\n" 6318 "\"pathat/\"\n" 6319 "\"slashes\"", 6320 format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10))); 6321 EXPECT_EQ("\"split at \"\n" 6322 "\"spaces/at/\"\n" 6323 "\"slashes.at.any$\"\n" 6324 "\"non-alphanumeric%\"\n" 6325 "\"1111111111characte\"\n" 6326 "\"rs\"", 6327 format("\"split at " 6328 "spaces/at/" 6329 "slashes.at." 6330 "any$non-" 6331 "alphanumeric%" 6332 "1111111111characte" 6333 "rs\"", 6334 getLLVMStyleWithColumns(20))); 6335 6336 // Verify that splitting the strings understands 6337 // Style::AlwaysBreakBeforeMultilineStrings. 6338 EXPECT_EQ( 6339 "aaaaaaaaaaaa(\n" 6340 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa \"\n" 6341 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\");", 6342 format("aaaaaaaaaaaa(\"aaaaaaaaaaaaaaaaaaaaaaaaaa " 6343 "aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa " 6344 "aaaaaaaaaaaaaaaaaaaaaa\");", 6345 getGoogleStyle())); 6346 EXPECT_EQ("return \"aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 6347 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\";", 6348 format("return \"aaaaaaaaaaaaaaaaaaaaaa " 6349 "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa " 6350 "aaaaaaaaaaaaaaaaaaaaaa\";", 6351 getGoogleStyle())); 6352 EXPECT_EQ("llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 6353 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";", 6354 format("llvm::outs() << " 6355 "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa" 6356 "aaaaaaaaaaaaaaaaaaa\";")); 6357 EXPECT_EQ("ffff(\n" 6358 " {\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 6359 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});", 6360 format("ffff({\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa " 6361 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});", 6362 getGoogleStyle())); 6363 6364 FormatStyle Style = getLLVMStyleWithColumns(12); 6365 Style.BreakStringLiterals = false; 6366 EXPECT_EQ("\"some text other\";", format("\"some text other\";", Style)); 6367 6368 FormatStyle AlignLeft = getLLVMStyleWithColumns(12); 6369 AlignLeft.AlignEscapedNewlinesLeft = true; 6370 EXPECT_EQ("#define A \\\n" 6371 " \"some \" \\\n" 6372 " \"text \" \\\n" 6373 " \"other\";", 6374 format("#define A \"some text other\";", AlignLeft)); 6375 } 6376 6377 TEST_F(FormatTest, FullyRemoveEmptyLines) { 6378 FormatStyle NoEmptyLines = getLLVMStyleWithColumns(80); 6379 NoEmptyLines.MaxEmptyLinesToKeep = 0; 6380 EXPECT_EQ("int i = a(b());", 6381 format("int i=a(\n\n b(\n\n\n )\n\n);", NoEmptyLines)); 6382 } 6383 6384 TEST_F(FormatTest, BreaksStringLiteralsWithTabs) { 6385 EXPECT_EQ( 6386 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 6387 "(\n" 6388 " \"x\t\");", 6389 format("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 6390 "aaaaaaa(" 6391 "\"x\t\");")); 6392 } 6393 6394 TEST_F(FormatTest, BreaksWideAndNSStringLiterals) { 6395 EXPECT_EQ( 6396 "u8\"utf8 string \"\n" 6397 "u8\"literal\";", 6398 format("u8\"utf8 string literal\";", getGoogleStyleWithColumns(16))); 6399 EXPECT_EQ( 6400 "u\"utf16 string \"\n" 6401 "u\"literal\";", 6402 format("u\"utf16 string literal\";", getGoogleStyleWithColumns(16))); 6403 EXPECT_EQ( 6404 "U\"utf32 string \"\n" 6405 "U\"literal\";", 6406 format("U\"utf32 string literal\";", getGoogleStyleWithColumns(16))); 6407 EXPECT_EQ("L\"wide string \"\n" 6408 "L\"literal\";", 6409 format("L\"wide string literal\";", getGoogleStyleWithColumns(16))); 6410 EXPECT_EQ("@\"NSString \"\n" 6411 "@\"literal\";", 6412 format("@\"NSString literal\";", getGoogleStyleWithColumns(19))); 6413 6414 // This input makes clang-format try to split the incomplete unicode escape 6415 // sequence, which used to lead to a crasher. 6416 verifyNoCrash( 6417 "aaaaaaaaaaaaaaaaaaaa = L\"\\udff\"'; // aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 6418 getLLVMStyleWithColumns(60)); 6419 } 6420 6421 TEST_F(FormatTest, DoesNotBreakRawStringLiterals) { 6422 FormatStyle Style = getGoogleStyleWithColumns(15); 6423 EXPECT_EQ("R\"x(raw literal)x\";", format("R\"x(raw literal)x\";", Style)); 6424 EXPECT_EQ("uR\"x(raw literal)x\";", format("uR\"x(raw literal)x\";", Style)); 6425 EXPECT_EQ("LR\"x(raw literal)x\";", format("LR\"x(raw literal)x\";", Style)); 6426 EXPECT_EQ("UR\"x(raw literal)x\";", format("UR\"x(raw literal)x\";", Style)); 6427 EXPECT_EQ("u8R\"x(raw literal)x\";", 6428 format("u8R\"x(raw literal)x\";", Style)); 6429 } 6430 6431 TEST_F(FormatTest, BreaksStringLiteralsWithin_TMacro) { 6432 FormatStyle Style = getLLVMStyleWithColumns(20); 6433 EXPECT_EQ( 6434 "_T(\"aaaaaaaaaaaaaa\")\n" 6435 "_T(\"aaaaaaaaaaaaaa\")\n" 6436 "_T(\"aaaaaaaaaaaa\")", 6437 format(" _T(\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\")", Style)); 6438 EXPECT_EQ("f(x, _T(\"aaaaaaaaa\")\n" 6439 " _T(\"aaaaaa\"),\n" 6440 " z);", 6441 format("f(x, _T(\"aaaaaaaaaaaaaaa\"), z);", Style)); 6442 6443 // FIXME: Handle embedded spaces in one iteration. 6444 // EXPECT_EQ("_T(\"aaaaaaaaaaaaa\")\n" 6445 // "_T(\"aaaaaaaaaaaaa\")\n" 6446 // "_T(\"aaaaaaaaaaaaa\")\n" 6447 // "_T(\"a\")", 6448 // format(" _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", 6449 // getLLVMStyleWithColumns(20))); 6450 EXPECT_EQ( 6451 "_T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", 6452 format(" _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", Style)); 6453 EXPECT_EQ("f(\n" 6454 "#if !TEST\n" 6455 " _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n" 6456 "#endif\n" 6457 " );", 6458 format("f(\n" 6459 "#if !TEST\n" 6460 "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n" 6461 "#endif\n" 6462 ");")); 6463 EXPECT_EQ("f(\n" 6464 "\n" 6465 " _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));", 6466 format("f(\n" 6467 "\n" 6468 "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));")); 6469 } 6470 6471 TEST_F(FormatTest, DontSplitStringLiteralsWithEscapedNewlines) { 6472 EXPECT_EQ( 6473 "aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 6474 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 6475 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";", 6476 format("aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 6477 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 6478 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";")); 6479 } 6480 6481 TEST_F(FormatTest, CountsCharactersInMultilineRawStringLiterals) { 6482 EXPECT_EQ("f(g(R\"x(raw literal)x\", a), b);", 6483 format("f(g(R\"x(raw literal)x\", a), b);", getGoogleStyle())); 6484 EXPECT_EQ("fffffffffff(g(R\"x(\n" 6485 "multiline raw string literal xxxxxxxxxxxxxx\n" 6486 ")x\",\n" 6487 " a),\n" 6488 " b);", 6489 format("fffffffffff(g(R\"x(\n" 6490 "multiline raw string literal xxxxxxxxxxxxxx\n" 6491 ")x\", a), b);", 6492 getGoogleStyleWithColumns(20))); 6493 EXPECT_EQ("fffffffffff(\n" 6494 " g(R\"x(qqq\n" 6495 "multiline raw string literal xxxxxxxxxxxxxx\n" 6496 ")x\",\n" 6497 " a),\n" 6498 " b);", 6499 format("fffffffffff(g(R\"x(qqq\n" 6500 "multiline raw string literal xxxxxxxxxxxxxx\n" 6501 ")x\", a), b);", 6502 getGoogleStyleWithColumns(20))); 6503 6504 EXPECT_EQ("fffffffffff(R\"x(\n" 6505 "multiline raw string literal xxxxxxxxxxxxxx\n" 6506 ")x\");", 6507 format("fffffffffff(R\"x(\n" 6508 "multiline raw string literal xxxxxxxxxxxxxx\n" 6509 ")x\");", 6510 getGoogleStyleWithColumns(20))); 6511 EXPECT_EQ("fffffffffff(R\"x(\n" 6512 "multiline raw string literal xxxxxxxxxxxxxx\n" 6513 ")x\" + bbbbbb);", 6514 format("fffffffffff(R\"x(\n" 6515 "multiline raw string literal xxxxxxxxxxxxxx\n" 6516 ")x\" + bbbbbb);", 6517 getGoogleStyleWithColumns(20))); 6518 EXPECT_EQ("fffffffffff(\n" 6519 " R\"x(\n" 6520 "multiline raw string literal xxxxxxxxxxxxxx\n" 6521 ")x\" +\n" 6522 " bbbbbb);", 6523 format("fffffffffff(\n" 6524 " R\"x(\n" 6525 "multiline raw string literal xxxxxxxxxxxxxx\n" 6526 ")x\" + bbbbbb);", 6527 getGoogleStyleWithColumns(20))); 6528 } 6529 6530 TEST_F(FormatTest, SkipsUnknownStringLiterals) { 6531 verifyFormat("string a = \"unterminated;"); 6532 EXPECT_EQ("function(\"unterminated,\n" 6533 " OtherParameter);", 6534 format("function( \"unterminated,\n" 6535 " OtherParameter);")); 6536 } 6537 6538 TEST_F(FormatTest, DoesNotTryToParseUDLiteralsInPreCpp11Code) { 6539 FormatStyle Style = getLLVMStyle(); 6540 Style.Standard = FormatStyle::LS_Cpp03; 6541 EXPECT_EQ("#define x(_a) printf(\"foo\" _a);", 6542 format("#define x(_a) printf(\"foo\"_a);", Style)); 6543 } 6544 6545 TEST_F(FormatTest, UnderstandsCpp1y) { verifyFormat("int bi{1'000'000};"); } 6546 6547 TEST_F(FormatTest, BreakStringLiteralsBeforeUnbreakableTokenSequence) { 6548 EXPECT_EQ("someFunction(\"aaabbbcccd\"\n" 6549 " \"ddeeefff\");", 6550 format("someFunction(\"aaabbbcccdddeeefff\");", 6551 getLLVMStyleWithColumns(25))); 6552 EXPECT_EQ("someFunction1234567890(\n" 6553 " \"aaabbbcccdddeeefff\");", 6554 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 6555 getLLVMStyleWithColumns(26))); 6556 EXPECT_EQ("someFunction1234567890(\n" 6557 " \"aaabbbcccdddeeeff\"\n" 6558 " \"f\");", 6559 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 6560 getLLVMStyleWithColumns(25))); 6561 EXPECT_EQ("someFunction1234567890(\n" 6562 " \"aaabbbcccdddeeeff\"\n" 6563 " \"f\");", 6564 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 6565 getLLVMStyleWithColumns(24))); 6566 EXPECT_EQ("someFunction(\"aaabbbcc \"\n" 6567 " \"ddde \"\n" 6568 " \"efff\");", 6569 format("someFunction(\"aaabbbcc ddde efff\");", 6570 getLLVMStyleWithColumns(25))); 6571 EXPECT_EQ("someFunction(\"aaabbbccc \"\n" 6572 " \"ddeeefff\");", 6573 format("someFunction(\"aaabbbccc ddeeefff\");", 6574 getLLVMStyleWithColumns(25))); 6575 EXPECT_EQ("someFunction1234567890(\n" 6576 " \"aaabb \"\n" 6577 " \"cccdddeeefff\");", 6578 format("someFunction1234567890(\"aaabb cccdddeeefff\");", 6579 getLLVMStyleWithColumns(25))); 6580 EXPECT_EQ("#define A \\\n" 6581 " string s = \\\n" 6582 " \"123456789\" \\\n" 6583 " \"0\"; \\\n" 6584 " int i;", 6585 format("#define A string s = \"1234567890\"; int i;", 6586 getLLVMStyleWithColumns(20))); 6587 // FIXME: Put additional penalties on breaking at non-whitespace locations. 6588 EXPECT_EQ("someFunction(\"aaabbbcc \"\n" 6589 " \"dddeeeff\"\n" 6590 " \"f\");", 6591 format("someFunction(\"aaabbbcc dddeeefff\");", 6592 getLLVMStyleWithColumns(25))); 6593 } 6594 6595 TEST_F(FormatTest, DoNotBreakStringLiteralsInEscapeSequence) { 6596 EXPECT_EQ("\"\\a\"", format("\"\\a\"", getLLVMStyleWithColumns(3))); 6597 EXPECT_EQ("\"\\\"", format("\"\\\"", getLLVMStyleWithColumns(2))); 6598 EXPECT_EQ("\"test\"\n" 6599 "\"\\n\"", 6600 format("\"test\\n\"", getLLVMStyleWithColumns(7))); 6601 EXPECT_EQ("\"tes\\\\\"\n" 6602 "\"n\"", 6603 format("\"tes\\\\n\"", getLLVMStyleWithColumns(7))); 6604 EXPECT_EQ("\"\\\\\\\\\"\n" 6605 "\"\\n\"", 6606 format("\"\\\\\\\\\\n\"", getLLVMStyleWithColumns(7))); 6607 EXPECT_EQ("\"\\uff01\"", format("\"\\uff01\"", getLLVMStyleWithColumns(7))); 6608 EXPECT_EQ("\"\\uff01\"\n" 6609 "\"test\"", 6610 format("\"\\uff01test\"", getLLVMStyleWithColumns(8))); 6611 EXPECT_EQ("\"\\Uff01ff02\"", 6612 format("\"\\Uff01ff02\"", getLLVMStyleWithColumns(11))); 6613 EXPECT_EQ("\"\\x000000000001\"\n" 6614 "\"next\"", 6615 format("\"\\x000000000001next\"", getLLVMStyleWithColumns(16))); 6616 EXPECT_EQ("\"\\x000000000001next\"", 6617 format("\"\\x000000000001next\"", getLLVMStyleWithColumns(15))); 6618 EXPECT_EQ("\"\\x000000000001\"", 6619 format("\"\\x000000000001\"", getLLVMStyleWithColumns(7))); 6620 EXPECT_EQ("\"test\"\n" 6621 "\"\\000000\"\n" 6622 "\"000001\"", 6623 format("\"test\\000000000001\"", getLLVMStyleWithColumns(9))); 6624 EXPECT_EQ("\"test\\000\"\n" 6625 "\"00000000\"\n" 6626 "\"1\"", 6627 format("\"test\\000000000001\"", getLLVMStyleWithColumns(10))); 6628 } 6629 6630 TEST_F(FormatTest, DoNotCreateUnreasonableUnwrappedLines) { 6631 verifyFormat("void f() {\n" 6632 " return g() {}\n" 6633 " void h() {}"); 6634 verifyFormat("int a[] = {void forgot_closing_brace(){f();\n" 6635 "g();\n" 6636 "}"); 6637 } 6638 6639 TEST_F(FormatTest, DoNotPrematurelyEndUnwrappedLineForReturnStatements) { 6640 verifyFormat( 6641 "void f() { return C{param1, param2}.SomeCall(param1, param2); }"); 6642 } 6643 6644 TEST_F(FormatTest, FormatsClosingBracesInEmptyNestedBlocks) { 6645 verifyFormat("class X {\n" 6646 " void f() {\n" 6647 " }\n" 6648 "};", 6649 getLLVMStyleWithColumns(12)); 6650 } 6651 6652 TEST_F(FormatTest, ConfigurableIndentWidth) { 6653 FormatStyle EightIndent = getLLVMStyleWithColumns(18); 6654 EightIndent.IndentWidth = 8; 6655 EightIndent.ContinuationIndentWidth = 8; 6656 verifyFormat("void f() {\n" 6657 " someFunction();\n" 6658 " if (true) {\n" 6659 " f();\n" 6660 " }\n" 6661 "}", 6662 EightIndent); 6663 verifyFormat("class X {\n" 6664 " void f() {\n" 6665 " }\n" 6666 "};", 6667 EightIndent); 6668 verifyFormat("int x[] = {\n" 6669 " call(),\n" 6670 " call()};", 6671 EightIndent); 6672 } 6673 6674 TEST_F(FormatTest, ConfigurableFunctionDeclarationIndentAfterType) { 6675 verifyFormat("double\n" 6676 "f();", 6677 getLLVMStyleWithColumns(8)); 6678 } 6679 6680 TEST_F(FormatTest, ConfigurableUseOfTab) { 6681 FormatStyle Tab = getLLVMStyleWithColumns(42); 6682 Tab.IndentWidth = 8; 6683 Tab.UseTab = FormatStyle::UT_Always; 6684 Tab.AlignEscapedNewlinesLeft = true; 6685 6686 EXPECT_EQ("if (aaaaaaaa && // q\n" 6687 " bb)\t\t// w\n" 6688 "\t;", 6689 format("if (aaaaaaaa &&// q\n" 6690 "bb)// w\n" 6691 ";", 6692 Tab)); 6693 EXPECT_EQ("if (aaa && bbb) // w\n" 6694 "\t;", 6695 format("if(aaa&&bbb)// w\n" 6696 ";", 6697 Tab)); 6698 6699 verifyFormat("class X {\n" 6700 "\tvoid f() {\n" 6701 "\t\tsomeFunction(parameter1,\n" 6702 "\t\t\t parameter2);\n" 6703 "\t}\n" 6704 "};", 6705 Tab); 6706 verifyFormat("#define A \\\n" 6707 "\tvoid f() { \\\n" 6708 "\t\tsomeFunction( \\\n" 6709 "\t\t parameter1, \\\n" 6710 "\t\t parameter2); \\\n" 6711 "\t}", 6712 Tab); 6713 6714 Tab.TabWidth = 4; 6715 Tab.IndentWidth = 8; 6716 verifyFormat("class TabWidth4Indent8 {\n" 6717 "\t\tvoid f() {\n" 6718 "\t\t\t\tsomeFunction(parameter1,\n" 6719 "\t\t\t\t\t\t\t parameter2);\n" 6720 "\t\t}\n" 6721 "};", 6722 Tab); 6723 6724 Tab.TabWidth = 4; 6725 Tab.IndentWidth = 4; 6726 verifyFormat("class TabWidth4Indent4 {\n" 6727 "\tvoid f() {\n" 6728 "\t\tsomeFunction(parameter1,\n" 6729 "\t\t\t\t\t parameter2);\n" 6730 "\t}\n" 6731 "};", 6732 Tab); 6733 6734 Tab.TabWidth = 8; 6735 Tab.IndentWidth = 4; 6736 verifyFormat("class TabWidth8Indent4 {\n" 6737 " void f() {\n" 6738 "\tsomeFunction(parameter1,\n" 6739 "\t\t parameter2);\n" 6740 " }\n" 6741 "};", 6742 Tab); 6743 6744 Tab.TabWidth = 8; 6745 Tab.IndentWidth = 8; 6746 EXPECT_EQ("/*\n" 6747 "\t a\t\tcomment\n" 6748 "\t in multiple lines\n" 6749 " */", 6750 format(" /*\t \t \n" 6751 " \t \t a\t\tcomment\t \t\n" 6752 " \t \t in multiple lines\t\n" 6753 " \t */", 6754 Tab)); 6755 6756 Tab.UseTab = FormatStyle::UT_ForIndentation; 6757 verifyFormat("{\n" 6758 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 6759 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 6760 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 6761 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 6762 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 6763 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 6764 "};", 6765 Tab); 6766 verifyFormat("enum AA {\n" 6767 "\ta1, // Force multiple lines\n" 6768 "\ta2,\n" 6769 "\ta3\n" 6770 "};", 6771 Tab); 6772 EXPECT_EQ("if (aaaaaaaa && // q\n" 6773 " bb) // w\n" 6774 "\t;", 6775 format("if (aaaaaaaa &&// q\n" 6776 "bb)// w\n" 6777 ";", 6778 Tab)); 6779 verifyFormat("class X {\n" 6780 "\tvoid f() {\n" 6781 "\t\tsomeFunction(parameter1,\n" 6782 "\t\t parameter2);\n" 6783 "\t}\n" 6784 "};", 6785 Tab); 6786 verifyFormat("{\n" 6787 "\tQ(\n" 6788 "\t {\n" 6789 "\t\t int a;\n" 6790 "\t\t someFunction(aaaaaaaa,\n" 6791 "\t\t bbbbbbb);\n" 6792 "\t },\n" 6793 "\t p);\n" 6794 "}", 6795 Tab); 6796 EXPECT_EQ("{\n" 6797 "\t/* aaaa\n" 6798 "\t bbbb */\n" 6799 "}", 6800 format("{\n" 6801 "/* aaaa\n" 6802 " bbbb */\n" 6803 "}", 6804 Tab)); 6805 EXPECT_EQ("{\n" 6806 "\t/*\n" 6807 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6808 "\t bbbbbbbbbbbbb\n" 6809 "\t*/\n" 6810 "}", 6811 format("{\n" 6812 "/*\n" 6813 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 6814 "*/\n" 6815 "}", 6816 Tab)); 6817 EXPECT_EQ("{\n" 6818 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6819 "\t// bbbbbbbbbbbbb\n" 6820 "}", 6821 format("{\n" 6822 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 6823 "}", 6824 Tab)); 6825 EXPECT_EQ("{\n" 6826 "\t/*\n" 6827 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6828 "\t bbbbbbbbbbbbb\n" 6829 "\t*/\n" 6830 "}", 6831 format("{\n" 6832 "\t/*\n" 6833 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 6834 "\t*/\n" 6835 "}", 6836 Tab)); 6837 EXPECT_EQ("{\n" 6838 "\t/*\n" 6839 "\n" 6840 "\t*/\n" 6841 "}", 6842 format("{\n" 6843 "\t/*\n" 6844 "\n" 6845 "\t*/\n" 6846 "}", 6847 Tab)); 6848 EXPECT_EQ("{\n" 6849 "\t/*\n" 6850 " asdf\n" 6851 "\t*/\n" 6852 "}", 6853 format("{\n" 6854 "\t/*\n" 6855 " asdf\n" 6856 "\t*/\n" 6857 "}", 6858 Tab)); 6859 6860 Tab.UseTab = FormatStyle::UT_Never; 6861 EXPECT_EQ("/*\n" 6862 " a\t\tcomment\n" 6863 " in multiple lines\n" 6864 " */", 6865 format(" /*\t \t \n" 6866 " \t \t a\t\tcomment\t \t\n" 6867 " \t \t in multiple lines\t\n" 6868 " \t */", 6869 Tab)); 6870 EXPECT_EQ("/* some\n" 6871 " comment */", 6872 format(" \t \t /* some\n" 6873 " \t \t comment */", 6874 Tab)); 6875 EXPECT_EQ("int a; /* some\n" 6876 " comment */", 6877 format(" \t \t int a; /* some\n" 6878 " \t \t comment */", 6879 Tab)); 6880 6881 EXPECT_EQ("int a; /* some\n" 6882 "comment */", 6883 format(" \t \t int\ta; /* some\n" 6884 " \t \t comment */", 6885 Tab)); 6886 EXPECT_EQ("f(\"\t\t\"); /* some\n" 6887 " comment */", 6888 format(" \t \t f(\"\t\t\"); /* some\n" 6889 " \t \t comment */", 6890 Tab)); 6891 EXPECT_EQ("{\n" 6892 " /*\n" 6893 " * Comment\n" 6894 " */\n" 6895 " int i;\n" 6896 "}", 6897 format("{\n" 6898 "\t/*\n" 6899 "\t * Comment\n" 6900 "\t */\n" 6901 "\t int i;\n" 6902 "}")); 6903 6904 Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation; 6905 Tab.TabWidth = 8; 6906 Tab.IndentWidth = 8; 6907 EXPECT_EQ("if (aaaaaaaa && // q\n" 6908 " bb) // w\n" 6909 "\t;", 6910 format("if (aaaaaaaa &&// q\n" 6911 "bb)// w\n" 6912 ";", 6913 Tab)); 6914 EXPECT_EQ("if (aaa && bbb) // w\n" 6915 "\t;", 6916 format("if(aaa&&bbb)// w\n" 6917 ";", 6918 Tab)); 6919 verifyFormat("class X {\n" 6920 "\tvoid f() {\n" 6921 "\t\tsomeFunction(parameter1,\n" 6922 "\t\t\t parameter2);\n" 6923 "\t}\n" 6924 "};", 6925 Tab); 6926 verifyFormat("#define A \\\n" 6927 "\tvoid f() { \\\n" 6928 "\t\tsomeFunction( \\\n" 6929 "\t\t parameter1, \\\n" 6930 "\t\t parameter2); \\\n" 6931 "\t}", 6932 Tab); 6933 Tab.TabWidth = 4; 6934 Tab.IndentWidth = 8; 6935 verifyFormat("class TabWidth4Indent8 {\n" 6936 "\t\tvoid f() {\n" 6937 "\t\t\t\tsomeFunction(parameter1,\n" 6938 "\t\t\t\t\t\t\t parameter2);\n" 6939 "\t\t}\n" 6940 "};", 6941 Tab); 6942 Tab.TabWidth = 4; 6943 Tab.IndentWidth = 4; 6944 verifyFormat("class TabWidth4Indent4 {\n" 6945 "\tvoid f() {\n" 6946 "\t\tsomeFunction(parameter1,\n" 6947 "\t\t\t\t\t parameter2);\n" 6948 "\t}\n" 6949 "};", 6950 Tab); 6951 Tab.TabWidth = 8; 6952 Tab.IndentWidth = 4; 6953 verifyFormat("class TabWidth8Indent4 {\n" 6954 " void f() {\n" 6955 "\tsomeFunction(parameter1,\n" 6956 "\t\t parameter2);\n" 6957 " }\n" 6958 "};", 6959 Tab); 6960 Tab.TabWidth = 8; 6961 Tab.IndentWidth = 8; 6962 EXPECT_EQ("/*\n" 6963 "\t a\t\tcomment\n" 6964 "\t in multiple lines\n" 6965 " */", 6966 format(" /*\t \t \n" 6967 " \t \t a\t\tcomment\t \t\n" 6968 " \t \t in multiple lines\t\n" 6969 " \t */", 6970 Tab)); 6971 verifyFormat("{\n" 6972 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 6973 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 6974 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 6975 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 6976 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 6977 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 6978 "};", 6979 Tab); 6980 verifyFormat("enum AA {\n" 6981 "\ta1, // Force multiple lines\n" 6982 "\ta2,\n" 6983 "\ta3\n" 6984 "};", 6985 Tab); 6986 EXPECT_EQ("if (aaaaaaaa && // q\n" 6987 " bb) // w\n" 6988 "\t;", 6989 format("if (aaaaaaaa &&// q\n" 6990 "bb)// w\n" 6991 ";", 6992 Tab)); 6993 verifyFormat("class X {\n" 6994 "\tvoid f() {\n" 6995 "\t\tsomeFunction(parameter1,\n" 6996 "\t\t\t parameter2);\n" 6997 "\t}\n" 6998 "};", 6999 Tab); 7000 verifyFormat("{\n" 7001 "\tQ(\n" 7002 "\t {\n" 7003 "\t\t int a;\n" 7004 "\t\t someFunction(aaaaaaaa,\n" 7005 "\t\t\t\t bbbbbbb);\n" 7006 "\t },\n" 7007 "\t p);\n" 7008 "}", 7009 Tab); 7010 EXPECT_EQ("{\n" 7011 "\t/* aaaa\n" 7012 "\t bbbb */\n" 7013 "}", 7014 format("{\n" 7015 "/* aaaa\n" 7016 " bbbb */\n" 7017 "}", 7018 Tab)); 7019 EXPECT_EQ("{\n" 7020 "\t/*\n" 7021 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7022 "\t bbbbbbbbbbbbb\n" 7023 "\t*/\n" 7024 "}", 7025 format("{\n" 7026 "/*\n" 7027 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 7028 "*/\n" 7029 "}", 7030 Tab)); 7031 EXPECT_EQ("{\n" 7032 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7033 "\t// bbbbbbbbbbbbb\n" 7034 "}", 7035 format("{\n" 7036 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 7037 "}", 7038 Tab)); 7039 EXPECT_EQ("{\n" 7040 "\t/*\n" 7041 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7042 "\t bbbbbbbbbbbbb\n" 7043 "\t*/\n" 7044 "}", 7045 format("{\n" 7046 "\t/*\n" 7047 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 7048 "\t*/\n" 7049 "}", 7050 Tab)); 7051 EXPECT_EQ("{\n" 7052 "\t/*\n" 7053 "\n" 7054 "\t*/\n" 7055 "}", 7056 format("{\n" 7057 "\t/*\n" 7058 "\n" 7059 "\t*/\n" 7060 "}", 7061 Tab)); 7062 EXPECT_EQ("{\n" 7063 "\t/*\n" 7064 " asdf\n" 7065 "\t*/\n" 7066 "}", 7067 format("{\n" 7068 "\t/*\n" 7069 " asdf\n" 7070 "\t*/\n" 7071 "}", 7072 Tab)); 7073 EXPECT_EQ("/*\n" 7074 "\t a\t\tcomment\n" 7075 "\t in multiple lines\n" 7076 " */", 7077 format(" /*\t \t \n" 7078 " \t \t a\t\tcomment\t \t\n" 7079 " \t \t in multiple lines\t\n" 7080 " \t */", 7081 Tab)); 7082 EXPECT_EQ("/* some\n" 7083 " comment */", 7084 format(" \t \t /* some\n" 7085 " \t \t comment */", 7086 Tab)); 7087 EXPECT_EQ("int a; /* some\n" 7088 " comment */", 7089 format(" \t \t int a; /* some\n" 7090 " \t \t comment */", 7091 Tab)); 7092 EXPECT_EQ("int a; /* some\n" 7093 "comment */", 7094 format(" \t \t int\ta; /* some\n" 7095 " \t \t comment */", 7096 Tab)); 7097 EXPECT_EQ("f(\"\t\t\"); /* some\n" 7098 " comment */", 7099 format(" \t \t f(\"\t\t\"); /* some\n" 7100 " \t \t comment */", 7101 Tab)); 7102 EXPECT_EQ("{\n" 7103 " /*\n" 7104 " * Comment\n" 7105 " */\n" 7106 " int i;\n" 7107 "}", 7108 format("{\n" 7109 "\t/*\n" 7110 "\t * Comment\n" 7111 "\t */\n" 7112 "\t int i;\n" 7113 "}")); 7114 Tab.AlignConsecutiveAssignments = true; 7115 Tab.AlignConsecutiveDeclarations = true; 7116 Tab.TabWidth = 4; 7117 Tab.IndentWidth = 4; 7118 verifyFormat("class Assign {\n" 7119 "\tvoid f() {\n" 7120 "\t\tint x = 123;\n" 7121 "\t\tint random = 4;\n" 7122 "\t\tstd::string alphabet =\n" 7123 "\t\t\t\"abcdefghijklmnopqrstuvwxyz\";\n" 7124 "\t}\n" 7125 "};", 7126 Tab); 7127 } 7128 7129 TEST_F(FormatTest, CalculatesOriginalColumn) { 7130 EXPECT_EQ("\"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 7131 "q\"; /* some\n" 7132 " comment */", 7133 format(" \"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 7134 "q\"; /* some\n" 7135 " comment */", 7136 getLLVMStyle())); 7137 EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n" 7138 "/* some\n" 7139 " comment */", 7140 format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n" 7141 " /* some\n" 7142 " comment */", 7143 getLLVMStyle())); 7144 EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 7145 "qqq\n" 7146 "/* some\n" 7147 " comment */", 7148 format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 7149 "qqq\n" 7150 " /* some\n" 7151 " comment */", 7152 getLLVMStyle())); 7153 EXPECT_EQ("inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 7154 "wwww; /* some\n" 7155 " comment */", 7156 format(" inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 7157 "wwww; /* some\n" 7158 " comment */", 7159 getLLVMStyle())); 7160 } 7161 7162 TEST_F(FormatTest, ConfigurableSpaceBeforeParens) { 7163 FormatStyle NoSpace = getLLVMStyle(); 7164 NoSpace.SpaceBeforeParens = FormatStyle::SBPO_Never; 7165 7166 verifyFormat("while(true)\n" 7167 " continue;", 7168 NoSpace); 7169 verifyFormat("for(;;)\n" 7170 " continue;", 7171 NoSpace); 7172 verifyFormat("if(true)\n" 7173 " f();\n" 7174 "else if(true)\n" 7175 " f();", 7176 NoSpace); 7177 verifyFormat("do {\n" 7178 " do_something();\n" 7179 "} while(something());", 7180 NoSpace); 7181 verifyFormat("switch(x) {\n" 7182 "default:\n" 7183 " break;\n" 7184 "}", 7185 NoSpace); 7186 verifyFormat("auto i = std::make_unique<int>(5);", NoSpace); 7187 verifyFormat("size_t x = sizeof(x);", NoSpace); 7188 verifyFormat("auto f(int x) -> decltype(x);", NoSpace); 7189 verifyFormat("int f(T x) noexcept(x.create());", NoSpace); 7190 verifyFormat("alignas(128) char a[128];", NoSpace); 7191 verifyFormat("size_t x = alignof(MyType);", NoSpace); 7192 verifyFormat("static_assert(sizeof(char) == 1, \"Impossible!\");", NoSpace); 7193 verifyFormat("int f() throw(Deprecated);", NoSpace); 7194 verifyFormat("typedef void (*cb)(int);", NoSpace); 7195 verifyFormat("T A::operator()();", NoSpace); 7196 verifyFormat("X A::operator++(T);", NoSpace); 7197 7198 FormatStyle Space = getLLVMStyle(); 7199 Space.SpaceBeforeParens = FormatStyle::SBPO_Always; 7200 7201 verifyFormat("int f ();", Space); 7202 verifyFormat("void f (int a, T b) {\n" 7203 " while (true)\n" 7204 " continue;\n" 7205 "}", 7206 Space); 7207 verifyFormat("if (true)\n" 7208 " f ();\n" 7209 "else if (true)\n" 7210 " f ();", 7211 Space); 7212 verifyFormat("do {\n" 7213 " do_something ();\n" 7214 "} while (something ());", 7215 Space); 7216 verifyFormat("switch (x) {\n" 7217 "default:\n" 7218 " break;\n" 7219 "}", 7220 Space); 7221 verifyFormat("A::A () : a (1) {}", Space); 7222 verifyFormat("void f () __attribute__ ((asdf));", Space); 7223 verifyFormat("*(&a + 1);\n" 7224 "&((&a)[1]);\n" 7225 "a[(b + c) * d];\n" 7226 "(((a + 1) * 2) + 3) * 4;", 7227 Space); 7228 verifyFormat("#define A(x) x", Space); 7229 verifyFormat("#define A (x) x", Space); 7230 verifyFormat("#if defined(x)\n" 7231 "#endif", 7232 Space); 7233 verifyFormat("auto i = std::make_unique<int> (5);", Space); 7234 verifyFormat("size_t x = sizeof (x);", Space); 7235 verifyFormat("auto f (int x) -> decltype (x);", Space); 7236 verifyFormat("int f (T x) noexcept (x.create ());", Space); 7237 verifyFormat("alignas (128) char a[128];", Space); 7238 verifyFormat("size_t x = alignof (MyType);", Space); 7239 verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");", Space); 7240 verifyFormat("int f () throw (Deprecated);", Space); 7241 verifyFormat("typedef void (*cb) (int);", Space); 7242 verifyFormat("T A::operator() ();", Space); 7243 verifyFormat("X A::operator++ (T);", Space); 7244 } 7245 7246 TEST_F(FormatTest, ConfigurableSpacesInParentheses) { 7247 FormatStyle Spaces = getLLVMStyle(); 7248 7249 Spaces.SpacesInParentheses = true; 7250 verifyFormat("call( x, y, z );", Spaces); 7251 verifyFormat("call();", Spaces); 7252 verifyFormat("std::function<void( int, int )> callback;", Spaces); 7253 verifyFormat("void inFunction() { std::function<void( int, int )> fct; }", 7254 Spaces); 7255 verifyFormat("while ( (bool)1 )\n" 7256 " continue;", 7257 Spaces); 7258 verifyFormat("for ( ;; )\n" 7259 " continue;", 7260 Spaces); 7261 verifyFormat("if ( true )\n" 7262 " f();\n" 7263 "else if ( true )\n" 7264 " f();", 7265 Spaces); 7266 verifyFormat("do {\n" 7267 " do_something( (int)i );\n" 7268 "} while ( something() );", 7269 Spaces); 7270 verifyFormat("switch ( x ) {\n" 7271 "default:\n" 7272 " break;\n" 7273 "}", 7274 Spaces); 7275 7276 Spaces.SpacesInParentheses = false; 7277 Spaces.SpacesInCStyleCastParentheses = true; 7278 verifyFormat("Type *A = ( Type * )P;", Spaces); 7279 verifyFormat("Type *A = ( vector<Type *, int *> )P;", Spaces); 7280 verifyFormat("x = ( int32 )y;", Spaces); 7281 verifyFormat("int a = ( int )(2.0f);", Spaces); 7282 verifyFormat("#define AA(X) sizeof((( X * )NULL)->a)", Spaces); 7283 verifyFormat("my_int a = ( my_int )sizeof(int);", Spaces); 7284 verifyFormat("#define x (( int )-1)", Spaces); 7285 7286 // Run the first set of tests again with: 7287 Spaces.SpacesInParentheses = false; 7288 Spaces.SpaceInEmptyParentheses = true; 7289 Spaces.SpacesInCStyleCastParentheses = true; 7290 verifyFormat("call(x, y, z);", Spaces); 7291 verifyFormat("call( );", Spaces); 7292 verifyFormat("std::function<void(int, int)> callback;", Spaces); 7293 verifyFormat("while (( bool )1)\n" 7294 " continue;", 7295 Spaces); 7296 verifyFormat("for (;;)\n" 7297 " continue;", 7298 Spaces); 7299 verifyFormat("if (true)\n" 7300 " f( );\n" 7301 "else if (true)\n" 7302 " f( );", 7303 Spaces); 7304 verifyFormat("do {\n" 7305 " do_something(( int )i);\n" 7306 "} while (something( ));", 7307 Spaces); 7308 verifyFormat("switch (x) {\n" 7309 "default:\n" 7310 " break;\n" 7311 "}", 7312 Spaces); 7313 7314 // Run the first set of tests again with: 7315 Spaces.SpaceAfterCStyleCast = true; 7316 verifyFormat("call(x, y, z);", Spaces); 7317 verifyFormat("call( );", Spaces); 7318 verifyFormat("std::function<void(int, int)> callback;", Spaces); 7319 verifyFormat("while (( bool ) 1)\n" 7320 " continue;", 7321 Spaces); 7322 verifyFormat("for (;;)\n" 7323 " continue;", 7324 Spaces); 7325 verifyFormat("if (true)\n" 7326 " f( );\n" 7327 "else if (true)\n" 7328 " f( );", 7329 Spaces); 7330 verifyFormat("do {\n" 7331 " do_something(( int ) i);\n" 7332 "} while (something( ));", 7333 Spaces); 7334 verifyFormat("switch (x) {\n" 7335 "default:\n" 7336 " break;\n" 7337 "}", 7338 Spaces); 7339 7340 // Run subset of tests again with: 7341 Spaces.SpacesInCStyleCastParentheses = false; 7342 Spaces.SpaceAfterCStyleCast = true; 7343 verifyFormat("while ((bool) 1)\n" 7344 " continue;", 7345 Spaces); 7346 verifyFormat("do {\n" 7347 " do_something((int) i);\n" 7348 "} while (something( ));", 7349 Spaces); 7350 } 7351 7352 TEST_F(FormatTest, ConfigurableSpacesInSquareBrackets) { 7353 verifyFormat("int a[5];"); 7354 verifyFormat("a[3] += 42;"); 7355 7356 FormatStyle Spaces = getLLVMStyle(); 7357 Spaces.SpacesInSquareBrackets = true; 7358 // Lambdas unchanged. 7359 verifyFormat("int c = []() -> int { return 2; }();\n", Spaces); 7360 verifyFormat("return [i, args...] {};", Spaces); 7361 7362 // Not lambdas. 7363 verifyFormat("int a[ 5 ];", Spaces); 7364 verifyFormat("a[ 3 ] += 42;", Spaces); 7365 verifyFormat("constexpr char hello[]{\"hello\"};", Spaces); 7366 verifyFormat("double &operator[](int i) { return 0; }\n" 7367 "int i;", 7368 Spaces); 7369 verifyFormat("std::unique_ptr<int[]> foo() {}", Spaces); 7370 verifyFormat("int i = a[ a ][ a ]->f();", Spaces); 7371 verifyFormat("int i = (*b)[ a ]->f();", Spaces); 7372 } 7373 7374 TEST_F(FormatTest, ConfigurableSpaceBeforeAssignmentOperators) { 7375 verifyFormat("int a = 5;"); 7376 verifyFormat("a += 42;"); 7377 verifyFormat("a or_eq 8;"); 7378 7379 FormatStyle Spaces = getLLVMStyle(); 7380 Spaces.SpaceBeforeAssignmentOperators = false; 7381 verifyFormat("int a= 5;", Spaces); 7382 verifyFormat("a+= 42;", Spaces); 7383 verifyFormat("a or_eq 8;", Spaces); 7384 } 7385 7386 TEST_F(FormatTest, AlignConsecutiveAssignments) { 7387 FormatStyle Alignment = getLLVMStyle(); 7388 Alignment.AlignConsecutiveAssignments = false; 7389 verifyFormat("int a = 5;\n" 7390 "int oneTwoThree = 123;", 7391 Alignment); 7392 verifyFormat("int a = 5;\n" 7393 "int oneTwoThree = 123;", 7394 Alignment); 7395 7396 Alignment.AlignConsecutiveAssignments = true; 7397 verifyFormat("int a = 5;\n" 7398 "int oneTwoThree = 123;", 7399 Alignment); 7400 verifyFormat("int a = method();\n" 7401 "int oneTwoThree = 133;", 7402 Alignment); 7403 verifyFormat("a &= 5;\n" 7404 "bcd *= 5;\n" 7405 "ghtyf += 5;\n" 7406 "dvfvdb -= 5;\n" 7407 "a /= 5;\n" 7408 "vdsvsv %= 5;\n" 7409 "sfdbddfbdfbb ^= 5;\n" 7410 "dvsdsv |= 5;\n" 7411 "int dsvvdvsdvvv = 123;", 7412 Alignment); 7413 verifyFormat("int i = 1, j = 10;\n" 7414 "something = 2000;", 7415 Alignment); 7416 verifyFormat("something = 2000;\n" 7417 "int i = 1, j = 10;\n", 7418 Alignment); 7419 verifyFormat("something = 2000;\n" 7420 "another = 911;\n" 7421 "int i = 1, j = 10;\n" 7422 "oneMore = 1;\n" 7423 "i = 2;", 7424 Alignment); 7425 verifyFormat("int a = 5;\n" 7426 "int one = 1;\n" 7427 "method();\n" 7428 "int oneTwoThree = 123;\n" 7429 "int oneTwo = 12;", 7430 Alignment); 7431 verifyFormat("int oneTwoThree = 123;\n" 7432 "int oneTwo = 12;\n" 7433 "method();\n", 7434 Alignment); 7435 verifyFormat("int oneTwoThree = 123; // comment\n" 7436 "int oneTwo = 12; // comment", 7437 Alignment); 7438 EXPECT_EQ("int a = 5;\n" 7439 "\n" 7440 "int oneTwoThree = 123;", 7441 format("int a = 5;\n" 7442 "\n" 7443 "int oneTwoThree= 123;", 7444 Alignment)); 7445 EXPECT_EQ("int a = 5;\n" 7446 "int one = 1;\n" 7447 "\n" 7448 "int oneTwoThree = 123;", 7449 format("int a = 5;\n" 7450 "int one = 1;\n" 7451 "\n" 7452 "int oneTwoThree = 123;", 7453 Alignment)); 7454 EXPECT_EQ("int a = 5;\n" 7455 "int one = 1;\n" 7456 "\n" 7457 "int oneTwoThree = 123;\n" 7458 "int oneTwo = 12;", 7459 format("int a = 5;\n" 7460 "int one = 1;\n" 7461 "\n" 7462 "int oneTwoThree = 123;\n" 7463 "int oneTwo = 12;", 7464 Alignment)); 7465 Alignment.AlignEscapedNewlinesLeft = true; 7466 verifyFormat("#define A \\\n" 7467 " int aaaa = 12; \\\n" 7468 " int b = 23; \\\n" 7469 " int ccc = 234; \\\n" 7470 " int dddddddddd = 2345;", 7471 Alignment); 7472 Alignment.AlignEscapedNewlinesLeft = false; 7473 verifyFormat("#define A " 7474 " \\\n" 7475 " int aaaa = 12; " 7476 " \\\n" 7477 " int b = 23; " 7478 " \\\n" 7479 " int ccc = 234; " 7480 " \\\n" 7481 " int dddddddddd = 2345;", 7482 Alignment); 7483 verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int " 7484 "k = 4, int l = 5,\n" 7485 " int m = 6) {\n" 7486 " int j = 10;\n" 7487 " otherThing = 1;\n" 7488 "}", 7489 Alignment); 7490 verifyFormat("void SomeFunction(int parameter = 0) {\n" 7491 " int i = 1;\n" 7492 " int j = 2;\n" 7493 " int big = 10000;\n" 7494 "}", 7495 Alignment); 7496 verifyFormat("class C {\n" 7497 "public:\n" 7498 " int i = 1;\n" 7499 " virtual void f() = 0;\n" 7500 "};", 7501 Alignment); 7502 verifyFormat("int i = 1;\n" 7503 "if (SomeType t = getSomething()) {\n" 7504 "}\n" 7505 "int j = 2;\n" 7506 "int big = 10000;", 7507 Alignment); 7508 verifyFormat("int j = 7;\n" 7509 "for (int k = 0; k < N; ++k) {\n" 7510 "}\n" 7511 "int j = 2;\n" 7512 "int big = 10000;\n" 7513 "}", 7514 Alignment); 7515 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 7516 verifyFormat("int i = 1;\n" 7517 "LooooooooooongType loooooooooooooooooooooongVariable\n" 7518 " = someLooooooooooooooooongFunction();\n" 7519 "int j = 2;", 7520 Alignment); 7521 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 7522 verifyFormat("int i = 1;\n" 7523 "LooooooooooongType loooooooooooooooooooooongVariable =\n" 7524 " someLooooooooooooooooongFunction();\n" 7525 "int j = 2;", 7526 Alignment); 7527 7528 verifyFormat("auto lambda = []() {\n" 7529 " auto i = 0;\n" 7530 " return 0;\n" 7531 "};\n" 7532 "int i = 0;\n" 7533 "auto v = type{\n" 7534 " i = 1, //\n" 7535 " (i = 2), //\n" 7536 " i = 3 //\n" 7537 "};", 7538 Alignment); 7539 7540 // FIXME: Should align all three assignments 7541 verifyFormat( 7542 "int i = 1;\n" 7543 "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n" 7544 " loooooooooooooooooooooongParameterB);\n" 7545 "int j = 2;", 7546 Alignment); 7547 7548 verifyFormat("template <typename T, typename T_0 = very_long_type_name_0,\n" 7549 " typename B = very_long_type_name_1,\n" 7550 " typename T_2 = very_long_type_name_2>\n" 7551 "auto foo() {}\n", 7552 Alignment); 7553 verifyFormat("int a, b = 1;\n" 7554 "int c = 2;\n" 7555 "int dd = 3;\n", 7556 Alignment); 7557 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n" 7558 "float b[1][] = {{3.f}};\n", 7559 Alignment); 7560 } 7561 7562 TEST_F(FormatTest, AlignConsecutiveDeclarations) { 7563 FormatStyle Alignment = getLLVMStyle(); 7564 Alignment.AlignConsecutiveDeclarations = false; 7565 verifyFormat("float const a = 5;\n" 7566 "int oneTwoThree = 123;", 7567 Alignment); 7568 verifyFormat("int a = 5;\n" 7569 "float const oneTwoThree = 123;", 7570 Alignment); 7571 7572 Alignment.AlignConsecutiveDeclarations = true; 7573 verifyFormat("float const a = 5;\n" 7574 "int oneTwoThree = 123;", 7575 Alignment); 7576 verifyFormat("int a = method();\n" 7577 "float const oneTwoThree = 133;", 7578 Alignment); 7579 verifyFormat("int i = 1, j = 10;\n" 7580 "something = 2000;", 7581 Alignment); 7582 verifyFormat("something = 2000;\n" 7583 "int i = 1, j = 10;\n", 7584 Alignment); 7585 verifyFormat("float something = 2000;\n" 7586 "double another = 911;\n" 7587 "int i = 1, j = 10;\n" 7588 "const int *oneMore = 1;\n" 7589 "unsigned i = 2;", 7590 Alignment); 7591 verifyFormat("float a = 5;\n" 7592 "int one = 1;\n" 7593 "method();\n" 7594 "const double oneTwoThree = 123;\n" 7595 "const unsigned int oneTwo = 12;", 7596 Alignment); 7597 verifyFormat("int oneTwoThree{0}; // comment\n" 7598 "unsigned oneTwo; // comment", 7599 Alignment); 7600 EXPECT_EQ("float const a = 5;\n" 7601 "\n" 7602 "int oneTwoThree = 123;", 7603 format("float const a = 5;\n" 7604 "\n" 7605 "int oneTwoThree= 123;", 7606 Alignment)); 7607 EXPECT_EQ("float a = 5;\n" 7608 "int one = 1;\n" 7609 "\n" 7610 "unsigned oneTwoThree = 123;", 7611 format("float a = 5;\n" 7612 "int one = 1;\n" 7613 "\n" 7614 "unsigned oneTwoThree = 123;", 7615 Alignment)); 7616 EXPECT_EQ("float a = 5;\n" 7617 "int one = 1;\n" 7618 "\n" 7619 "unsigned oneTwoThree = 123;\n" 7620 "int oneTwo = 12;", 7621 format("float a = 5;\n" 7622 "int one = 1;\n" 7623 "\n" 7624 "unsigned oneTwoThree = 123;\n" 7625 "int oneTwo = 12;", 7626 Alignment)); 7627 Alignment.AlignConsecutiveAssignments = true; 7628 verifyFormat("float something = 2000;\n" 7629 "double another = 911;\n" 7630 "int i = 1, j = 10;\n" 7631 "const int *oneMore = 1;\n" 7632 "unsigned i = 2;", 7633 Alignment); 7634 verifyFormat("int oneTwoThree = {0}; // comment\n" 7635 "unsigned oneTwo = 0; // comment", 7636 Alignment); 7637 EXPECT_EQ("void SomeFunction(int parameter = 0) {\n" 7638 " int const i = 1;\n" 7639 " int * j = 2;\n" 7640 " int big = 10000;\n" 7641 "\n" 7642 " unsigned oneTwoThree = 123;\n" 7643 " int oneTwo = 12;\n" 7644 " method();\n" 7645 " float k = 2;\n" 7646 " int ll = 10000;\n" 7647 "}", 7648 format("void SomeFunction(int parameter= 0) {\n" 7649 " int const i= 1;\n" 7650 " int *j=2;\n" 7651 " int big = 10000;\n" 7652 "\n" 7653 "unsigned oneTwoThree =123;\n" 7654 "int oneTwo = 12;\n" 7655 " method();\n" 7656 "float k= 2;\n" 7657 "int ll=10000;\n" 7658 "}", 7659 Alignment)); 7660 Alignment.AlignConsecutiveAssignments = false; 7661 Alignment.AlignEscapedNewlinesLeft = true; 7662 verifyFormat("#define A \\\n" 7663 " int aaaa = 12; \\\n" 7664 " float b = 23; \\\n" 7665 " const int ccc = 234; \\\n" 7666 " unsigned dddddddddd = 2345;", 7667 Alignment); 7668 Alignment.AlignEscapedNewlinesLeft = false; 7669 Alignment.ColumnLimit = 30; 7670 verifyFormat("#define A \\\n" 7671 " int aaaa = 12; \\\n" 7672 " float b = 23; \\\n" 7673 " const int ccc = 234; \\\n" 7674 " int dddddddddd = 2345;", 7675 Alignment); 7676 Alignment.ColumnLimit = 80; 7677 verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int " 7678 "k = 4, int l = 5,\n" 7679 " int m = 6) {\n" 7680 " const int j = 10;\n" 7681 " otherThing = 1;\n" 7682 "}", 7683 Alignment); 7684 verifyFormat("void SomeFunction(int parameter = 0) {\n" 7685 " int const i = 1;\n" 7686 " int * j = 2;\n" 7687 " int big = 10000;\n" 7688 "}", 7689 Alignment); 7690 verifyFormat("class C {\n" 7691 "public:\n" 7692 " int i = 1;\n" 7693 " virtual void f() = 0;\n" 7694 "};", 7695 Alignment); 7696 verifyFormat("float i = 1;\n" 7697 "if (SomeType t = getSomething()) {\n" 7698 "}\n" 7699 "const unsigned j = 2;\n" 7700 "int big = 10000;", 7701 Alignment); 7702 verifyFormat("float j = 7;\n" 7703 "for (int k = 0; k < N; ++k) {\n" 7704 "}\n" 7705 "unsigned j = 2;\n" 7706 "int big = 10000;\n" 7707 "}", 7708 Alignment); 7709 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 7710 verifyFormat("float i = 1;\n" 7711 "LooooooooooongType loooooooooooooooooooooongVariable\n" 7712 " = someLooooooooooooooooongFunction();\n" 7713 "int j = 2;", 7714 Alignment); 7715 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 7716 verifyFormat("int i = 1;\n" 7717 "LooooooooooongType loooooooooooooooooooooongVariable =\n" 7718 " someLooooooooooooooooongFunction();\n" 7719 "int j = 2;", 7720 Alignment); 7721 7722 Alignment.AlignConsecutiveAssignments = true; 7723 verifyFormat("auto lambda = []() {\n" 7724 " auto ii = 0;\n" 7725 " float j = 0;\n" 7726 " return 0;\n" 7727 "};\n" 7728 "int i = 0;\n" 7729 "float i2 = 0;\n" 7730 "auto v = type{\n" 7731 " i = 1, //\n" 7732 " (i = 2), //\n" 7733 " i = 3 //\n" 7734 "};", 7735 Alignment); 7736 Alignment.AlignConsecutiveAssignments = false; 7737 7738 // FIXME: Should align all three declarations 7739 verifyFormat( 7740 "int i = 1;\n" 7741 "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n" 7742 " loooooooooooooooooooooongParameterB);\n" 7743 "int j = 2;", 7744 Alignment); 7745 7746 // Test interactions with ColumnLimit and AlignConsecutiveAssignments: 7747 // We expect declarations and assignments to align, as long as it doesn't 7748 // exceed the column limit, starting a new alignemnt sequence whenever it 7749 // happens. 7750 Alignment.AlignConsecutiveAssignments = true; 7751 Alignment.ColumnLimit = 30; 7752 verifyFormat("float ii = 1;\n" 7753 "unsigned j = 2;\n" 7754 "int someVerylongVariable = 1;\n" 7755 "AnotherLongType ll = 123456;\n" 7756 "VeryVeryLongType k = 2;\n" 7757 "int myvar = 1;", 7758 Alignment); 7759 Alignment.ColumnLimit = 80; 7760 Alignment.AlignConsecutiveAssignments = false; 7761 7762 verifyFormat( 7763 "template <typename LongTemplate, typename VeryLongTemplateTypeName,\n" 7764 " typename LongType, typename B>\n" 7765 "auto foo() {}\n", 7766 Alignment); 7767 verifyFormat("float a, b = 1;\n" 7768 "int c = 2;\n" 7769 "int dd = 3;\n", 7770 Alignment); 7771 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n" 7772 "float b[1][] = {{3.f}};\n", 7773 Alignment); 7774 Alignment.AlignConsecutiveAssignments = true; 7775 verifyFormat("float a, b = 1;\n" 7776 "int c = 2;\n" 7777 "int dd = 3;\n", 7778 Alignment); 7779 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n" 7780 "float b[1][] = {{3.f}};\n", 7781 Alignment); 7782 Alignment.AlignConsecutiveAssignments = false; 7783 7784 Alignment.ColumnLimit = 30; 7785 Alignment.BinPackParameters = false; 7786 verifyFormat("void foo(float a,\n" 7787 " float b,\n" 7788 " int c,\n" 7789 " uint32_t *d) {\n" 7790 " int * e = 0;\n" 7791 " float f = 0;\n" 7792 " double g = 0;\n" 7793 "}\n" 7794 "void bar(ino_t a,\n" 7795 " int b,\n" 7796 " uint32_t *c,\n" 7797 " bool d) {}\n", 7798 Alignment); 7799 Alignment.BinPackParameters = true; 7800 Alignment.ColumnLimit = 80; 7801 } 7802 7803 TEST_F(FormatTest, LinuxBraceBreaking) { 7804 FormatStyle LinuxBraceStyle = getLLVMStyle(); 7805 LinuxBraceStyle.BreakBeforeBraces = FormatStyle::BS_Linux; 7806 verifyFormat("namespace a\n" 7807 "{\n" 7808 "class A\n" 7809 "{\n" 7810 " void f()\n" 7811 " {\n" 7812 " if (true) {\n" 7813 " a();\n" 7814 " b();\n" 7815 " } else {\n" 7816 " a();\n" 7817 " }\n" 7818 " }\n" 7819 " void g() { return; }\n" 7820 "};\n" 7821 "struct B {\n" 7822 " int x;\n" 7823 "};\n" 7824 "}\n", 7825 LinuxBraceStyle); 7826 verifyFormat("enum X {\n" 7827 " Y = 0,\n" 7828 "}\n", 7829 LinuxBraceStyle); 7830 verifyFormat("struct S {\n" 7831 " int Type;\n" 7832 " union {\n" 7833 " int x;\n" 7834 " double y;\n" 7835 " } Value;\n" 7836 " class C\n" 7837 " {\n" 7838 " MyFavoriteType Value;\n" 7839 " } Class;\n" 7840 "}\n", 7841 LinuxBraceStyle); 7842 } 7843 7844 TEST_F(FormatTest, MozillaBraceBreaking) { 7845 FormatStyle MozillaBraceStyle = getLLVMStyle(); 7846 MozillaBraceStyle.BreakBeforeBraces = FormatStyle::BS_Mozilla; 7847 verifyFormat("namespace a {\n" 7848 "class A\n" 7849 "{\n" 7850 " void f()\n" 7851 " {\n" 7852 " if (true) {\n" 7853 " a();\n" 7854 " b();\n" 7855 " }\n" 7856 " }\n" 7857 " void g() { return; }\n" 7858 "};\n" 7859 "enum E\n" 7860 "{\n" 7861 " A,\n" 7862 " // foo\n" 7863 " B,\n" 7864 " C\n" 7865 "};\n" 7866 "struct B\n" 7867 "{\n" 7868 " int x;\n" 7869 "};\n" 7870 "}\n", 7871 MozillaBraceStyle); 7872 verifyFormat("struct S\n" 7873 "{\n" 7874 " int Type;\n" 7875 " union\n" 7876 " {\n" 7877 " int x;\n" 7878 " double y;\n" 7879 " } Value;\n" 7880 " class C\n" 7881 " {\n" 7882 " MyFavoriteType Value;\n" 7883 " } Class;\n" 7884 "}\n", 7885 MozillaBraceStyle); 7886 } 7887 7888 TEST_F(FormatTest, StroustrupBraceBreaking) { 7889 FormatStyle StroustrupBraceStyle = getLLVMStyle(); 7890 StroustrupBraceStyle.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 7891 verifyFormat("namespace a {\n" 7892 "class A {\n" 7893 " void f()\n" 7894 " {\n" 7895 " if (true) {\n" 7896 " a();\n" 7897 " b();\n" 7898 " }\n" 7899 " }\n" 7900 " void g() { return; }\n" 7901 "};\n" 7902 "struct B {\n" 7903 " int x;\n" 7904 "};\n" 7905 "}\n", 7906 StroustrupBraceStyle); 7907 7908 verifyFormat("void foo()\n" 7909 "{\n" 7910 " if (a) {\n" 7911 " a();\n" 7912 " }\n" 7913 " else {\n" 7914 " b();\n" 7915 " }\n" 7916 "}\n", 7917 StroustrupBraceStyle); 7918 7919 verifyFormat("#ifdef _DEBUG\n" 7920 "int foo(int i = 0)\n" 7921 "#else\n" 7922 "int foo(int i = 5)\n" 7923 "#endif\n" 7924 "{\n" 7925 " return i;\n" 7926 "}", 7927 StroustrupBraceStyle); 7928 7929 verifyFormat("void foo() {}\n" 7930 "void bar()\n" 7931 "#ifdef _DEBUG\n" 7932 "{\n" 7933 " foo();\n" 7934 "}\n" 7935 "#else\n" 7936 "{\n" 7937 "}\n" 7938 "#endif", 7939 StroustrupBraceStyle); 7940 7941 verifyFormat("void foobar() { int i = 5; }\n" 7942 "#ifdef _DEBUG\n" 7943 "void bar() {}\n" 7944 "#else\n" 7945 "void bar() { foobar(); }\n" 7946 "#endif", 7947 StroustrupBraceStyle); 7948 } 7949 7950 TEST_F(FormatTest, AllmanBraceBreaking) { 7951 FormatStyle AllmanBraceStyle = getLLVMStyle(); 7952 AllmanBraceStyle.BreakBeforeBraces = FormatStyle::BS_Allman; 7953 verifyFormat("namespace a\n" 7954 "{\n" 7955 "class A\n" 7956 "{\n" 7957 " void f()\n" 7958 " {\n" 7959 " if (true)\n" 7960 " {\n" 7961 " a();\n" 7962 " b();\n" 7963 " }\n" 7964 " }\n" 7965 " void g() { return; }\n" 7966 "};\n" 7967 "struct B\n" 7968 "{\n" 7969 " int x;\n" 7970 "};\n" 7971 "}", 7972 AllmanBraceStyle); 7973 7974 verifyFormat("void f()\n" 7975 "{\n" 7976 " if (true)\n" 7977 " {\n" 7978 " a();\n" 7979 " }\n" 7980 " else if (false)\n" 7981 " {\n" 7982 " b();\n" 7983 " }\n" 7984 " else\n" 7985 " {\n" 7986 " c();\n" 7987 " }\n" 7988 "}\n", 7989 AllmanBraceStyle); 7990 7991 verifyFormat("void f()\n" 7992 "{\n" 7993 " for (int i = 0; i < 10; ++i)\n" 7994 " {\n" 7995 " a();\n" 7996 " }\n" 7997 " while (false)\n" 7998 " {\n" 7999 " b();\n" 8000 " }\n" 8001 " do\n" 8002 " {\n" 8003 " c();\n" 8004 " } while (false)\n" 8005 "}\n", 8006 AllmanBraceStyle); 8007 8008 verifyFormat("void f(int a)\n" 8009 "{\n" 8010 " switch (a)\n" 8011 " {\n" 8012 " case 0:\n" 8013 " break;\n" 8014 " case 1:\n" 8015 " {\n" 8016 " break;\n" 8017 " }\n" 8018 " case 2:\n" 8019 " {\n" 8020 " }\n" 8021 " break;\n" 8022 " default:\n" 8023 " break;\n" 8024 " }\n" 8025 "}\n", 8026 AllmanBraceStyle); 8027 8028 verifyFormat("enum X\n" 8029 "{\n" 8030 " Y = 0,\n" 8031 "}\n", 8032 AllmanBraceStyle); 8033 verifyFormat("enum X\n" 8034 "{\n" 8035 " Y = 0\n" 8036 "}\n", 8037 AllmanBraceStyle); 8038 8039 verifyFormat("@interface BSApplicationController ()\n" 8040 "{\n" 8041 "@private\n" 8042 " id _extraIvar;\n" 8043 "}\n" 8044 "@end\n", 8045 AllmanBraceStyle); 8046 8047 verifyFormat("#ifdef _DEBUG\n" 8048 "int foo(int i = 0)\n" 8049 "#else\n" 8050 "int foo(int i = 5)\n" 8051 "#endif\n" 8052 "{\n" 8053 " return i;\n" 8054 "}", 8055 AllmanBraceStyle); 8056 8057 verifyFormat("void foo() {}\n" 8058 "void bar()\n" 8059 "#ifdef _DEBUG\n" 8060 "{\n" 8061 " foo();\n" 8062 "}\n" 8063 "#else\n" 8064 "{\n" 8065 "}\n" 8066 "#endif", 8067 AllmanBraceStyle); 8068 8069 verifyFormat("void foobar() { int i = 5; }\n" 8070 "#ifdef _DEBUG\n" 8071 "void bar() {}\n" 8072 "#else\n" 8073 "void bar() { foobar(); }\n" 8074 "#endif", 8075 AllmanBraceStyle); 8076 8077 // This shouldn't affect ObjC blocks.. 8078 verifyFormat("[self doSomeThingWithACompletionHandler:^{\n" 8079 " // ...\n" 8080 " int i;\n" 8081 "}];", 8082 AllmanBraceStyle); 8083 verifyFormat("void (^block)(void) = ^{\n" 8084 " // ...\n" 8085 " int i;\n" 8086 "};", 8087 AllmanBraceStyle); 8088 // .. or dict literals. 8089 verifyFormat("void f()\n" 8090 "{\n" 8091 " [object someMethod:@{ @\"a\" : @\"b\" }];\n" 8092 "}", 8093 AllmanBraceStyle); 8094 verifyFormat("int f()\n" 8095 "{ // comment\n" 8096 " return 42;\n" 8097 "}", 8098 AllmanBraceStyle); 8099 8100 AllmanBraceStyle.ColumnLimit = 19; 8101 verifyFormat("void f() { int i; }", AllmanBraceStyle); 8102 AllmanBraceStyle.ColumnLimit = 18; 8103 verifyFormat("void f()\n" 8104 "{\n" 8105 " int i;\n" 8106 "}", 8107 AllmanBraceStyle); 8108 AllmanBraceStyle.ColumnLimit = 80; 8109 8110 FormatStyle BreakBeforeBraceShortIfs = AllmanBraceStyle; 8111 BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine = true; 8112 BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true; 8113 verifyFormat("void f(bool b)\n" 8114 "{\n" 8115 " if (b)\n" 8116 " {\n" 8117 " return;\n" 8118 " }\n" 8119 "}\n", 8120 BreakBeforeBraceShortIfs); 8121 verifyFormat("void f(bool b)\n" 8122 "{\n" 8123 " if (b) return;\n" 8124 "}\n", 8125 BreakBeforeBraceShortIfs); 8126 verifyFormat("void f(bool b)\n" 8127 "{\n" 8128 " while (b)\n" 8129 " {\n" 8130 " return;\n" 8131 " }\n" 8132 "}\n", 8133 BreakBeforeBraceShortIfs); 8134 } 8135 8136 TEST_F(FormatTest, GNUBraceBreaking) { 8137 FormatStyle GNUBraceStyle = getLLVMStyle(); 8138 GNUBraceStyle.BreakBeforeBraces = FormatStyle::BS_GNU; 8139 verifyFormat("namespace a\n" 8140 "{\n" 8141 "class A\n" 8142 "{\n" 8143 " void f()\n" 8144 " {\n" 8145 " int a;\n" 8146 " {\n" 8147 " int b;\n" 8148 " }\n" 8149 " if (true)\n" 8150 " {\n" 8151 " a();\n" 8152 " b();\n" 8153 " }\n" 8154 " }\n" 8155 " void g() { return; }\n" 8156 "}\n" 8157 "}", 8158 GNUBraceStyle); 8159 8160 verifyFormat("void f()\n" 8161 "{\n" 8162 " if (true)\n" 8163 " {\n" 8164 " a();\n" 8165 " }\n" 8166 " else if (false)\n" 8167 " {\n" 8168 " b();\n" 8169 " }\n" 8170 " else\n" 8171 " {\n" 8172 " c();\n" 8173 " }\n" 8174 "}\n", 8175 GNUBraceStyle); 8176 8177 verifyFormat("void f()\n" 8178 "{\n" 8179 " for (int i = 0; i < 10; ++i)\n" 8180 " {\n" 8181 " a();\n" 8182 " }\n" 8183 " while (false)\n" 8184 " {\n" 8185 " b();\n" 8186 " }\n" 8187 " do\n" 8188 " {\n" 8189 " c();\n" 8190 " }\n" 8191 " while (false);\n" 8192 "}\n", 8193 GNUBraceStyle); 8194 8195 verifyFormat("void f(int a)\n" 8196 "{\n" 8197 " switch (a)\n" 8198 " {\n" 8199 " case 0:\n" 8200 " break;\n" 8201 " case 1:\n" 8202 " {\n" 8203 " break;\n" 8204 " }\n" 8205 " case 2:\n" 8206 " {\n" 8207 " }\n" 8208 " break;\n" 8209 " default:\n" 8210 " break;\n" 8211 " }\n" 8212 "}\n", 8213 GNUBraceStyle); 8214 8215 verifyFormat("enum X\n" 8216 "{\n" 8217 " Y = 0,\n" 8218 "}\n", 8219 GNUBraceStyle); 8220 8221 verifyFormat("@interface BSApplicationController ()\n" 8222 "{\n" 8223 "@private\n" 8224 " id _extraIvar;\n" 8225 "}\n" 8226 "@end\n", 8227 GNUBraceStyle); 8228 8229 verifyFormat("#ifdef _DEBUG\n" 8230 "int foo(int i = 0)\n" 8231 "#else\n" 8232 "int foo(int i = 5)\n" 8233 "#endif\n" 8234 "{\n" 8235 " return i;\n" 8236 "}", 8237 GNUBraceStyle); 8238 8239 verifyFormat("void foo() {}\n" 8240 "void bar()\n" 8241 "#ifdef _DEBUG\n" 8242 "{\n" 8243 " foo();\n" 8244 "}\n" 8245 "#else\n" 8246 "{\n" 8247 "}\n" 8248 "#endif", 8249 GNUBraceStyle); 8250 8251 verifyFormat("void foobar() { int i = 5; }\n" 8252 "#ifdef _DEBUG\n" 8253 "void bar() {}\n" 8254 "#else\n" 8255 "void bar() { foobar(); }\n" 8256 "#endif", 8257 GNUBraceStyle); 8258 } 8259 8260 TEST_F(FormatTest, WebKitBraceBreaking) { 8261 FormatStyle WebKitBraceStyle = getLLVMStyle(); 8262 WebKitBraceStyle.BreakBeforeBraces = FormatStyle::BS_WebKit; 8263 verifyFormat("namespace a {\n" 8264 "class A {\n" 8265 " void f()\n" 8266 " {\n" 8267 " if (true) {\n" 8268 " a();\n" 8269 " b();\n" 8270 " }\n" 8271 " }\n" 8272 " void g() { return; }\n" 8273 "};\n" 8274 "enum E {\n" 8275 " A,\n" 8276 " // foo\n" 8277 " B,\n" 8278 " C\n" 8279 "};\n" 8280 "struct B {\n" 8281 " int x;\n" 8282 "};\n" 8283 "}\n", 8284 WebKitBraceStyle); 8285 verifyFormat("struct S {\n" 8286 " int Type;\n" 8287 " union {\n" 8288 " int x;\n" 8289 " double y;\n" 8290 " } Value;\n" 8291 " class C {\n" 8292 " MyFavoriteType Value;\n" 8293 " } Class;\n" 8294 "};\n", 8295 WebKitBraceStyle); 8296 } 8297 8298 TEST_F(FormatTest, CatchExceptionReferenceBinding) { 8299 verifyFormat("void f() {\n" 8300 " try {\n" 8301 " } catch (const Exception &e) {\n" 8302 " }\n" 8303 "}\n", 8304 getLLVMStyle()); 8305 } 8306 8307 TEST_F(FormatTest, UnderstandsPragmas) { 8308 verifyFormat("#pragma omp reduction(| : var)"); 8309 verifyFormat("#pragma omp reduction(+ : var)"); 8310 8311 EXPECT_EQ("#pragma mark Any non-hyphenated or hyphenated string " 8312 "(including parentheses).", 8313 format("#pragma mark Any non-hyphenated or hyphenated string " 8314 "(including parentheses).")); 8315 } 8316 8317 TEST_F(FormatTest, UnderstandPragmaOption) { 8318 verifyFormat("#pragma option -C -A"); 8319 8320 EXPECT_EQ("#pragma option -C -A", format("#pragma option -C -A")); 8321 } 8322 8323 #define EXPECT_ALL_STYLES_EQUAL(Styles) \ 8324 for (size_t i = 1; i < Styles.size(); ++i) \ 8325 EXPECT_EQ(Styles[0], Styles[i]) << "Style #" << i << " of " << Styles.size() \ 8326 << " differs from Style #0" 8327 8328 TEST_F(FormatTest, GetsPredefinedStyleByName) { 8329 SmallVector<FormatStyle, 3> Styles; 8330 Styles.resize(3); 8331 8332 Styles[0] = getLLVMStyle(); 8333 EXPECT_TRUE(getPredefinedStyle("LLVM", FormatStyle::LK_Cpp, &Styles[1])); 8334 EXPECT_TRUE(getPredefinedStyle("lLvM", FormatStyle::LK_Cpp, &Styles[2])); 8335 EXPECT_ALL_STYLES_EQUAL(Styles); 8336 8337 Styles[0] = getGoogleStyle(); 8338 EXPECT_TRUE(getPredefinedStyle("Google", FormatStyle::LK_Cpp, &Styles[1])); 8339 EXPECT_TRUE(getPredefinedStyle("gOOgle", FormatStyle::LK_Cpp, &Styles[2])); 8340 EXPECT_ALL_STYLES_EQUAL(Styles); 8341 8342 Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript); 8343 EXPECT_TRUE( 8344 getPredefinedStyle("Google", FormatStyle::LK_JavaScript, &Styles[1])); 8345 EXPECT_TRUE( 8346 getPredefinedStyle("gOOgle", FormatStyle::LK_JavaScript, &Styles[2])); 8347 EXPECT_ALL_STYLES_EQUAL(Styles); 8348 8349 Styles[0] = getChromiumStyle(FormatStyle::LK_Cpp); 8350 EXPECT_TRUE(getPredefinedStyle("Chromium", FormatStyle::LK_Cpp, &Styles[1])); 8351 EXPECT_TRUE(getPredefinedStyle("cHRoMiUM", FormatStyle::LK_Cpp, &Styles[2])); 8352 EXPECT_ALL_STYLES_EQUAL(Styles); 8353 8354 Styles[0] = getMozillaStyle(); 8355 EXPECT_TRUE(getPredefinedStyle("Mozilla", FormatStyle::LK_Cpp, &Styles[1])); 8356 EXPECT_TRUE(getPredefinedStyle("moZILla", FormatStyle::LK_Cpp, &Styles[2])); 8357 EXPECT_ALL_STYLES_EQUAL(Styles); 8358 8359 Styles[0] = getWebKitStyle(); 8360 EXPECT_TRUE(getPredefinedStyle("WebKit", FormatStyle::LK_Cpp, &Styles[1])); 8361 EXPECT_TRUE(getPredefinedStyle("wEbKit", FormatStyle::LK_Cpp, &Styles[2])); 8362 EXPECT_ALL_STYLES_EQUAL(Styles); 8363 8364 Styles[0] = getGNUStyle(); 8365 EXPECT_TRUE(getPredefinedStyle("GNU", FormatStyle::LK_Cpp, &Styles[1])); 8366 EXPECT_TRUE(getPredefinedStyle("gnU", FormatStyle::LK_Cpp, &Styles[2])); 8367 EXPECT_ALL_STYLES_EQUAL(Styles); 8368 8369 EXPECT_FALSE(getPredefinedStyle("qwerty", FormatStyle::LK_Cpp, &Styles[0])); 8370 } 8371 8372 TEST_F(FormatTest, GetsCorrectBasedOnStyle) { 8373 SmallVector<FormatStyle, 8> Styles; 8374 Styles.resize(2); 8375 8376 Styles[0] = getGoogleStyle(); 8377 Styles[1] = getLLVMStyle(); 8378 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value()); 8379 EXPECT_ALL_STYLES_EQUAL(Styles); 8380 8381 Styles.resize(5); 8382 Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript); 8383 Styles[1] = getLLVMStyle(); 8384 Styles[1].Language = FormatStyle::LK_JavaScript; 8385 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value()); 8386 8387 Styles[2] = getLLVMStyle(); 8388 Styles[2].Language = FormatStyle::LK_JavaScript; 8389 EXPECT_EQ(0, parseConfiguration("Language: JavaScript\n" 8390 "BasedOnStyle: Google", 8391 &Styles[2]) 8392 .value()); 8393 8394 Styles[3] = getLLVMStyle(); 8395 Styles[3].Language = FormatStyle::LK_JavaScript; 8396 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google\n" 8397 "Language: JavaScript", 8398 &Styles[3]) 8399 .value()); 8400 8401 Styles[4] = getLLVMStyle(); 8402 Styles[4].Language = FormatStyle::LK_JavaScript; 8403 EXPECT_EQ(0, parseConfiguration("---\n" 8404 "BasedOnStyle: LLVM\n" 8405 "IndentWidth: 123\n" 8406 "---\n" 8407 "BasedOnStyle: Google\n" 8408 "Language: JavaScript", 8409 &Styles[4]) 8410 .value()); 8411 EXPECT_ALL_STYLES_EQUAL(Styles); 8412 } 8413 8414 #define CHECK_PARSE_BOOL_FIELD(FIELD, CONFIG_NAME) \ 8415 Style.FIELD = false; \ 8416 EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": true", &Style).value()); \ 8417 EXPECT_TRUE(Style.FIELD); \ 8418 EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": false", &Style).value()); \ 8419 EXPECT_FALSE(Style.FIELD); 8420 8421 #define CHECK_PARSE_BOOL(FIELD) CHECK_PARSE_BOOL_FIELD(FIELD, #FIELD) 8422 8423 #define CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, CONFIG_NAME) \ 8424 Style.STRUCT.FIELD = false; \ 8425 EXPECT_EQ(0, \ 8426 parseConfiguration(#STRUCT ":\n " CONFIG_NAME ": true", &Style) \ 8427 .value()); \ 8428 EXPECT_TRUE(Style.STRUCT.FIELD); \ 8429 EXPECT_EQ(0, \ 8430 parseConfiguration(#STRUCT ":\n " CONFIG_NAME ": false", &Style) \ 8431 .value()); \ 8432 EXPECT_FALSE(Style.STRUCT.FIELD); 8433 8434 #define CHECK_PARSE_NESTED_BOOL(STRUCT, FIELD) \ 8435 CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, #FIELD) 8436 8437 #define CHECK_PARSE(TEXT, FIELD, VALUE) \ 8438 EXPECT_NE(VALUE, Style.FIELD); \ 8439 EXPECT_EQ(0, parseConfiguration(TEXT, &Style).value()); \ 8440 EXPECT_EQ(VALUE, Style.FIELD) 8441 8442 TEST_F(FormatTest, ParsesConfigurationBools) { 8443 FormatStyle Style = {}; 8444 Style.Language = FormatStyle::LK_Cpp; 8445 CHECK_PARSE_BOOL(AlignEscapedNewlinesLeft); 8446 CHECK_PARSE_BOOL(AlignOperands); 8447 CHECK_PARSE_BOOL(AlignTrailingComments); 8448 CHECK_PARSE_BOOL(AlignConsecutiveAssignments); 8449 CHECK_PARSE_BOOL(AlignConsecutiveDeclarations); 8450 CHECK_PARSE_BOOL(AllowAllParametersOfDeclarationOnNextLine); 8451 CHECK_PARSE_BOOL(AllowShortBlocksOnASingleLine); 8452 CHECK_PARSE_BOOL(AllowShortCaseLabelsOnASingleLine); 8453 CHECK_PARSE_BOOL(AllowShortIfStatementsOnASingleLine); 8454 CHECK_PARSE_BOOL(AllowShortLoopsOnASingleLine); 8455 CHECK_PARSE_BOOL(AlwaysBreakTemplateDeclarations); 8456 CHECK_PARSE_BOOL(BinPackArguments); 8457 CHECK_PARSE_BOOL(BinPackParameters); 8458 CHECK_PARSE_BOOL(BreakAfterJavaFieldAnnotations); 8459 CHECK_PARSE_BOOL(BreakBeforeTernaryOperators); 8460 CHECK_PARSE_BOOL(BreakConstructorInitializersBeforeComma); 8461 CHECK_PARSE_BOOL(BreakStringLiterals); 8462 CHECK_PARSE_BOOL(ConstructorInitializerAllOnOneLineOrOnePerLine); 8463 CHECK_PARSE_BOOL(DerivePointerAlignment); 8464 CHECK_PARSE_BOOL_FIELD(DerivePointerAlignment, "DerivePointerBinding"); 8465 CHECK_PARSE_BOOL(DisableFormat); 8466 CHECK_PARSE_BOOL(IndentCaseLabels); 8467 CHECK_PARSE_BOOL(IndentWrappedFunctionNames); 8468 CHECK_PARSE_BOOL(KeepEmptyLinesAtTheStartOfBlocks); 8469 CHECK_PARSE_BOOL(ObjCSpaceAfterProperty); 8470 CHECK_PARSE_BOOL(ObjCSpaceBeforeProtocolList); 8471 CHECK_PARSE_BOOL(Cpp11BracedListStyle); 8472 CHECK_PARSE_BOOL(ReflowComments); 8473 CHECK_PARSE_BOOL(SortIncludes); 8474 CHECK_PARSE_BOOL(SpacesInParentheses); 8475 CHECK_PARSE_BOOL(SpacesInSquareBrackets); 8476 CHECK_PARSE_BOOL(SpacesInAngles); 8477 CHECK_PARSE_BOOL(SpaceInEmptyParentheses); 8478 CHECK_PARSE_BOOL(SpacesInContainerLiterals); 8479 CHECK_PARSE_BOOL(SpacesInCStyleCastParentheses); 8480 CHECK_PARSE_BOOL(SpaceAfterCStyleCast); 8481 CHECK_PARSE_BOOL(SpaceAfterTemplateKeyword); 8482 CHECK_PARSE_BOOL(SpaceBeforeAssignmentOperators); 8483 8484 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterClass); 8485 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterControlStatement); 8486 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterEnum); 8487 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterFunction); 8488 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterNamespace); 8489 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterObjCDeclaration); 8490 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterStruct); 8491 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterUnion); 8492 CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeCatch); 8493 CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeElse); 8494 CHECK_PARSE_NESTED_BOOL(BraceWrapping, IndentBraces); 8495 } 8496 8497 #undef CHECK_PARSE_BOOL 8498 8499 TEST_F(FormatTest, ParsesConfiguration) { 8500 FormatStyle Style = {}; 8501 Style.Language = FormatStyle::LK_Cpp; 8502 CHECK_PARSE("AccessModifierOffset: -1234", AccessModifierOffset, -1234); 8503 CHECK_PARSE("ConstructorInitializerIndentWidth: 1234", 8504 ConstructorInitializerIndentWidth, 1234u); 8505 CHECK_PARSE("ObjCBlockIndentWidth: 1234", ObjCBlockIndentWidth, 1234u); 8506 CHECK_PARSE("ColumnLimit: 1234", ColumnLimit, 1234u); 8507 CHECK_PARSE("MaxEmptyLinesToKeep: 1234", MaxEmptyLinesToKeep, 1234u); 8508 CHECK_PARSE("PenaltyBreakBeforeFirstCallParameter: 1234", 8509 PenaltyBreakBeforeFirstCallParameter, 1234u); 8510 CHECK_PARSE("PenaltyExcessCharacter: 1234", PenaltyExcessCharacter, 1234u); 8511 CHECK_PARSE("PenaltyReturnTypeOnItsOwnLine: 1234", 8512 PenaltyReturnTypeOnItsOwnLine, 1234u); 8513 CHECK_PARSE("SpacesBeforeTrailingComments: 1234", 8514 SpacesBeforeTrailingComments, 1234u); 8515 CHECK_PARSE("IndentWidth: 32", IndentWidth, 32u); 8516 CHECK_PARSE("ContinuationIndentWidth: 11", ContinuationIndentWidth, 11u); 8517 CHECK_PARSE("CommentPragmas: '// abc$'", CommentPragmas, "// abc$"); 8518 8519 Style.PointerAlignment = FormatStyle::PAS_Middle; 8520 CHECK_PARSE("PointerAlignment: Left", PointerAlignment, 8521 FormatStyle::PAS_Left); 8522 CHECK_PARSE("PointerAlignment: Right", PointerAlignment, 8523 FormatStyle::PAS_Right); 8524 CHECK_PARSE("PointerAlignment: Middle", PointerAlignment, 8525 FormatStyle::PAS_Middle); 8526 // For backward compatibility: 8527 CHECK_PARSE("PointerBindsToType: Left", PointerAlignment, 8528 FormatStyle::PAS_Left); 8529 CHECK_PARSE("PointerBindsToType: Right", PointerAlignment, 8530 FormatStyle::PAS_Right); 8531 CHECK_PARSE("PointerBindsToType: Middle", PointerAlignment, 8532 FormatStyle::PAS_Middle); 8533 8534 Style.Standard = FormatStyle::LS_Auto; 8535 CHECK_PARSE("Standard: Cpp03", Standard, FormatStyle::LS_Cpp03); 8536 CHECK_PARSE("Standard: Cpp11", Standard, FormatStyle::LS_Cpp11); 8537 CHECK_PARSE("Standard: C++03", Standard, FormatStyle::LS_Cpp03); 8538 CHECK_PARSE("Standard: C++11", Standard, FormatStyle::LS_Cpp11); 8539 CHECK_PARSE("Standard: Auto", Standard, FormatStyle::LS_Auto); 8540 8541 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 8542 CHECK_PARSE("BreakBeforeBinaryOperators: NonAssignment", 8543 BreakBeforeBinaryOperators, FormatStyle::BOS_NonAssignment); 8544 CHECK_PARSE("BreakBeforeBinaryOperators: None", BreakBeforeBinaryOperators, 8545 FormatStyle::BOS_None); 8546 CHECK_PARSE("BreakBeforeBinaryOperators: All", BreakBeforeBinaryOperators, 8547 FormatStyle::BOS_All); 8548 // For backward compatibility: 8549 CHECK_PARSE("BreakBeforeBinaryOperators: false", BreakBeforeBinaryOperators, 8550 FormatStyle::BOS_None); 8551 CHECK_PARSE("BreakBeforeBinaryOperators: true", BreakBeforeBinaryOperators, 8552 FormatStyle::BOS_All); 8553 8554 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 8555 CHECK_PARSE("AlignAfterOpenBracket: Align", AlignAfterOpenBracket, 8556 FormatStyle::BAS_Align); 8557 CHECK_PARSE("AlignAfterOpenBracket: DontAlign", AlignAfterOpenBracket, 8558 FormatStyle::BAS_DontAlign); 8559 CHECK_PARSE("AlignAfterOpenBracket: AlwaysBreak", AlignAfterOpenBracket, 8560 FormatStyle::BAS_AlwaysBreak); 8561 // For backward compatibility: 8562 CHECK_PARSE("AlignAfterOpenBracket: false", AlignAfterOpenBracket, 8563 FormatStyle::BAS_DontAlign); 8564 CHECK_PARSE("AlignAfterOpenBracket: true", AlignAfterOpenBracket, 8565 FormatStyle::BAS_Align); 8566 8567 Style.UseTab = FormatStyle::UT_ForIndentation; 8568 CHECK_PARSE("UseTab: Never", UseTab, FormatStyle::UT_Never); 8569 CHECK_PARSE("UseTab: ForIndentation", UseTab, FormatStyle::UT_ForIndentation); 8570 CHECK_PARSE("UseTab: Always", UseTab, FormatStyle::UT_Always); 8571 CHECK_PARSE("UseTab: ForContinuationAndIndentation", UseTab, 8572 FormatStyle::UT_ForContinuationAndIndentation); 8573 // For backward compatibility: 8574 CHECK_PARSE("UseTab: false", UseTab, FormatStyle::UT_Never); 8575 CHECK_PARSE("UseTab: true", UseTab, FormatStyle::UT_Always); 8576 8577 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; 8578 CHECK_PARSE("AllowShortFunctionsOnASingleLine: None", 8579 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None); 8580 CHECK_PARSE("AllowShortFunctionsOnASingleLine: Inline", 8581 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Inline); 8582 CHECK_PARSE("AllowShortFunctionsOnASingleLine: Empty", 8583 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Empty); 8584 CHECK_PARSE("AllowShortFunctionsOnASingleLine: All", 8585 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All); 8586 // For backward compatibility: 8587 CHECK_PARSE("AllowShortFunctionsOnASingleLine: false", 8588 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None); 8589 CHECK_PARSE("AllowShortFunctionsOnASingleLine: true", 8590 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All); 8591 8592 Style.SpaceBeforeParens = FormatStyle::SBPO_Always; 8593 CHECK_PARSE("SpaceBeforeParens: Never", SpaceBeforeParens, 8594 FormatStyle::SBPO_Never); 8595 CHECK_PARSE("SpaceBeforeParens: Always", SpaceBeforeParens, 8596 FormatStyle::SBPO_Always); 8597 CHECK_PARSE("SpaceBeforeParens: ControlStatements", SpaceBeforeParens, 8598 FormatStyle::SBPO_ControlStatements); 8599 // For backward compatibility: 8600 CHECK_PARSE("SpaceAfterControlStatementKeyword: false", SpaceBeforeParens, 8601 FormatStyle::SBPO_Never); 8602 CHECK_PARSE("SpaceAfterControlStatementKeyword: true", SpaceBeforeParens, 8603 FormatStyle::SBPO_ControlStatements); 8604 8605 Style.ColumnLimit = 123; 8606 FormatStyle BaseStyle = getLLVMStyle(); 8607 CHECK_PARSE("BasedOnStyle: LLVM", ColumnLimit, BaseStyle.ColumnLimit); 8608 CHECK_PARSE("BasedOnStyle: LLVM\nColumnLimit: 1234", ColumnLimit, 1234u); 8609 8610 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 8611 CHECK_PARSE("BreakBeforeBraces: Attach", BreakBeforeBraces, 8612 FormatStyle::BS_Attach); 8613 CHECK_PARSE("BreakBeforeBraces: Linux", BreakBeforeBraces, 8614 FormatStyle::BS_Linux); 8615 CHECK_PARSE("BreakBeforeBraces: Mozilla", BreakBeforeBraces, 8616 FormatStyle::BS_Mozilla); 8617 CHECK_PARSE("BreakBeforeBraces: Stroustrup", BreakBeforeBraces, 8618 FormatStyle::BS_Stroustrup); 8619 CHECK_PARSE("BreakBeforeBraces: Allman", BreakBeforeBraces, 8620 FormatStyle::BS_Allman); 8621 CHECK_PARSE("BreakBeforeBraces: GNU", BreakBeforeBraces, FormatStyle::BS_GNU); 8622 CHECK_PARSE("BreakBeforeBraces: WebKit", BreakBeforeBraces, 8623 FormatStyle::BS_WebKit); 8624 CHECK_PARSE("BreakBeforeBraces: Custom", BreakBeforeBraces, 8625 FormatStyle::BS_Custom); 8626 8627 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All; 8628 CHECK_PARSE("AlwaysBreakAfterReturnType: None", AlwaysBreakAfterReturnType, 8629 FormatStyle::RTBS_None); 8630 CHECK_PARSE("AlwaysBreakAfterReturnType: All", AlwaysBreakAfterReturnType, 8631 FormatStyle::RTBS_All); 8632 CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevel", 8633 AlwaysBreakAfterReturnType, FormatStyle::RTBS_TopLevel); 8634 CHECK_PARSE("AlwaysBreakAfterReturnType: AllDefinitions", 8635 AlwaysBreakAfterReturnType, FormatStyle::RTBS_AllDefinitions); 8636 CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevelDefinitions", 8637 AlwaysBreakAfterReturnType, 8638 FormatStyle::RTBS_TopLevelDefinitions); 8639 8640 Style.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_All; 8641 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: None", 8642 AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_None); 8643 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: All", 8644 AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_All); 8645 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: TopLevel", 8646 AlwaysBreakAfterDefinitionReturnType, 8647 FormatStyle::DRTBS_TopLevel); 8648 8649 Style.NamespaceIndentation = FormatStyle::NI_All; 8650 CHECK_PARSE("NamespaceIndentation: None", NamespaceIndentation, 8651 FormatStyle::NI_None); 8652 CHECK_PARSE("NamespaceIndentation: Inner", NamespaceIndentation, 8653 FormatStyle::NI_Inner); 8654 CHECK_PARSE("NamespaceIndentation: All", NamespaceIndentation, 8655 FormatStyle::NI_All); 8656 8657 // FIXME: This is required because parsing a configuration simply overwrites 8658 // the first N elements of the list instead of resetting it. 8659 Style.ForEachMacros.clear(); 8660 std::vector<std::string> BoostForeach; 8661 BoostForeach.push_back("BOOST_FOREACH"); 8662 CHECK_PARSE("ForEachMacros: [BOOST_FOREACH]", ForEachMacros, BoostForeach); 8663 std::vector<std::string> BoostAndQForeach; 8664 BoostAndQForeach.push_back("BOOST_FOREACH"); 8665 BoostAndQForeach.push_back("Q_FOREACH"); 8666 CHECK_PARSE("ForEachMacros: [BOOST_FOREACH, Q_FOREACH]", ForEachMacros, 8667 BoostAndQForeach); 8668 8669 Style.IncludeCategories.clear(); 8670 std::vector<FormatStyle::IncludeCategory> ExpectedCategories = {{"abc/.*", 2}, 8671 {".*", 1}}; 8672 CHECK_PARSE("IncludeCategories:\n" 8673 " - Regex: abc/.*\n" 8674 " Priority: 2\n" 8675 " - Regex: .*\n" 8676 " Priority: 1", 8677 IncludeCategories, ExpectedCategories); 8678 CHECK_PARSE("IncludeIsMainRegex: 'abc$'", IncludeIsMainRegex, "abc$"); 8679 } 8680 8681 TEST_F(FormatTest, ParsesConfigurationWithLanguages) { 8682 FormatStyle Style = {}; 8683 Style.Language = FormatStyle::LK_Cpp; 8684 CHECK_PARSE("Language: Cpp\n" 8685 "IndentWidth: 12", 8686 IndentWidth, 12u); 8687 EXPECT_EQ(parseConfiguration("Language: JavaScript\n" 8688 "IndentWidth: 34", 8689 &Style), 8690 ParseError::Unsuitable); 8691 EXPECT_EQ(12u, Style.IndentWidth); 8692 CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u); 8693 EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language); 8694 8695 Style.Language = FormatStyle::LK_JavaScript; 8696 CHECK_PARSE("Language: JavaScript\n" 8697 "IndentWidth: 12", 8698 IndentWidth, 12u); 8699 CHECK_PARSE("IndentWidth: 23", IndentWidth, 23u); 8700 EXPECT_EQ(parseConfiguration("Language: Cpp\n" 8701 "IndentWidth: 34", 8702 &Style), 8703 ParseError::Unsuitable); 8704 EXPECT_EQ(23u, Style.IndentWidth); 8705 CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u); 8706 EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language); 8707 8708 CHECK_PARSE("BasedOnStyle: LLVM\n" 8709 "IndentWidth: 67", 8710 IndentWidth, 67u); 8711 8712 CHECK_PARSE("---\n" 8713 "Language: JavaScript\n" 8714 "IndentWidth: 12\n" 8715 "---\n" 8716 "Language: Cpp\n" 8717 "IndentWidth: 34\n" 8718 "...\n", 8719 IndentWidth, 12u); 8720 8721 Style.Language = FormatStyle::LK_Cpp; 8722 CHECK_PARSE("---\n" 8723 "Language: JavaScript\n" 8724 "IndentWidth: 12\n" 8725 "---\n" 8726 "Language: Cpp\n" 8727 "IndentWidth: 34\n" 8728 "...\n", 8729 IndentWidth, 34u); 8730 CHECK_PARSE("---\n" 8731 "IndentWidth: 78\n" 8732 "---\n" 8733 "Language: JavaScript\n" 8734 "IndentWidth: 56\n" 8735 "...\n", 8736 IndentWidth, 78u); 8737 8738 Style.ColumnLimit = 123; 8739 Style.IndentWidth = 234; 8740 Style.BreakBeforeBraces = FormatStyle::BS_Linux; 8741 Style.TabWidth = 345; 8742 EXPECT_FALSE(parseConfiguration("---\n" 8743 "IndentWidth: 456\n" 8744 "BreakBeforeBraces: Allman\n" 8745 "---\n" 8746 "Language: JavaScript\n" 8747 "IndentWidth: 111\n" 8748 "TabWidth: 111\n" 8749 "---\n" 8750 "Language: Cpp\n" 8751 "BreakBeforeBraces: Stroustrup\n" 8752 "TabWidth: 789\n" 8753 "...\n", 8754 &Style)); 8755 EXPECT_EQ(123u, Style.ColumnLimit); 8756 EXPECT_EQ(456u, Style.IndentWidth); 8757 EXPECT_EQ(FormatStyle::BS_Stroustrup, Style.BreakBeforeBraces); 8758 EXPECT_EQ(789u, Style.TabWidth); 8759 8760 EXPECT_EQ(parseConfiguration("---\n" 8761 "Language: JavaScript\n" 8762 "IndentWidth: 56\n" 8763 "---\n" 8764 "IndentWidth: 78\n" 8765 "...\n", 8766 &Style), 8767 ParseError::Error); 8768 EXPECT_EQ(parseConfiguration("---\n" 8769 "Language: JavaScript\n" 8770 "IndentWidth: 56\n" 8771 "---\n" 8772 "Language: JavaScript\n" 8773 "IndentWidth: 78\n" 8774 "...\n", 8775 &Style), 8776 ParseError::Error); 8777 8778 EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language); 8779 } 8780 8781 #undef CHECK_PARSE 8782 8783 TEST_F(FormatTest, UsesLanguageForBasedOnStyle) { 8784 FormatStyle Style = {}; 8785 Style.Language = FormatStyle::LK_JavaScript; 8786 Style.BreakBeforeTernaryOperators = true; 8787 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Style).value()); 8788 EXPECT_FALSE(Style.BreakBeforeTernaryOperators); 8789 8790 Style.BreakBeforeTernaryOperators = true; 8791 EXPECT_EQ(0, parseConfiguration("---\n" 8792 "BasedOnStyle: Google\n" 8793 "---\n" 8794 "Language: JavaScript\n" 8795 "IndentWidth: 76\n" 8796 "...\n", 8797 &Style) 8798 .value()); 8799 EXPECT_FALSE(Style.BreakBeforeTernaryOperators); 8800 EXPECT_EQ(76u, Style.IndentWidth); 8801 EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language); 8802 } 8803 8804 TEST_F(FormatTest, ConfigurationRoundTripTest) { 8805 FormatStyle Style = getLLVMStyle(); 8806 std::string YAML = configurationAsText(Style); 8807 FormatStyle ParsedStyle = {}; 8808 ParsedStyle.Language = FormatStyle::LK_Cpp; 8809 EXPECT_EQ(0, parseConfiguration(YAML, &ParsedStyle).value()); 8810 EXPECT_EQ(Style, ParsedStyle); 8811 } 8812 8813 TEST_F(FormatTest, WorksFor8bitEncodings) { 8814 EXPECT_EQ("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 \"\n" 8815 "\"\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \"\n" 8816 "\"\xe7\xe8\xec\xed\xfe\xfe \"\n" 8817 "\"\xef\xee\xf0\xf3...\"", 8818 format("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 " 8819 "\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \xe7\xe8\xec\xed\xfe\xfe " 8820 "\xef\xee\xf0\xf3...\"", 8821 getLLVMStyleWithColumns(12))); 8822 } 8823 8824 TEST_F(FormatTest, HandlesUTF8BOM) { 8825 EXPECT_EQ("\xef\xbb\xbf", format("\xef\xbb\xbf")); 8826 EXPECT_EQ("\xef\xbb\xbf#include <iostream>", 8827 format("\xef\xbb\xbf#include <iostream>")); 8828 EXPECT_EQ("\xef\xbb\xbf\n#include <iostream>", 8829 format("\xef\xbb\xbf\n#include <iostream>")); 8830 } 8831 8832 // FIXME: Encode Cyrillic and CJK characters below to appease MS compilers. 8833 #if !defined(_MSC_VER) 8834 8835 TEST_F(FormatTest, CountsUTF8CharactersProperly) { 8836 verifyFormat("\"Однажды в студёную зимнюю пору...\"", 8837 getLLVMStyleWithColumns(35)); 8838 verifyFormat("\"一 二 三 四 五 六 七 八 九 十\"", 8839 getLLVMStyleWithColumns(31)); 8840 verifyFormat("// Однажды в студёную зимнюю пору...", 8841 getLLVMStyleWithColumns(36)); 8842 verifyFormat("// 一 二 三 四 五 六 七 八 九 十", getLLVMStyleWithColumns(32)); 8843 verifyFormat("/* Однажды в студёную зимнюю пору... */", 8844 getLLVMStyleWithColumns(39)); 8845 verifyFormat("/* 一 二 三 四 五 六 七 八 九 十 */", 8846 getLLVMStyleWithColumns(35)); 8847 } 8848 8849 TEST_F(FormatTest, SplitsUTF8Strings) { 8850 // Non-printable characters' width is currently considered to be the length in 8851 // bytes in UTF8. The characters can be displayed in very different manner 8852 // (zero-width, single width with a substitution glyph, expanded to their code 8853 // (e.g. "<8d>"), so there's no single correct way to handle them. 8854 EXPECT_EQ("\"aaaaÄ\"\n" 8855 "\"\xc2\x8d\";", 8856 format("\"aaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10))); 8857 EXPECT_EQ("\"aaaaaaaÄ\"\n" 8858 "\"\xc2\x8d\";", 8859 format("\"aaaaaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10))); 8860 EXPECT_EQ("\"Однажды, в \"\n" 8861 "\"студёную \"\n" 8862 "\"зимнюю \"\n" 8863 "\"пору,\"", 8864 format("\"Однажды, в студёную зимнюю пору,\"", 8865 getLLVMStyleWithColumns(13))); 8866 EXPECT_EQ( 8867 "\"一 二 三 \"\n" 8868 "\"四 五六 \"\n" 8869 "\"七 八 九 \"\n" 8870 "\"十\"", 8871 format("\"一 二 三 四 五六 七 八 九 十\"", getLLVMStyleWithColumns(11))); 8872 EXPECT_EQ("\"一\t二 \"\n" 8873 "\"\t三 \"\n" 8874 "\"四 五\t六 \"\n" 8875 "\"\t七 \"\n" 8876 "\"八九十\tqq\"", 8877 format("\"一\t二 \t三 四 五\t六 \t七 八九十\tqq\"", 8878 getLLVMStyleWithColumns(11))); 8879 8880 // UTF8 character in an escape sequence. 8881 EXPECT_EQ("\"aaaaaa\"\n" 8882 "\"\\\xC2\x8D\"", 8883 format("\"aaaaaa\\\xC2\x8D\"", getLLVMStyleWithColumns(10))); 8884 } 8885 8886 TEST_F(FormatTest, HandlesDoubleWidthCharsInMultiLineStrings) { 8887 EXPECT_EQ("const char *sssss =\n" 8888 " \"一二三四五六七八\\\n" 8889 " 九 十\";", 8890 format("const char *sssss = \"一二三四五六七八\\\n" 8891 " 九 十\";", 8892 getLLVMStyleWithColumns(30))); 8893 } 8894 8895 TEST_F(FormatTest, SplitsUTF8LineComments) { 8896 EXPECT_EQ("// aaaaÄ\xc2\x8d", 8897 format("// aaaaÄ\xc2\x8d", getLLVMStyleWithColumns(10))); 8898 EXPECT_EQ("// Я из лесу\n" 8899 "// вышел; был\n" 8900 "// сильный\n" 8901 "// мороз.", 8902 format("// Я из лесу вышел; был сильный мороз.", 8903 getLLVMStyleWithColumns(13))); 8904 EXPECT_EQ("// 一二三\n" 8905 "// 四五六七\n" 8906 "// 八 九\n" 8907 "// 十", 8908 format("// 一二三 四五六七 八 九 十", getLLVMStyleWithColumns(9))); 8909 } 8910 8911 TEST_F(FormatTest, SplitsUTF8BlockComments) { 8912 EXPECT_EQ("/* Гляжу,\n" 8913 " * поднимается\n" 8914 " * медленно в\n" 8915 " * гору\n" 8916 " * Лошадка,\n" 8917 " * везущая\n" 8918 " * хворосту\n" 8919 " * воз. */", 8920 format("/* Гляжу, поднимается медленно в гору\n" 8921 " * Лошадка, везущая хворосту воз. */", 8922 getLLVMStyleWithColumns(13))); 8923 EXPECT_EQ( 8924 "/* 一二三\n" 8925 " * 四五六七\n" 8926 " * 八 九\n" 8927 " * 十 */", 8928 format("/* 一二三 四五六七 八 九 十 */", getLLVMStyleWithColumns(9))); 8929 EXPECT_EQ("/* �������� ��������\n" 8930 " * ��������\n" 8931 " * ������-�� */", 8932 format("/* �������� �������� �������� ������-�� */", getLLVMStyleWithColumns(12))); 8933 } 8934 8935 #endif // _MSC_VER 8936 8937 TEST_F(FormatTest, ConstructorInitializerIndentWidth) { 8938 FormatStyle Style = getLLVMStyle(); 8939 8940 Style.ConstructorInitializerIndentWidth = 4; 8941 verifyFormat( 8942 "SomeClass::Constructor()\n" 8943 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 8944 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 8945 Style); 8946 8947 Style.ConstructorInitializerIndentWidth = 2; 8948 verifyFormat( 8949 "SomeClass::Constructor()\n" 8950 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 8951 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 8952 Style); 8953 8954 Style.ConstructorInitializerIndentWidth = 0; 8955 verifyFormat( 8956 "SomeClass::Constructor()\n" 8957 ": aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 8958 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 8959 Style); 8960 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 8961 verifyFormat( 8962 "SomeLongTemplateVariableName<\n" 8963 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>", 8964 Style); 8965 verifyFormat( 8966 "bool smaller = 1 < bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 8967 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 8968 Style); 8969 } 8970 8971 TEST_F(FormatTest, BreakConstructorInitializersBeforeComma) { 8972 FormatStyle Style = getLLVMStyle(); 8973 Style.BreakConstructorInitializersBeforeComma = true; 8974 Style.ConstructorInitializerIndentWidth = 4; 8975 verifyFormat("SomeClass::Constructor()\n" 8976 " : a(a)\n" 8977 " , b(b)\n" 8978 " , c(c) {}", 8979 Style); 8980 verifyFormat("SomeClass::Constructor()\n" 8981 " : a(a) {}", 8982 Style); 8983 8984 Style.ColumnLimit = 0; 8985 verifyFormat("SomeClass::Constructor()\n" 8986 " : a(a) {}", 8987 Style); 8988 verifyFormat("SomeClass::Constructor() noexcept\n" 8989 " : a(a) {}", 8990 Style); 8991 verifyFormat("SomeClass::Constructor()\n" 8992 " : a(a)\n" 8993 " , b(b)\n" 8994 " , c(c) {}", 8995 Style); 8996 verifyFormat("SomeClass::Constructor()\n" 8997 " : a(a) {\n" 8998 " foo();\n" 8999 " bar();\n" 9000 "}", 9001 Style); 9002 9003 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 9004 verifyFormat("SomeClass::Constructor()\n" 9005 " : a(a)\n" 9006 " , b(b)\n" 9007 " , c(c) {\n}", 9008 Style); 9009 verifyFormat("SomeClass::Constructor()\n" 9010 " : a(a) {\n}", 9011 Style); 9012 9013 Style.ColumnLimit = 80; 9014 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 9015 Style.ConstructorInitializerIndentWidth = 2; 9016 verifyFormat("SomeClass::Constructor()\n" 9017 " : a(a)\n" 9018 " , b(b)\n" 9019 " , c(c) {}", 9020 Style); 9021 9022 Style.ConstructorInitializerIndentWidth = 0; 9023 verifyFormat("SomeClass::Constructor()\n" 9024 ": a(a)\n" 9025 ", b(b)\n" 9026 ", c(c) {}", 9027 Style); 9028 9029 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 9030 Style.ConstructorInitializerIndentWidth = 4; 9031 verifyFormat("SomeClass::Constructor() : aaaaaaaa(aaaaaaaa) {}", Style); 9032 verifyFormat( 9033 "SomeClass::Constructor() : aaaaa(aaaaa), aaaaa(aaaaa), aaaaa(aaaaa)\n", 9034 Style); 9035 verifyFormat( 9036 "SomeClass::Constructor()\n" 9037 " : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa) {}", 9038 Style); 9039 Style.ConstructorInitializerIndentWidth = 4; 9040 Style.ColumnLimit = 60; 9041 verifyFormat("SomeClass::Constructor()\n" 9042 " : aaaaaaaa(aaaaaaaa)\n" 9043 " , aaaaaaaa(aaaaaaaa)\n" 9044 " , aaaaaaaa(aaaaaaaa) {}", 9045 Style); 9046 } 9047 9048 TEST_F(FormatTest, Destructors) { 9049 verifyFormat("void F(int &i) { i.~int(); }"); 9050 verifyFormat("void F(int &i) { i->~int(); }"); 9051 } 9052 9053 TEST_F(FormatTest, FormatsWithWebKitStyle) { 9054 FormatStyle Style = getWebKitStyle(); 9055 9056 // Don't indent in outer namespaces. 9057 verifyFormat("namespace outer {\n" 9058 "int i;\n" 9059 "namespace inner {\n" 9060 " int i;\n" 9061 "} // namespace inner\n" 9062 "} // namespace outer\n" 9063 "namespace other_outer {\n" 9064 "int i;\n" 9065 "}", 9066 Style); 9067 9068 // Don't indent case labels. 9069 verifyFormat("switch (variable) {\n" 9070 "case 1:\n" 9071 "case 2:\n" 9072 " doSomething();\n" 9073 " break;\n" 9074 "default:\n" 9075 " ++variable;\n" 9076 "}", 9077 Style); 9078 9079 // Wrap before binary operators. 9080 EXPECT_EQ("void f()\n" 9081 "{\n" 9082 " if (aaaaaaaaaaaaaaaa\n" 9083 " && bbbbbbbbbbbbbbbbbbbbbbbb\n" 9084 " && (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n" 9085 " return;\n" 9086 "}", 9087 format("void f() {\n" 9088 "if (aaaaaaaaaaaaaaaa\n" 9089 "&& bbbbbbbbbbbbbbbbbbbbbbbb\n" 9090 "&& (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n" 9091 "return;\n" 9092 "}", 9093 Style)); 9094 9095 // Allow functions on a single line. 9096 verifyFormat("void f() { return; }", Style); 9097 9098 // Constructor initializers are formatted one per line with the "," on the 9099 // new line. 9100 verifyFormat("Constructor()\n" 9101 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 9102 " , aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaa, // break\n" 9103 " aaaaaaaaaaaaaa)\n" 9104 " , aaaaaaaaaaaaaaaaaaaaaaa()\n" 9105 "{\n" 9106 "}", 9107 Style); 9108 verifyFormat("SomeClass::Constructor()\n" 9109 " : a(a)\n" 9110 "{\n" 9111 "}", 9112 Style); 9113 EXPECT_EQ("SomeClass::Constructor()\n" 9114 " : a(a)\n" 9115 "{\n" 9116 "}", 9117 format("SomeClass::Constructor():a(a){}", Style)); 9118 verifyFormat("SomeClass::Constructor()\n" 9119 " : a(a)\n" 9120 " , b(b)\n" 9121 " , c(c)\n" 9122 "{\n" 9123 "}", 9124 Style); 9125 verifyFormat("SomeClass::Constructor()\n" 9126 " : a(a)\n" 9127 "{\n" 9128 " foo();\n" 9129 " bar();\n" 9130 "}", 9131 Style); 9132 9133 // Access specifiers should be aligned left. 9134 verifyFormat("class C {\n" 9135 "public:\n" 9136 " int i;\n" 9137 "};", 9138 Style); 9139 9140 // Do not align comments. 9141 verifyFormat("int a; // Do not\n" 9142 "double b; // align comments.", 9143 Style); 9144 9145 // Do not align operands. 9146 EXPECT_EQ("ASSERT(aaaa\n" 9147 " || bbbb);", 9148 format("ASSERT ( aaaa\n||bbbb);", Style)); 9149 9150 // Accept input's line breaks. 9151 EXPECT_EQ("if (aaaaaaaaaaaaaaa\n" 9152 " || bbbbbbbbbbbbbbb) {\n" 9153 " i++;\n" 9154 "}", 9155 format("if (aaaaaaaaaaaaaaa\n" 9156 "|| bbbbbbbbbbbbbbb) { i++; }", 9157 Style)); 9158 EXPECT_EQ("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) {\n" 9159 " i++;\n" 9160 "}", 9161 format("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) { i++; }", Style)); 9162 9163 // Don't automatically break all macro definitions (llvm.org/PR17842). 9164 verifyFormat("#define aNumber 10", Style); 9165 // However, generally keep the line breaks that the user authored. 9166 EXPECT_EQ("#define aNumber \\\n" 9167 " 10", 9168 format("#define aNumber \\\n" 9169 " 10", 9170 Style)); 9171 9172 // Keep empty and one-element array literals on a single line. 9173 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[]\n" 9174 " copyItems:YES];", 9175 format("NSArray*a=[[NSArray alloc] initWithArray:@[]\n" 9176 "copyItems:YES];", 9177 Style)); 9178 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\" ]\n" 9179 " copyItems:YES];", 9180 format("NSArray*a=[[NSArray alloc]initWithArray:@[ @\"a\" ]\n" 9181 " copyItems:YES];", 9182 Style)); 9183 // FIXME: This does not seem right, there should be more indentation before 9184 // the array literal's entries. Nested blocks have the same problem. 9185 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[\n" 9186 " @\"a\",\n" 9187 " @\"a\"\n" 9188 "]\n" 9189 " copyItems:YES];", 9190 format("NSArray* a = [[NSArray alloc] initWithArray:@[\n" 9191 " @\"a\",\n" 9192 " @\"a\"\n" 9193 " ]\n" 9194 " copyItems:YES];", 9195 Style)); 9196 EXPECT_EQ( 9197 "NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n" 9198 " copyItems:YES];", 9199 format("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n" 9200 " copyItems:YES];", 9201 Style)); 9202 9203 verifyFormat("[self.a b:c c:d];", Style); 9204 EXPECT_EQ("[self.a b:c\n" 9205 " c:d];", 9206 format("[self.a b:c\n" 9207 "c:d];", 9208 Style)); 9209 } 9210 9211 TEST_F(FormatTest, FormatsLambdas) { 9212 verifyFormat("int c = [b]() mutable { return [&b] { return b++; }(); }();\n"); 9213 verifyFormat("int c = [&] { [=] { return b++; }(); }();\n"); 9214 verifyFormat("int c = [&, &a, a] { [=, c, &d] { return b++; }(); }();\n"); 9215 verifyFormat("int c = [&a, &a, a] { [=, a, b, &c] { return b++; }(); }();\n"); 9216 verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] { return b++; }(); }}\n"); 9217 verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] {}(); }}\n"); 9218 verifyFormat("int x = f(*+[] {});"); 9219 verifyFormat("void f() {\n" 9220 " other(x.begin(), x.end(), [&](int, int) { return 1; });\n" 9221 "}\n"); 9222 verifyFormat("void f() {\n" 9223 " other(x.begin(), //\n" 9224 " x.end(), //\n" 9225 " [&](int, int) { return 1; });\n" 9226 "}\n"); 9227 verifyFormat("SomeFunction([]() { // A cool function...\n" 9228 " return 43;\n" 9229 "});"); 9230 EXPECT_EQ("SomeFunction([]() {\n" 9231 "#define A a\n" 9232 " return 43;\n" 9233 "});", 9234 format("SomeFunction([](){\n" 9235 "#define A a\n" 9236 "return 43;\n" 9237 "});")); 9238 verifyFormat("void f() {\n" 9239 " SomeFunction([](decltype(x), A *a) {});\n" 9240 "}"); 9241 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 9242 " [](const aaaaaaaaaa &a) { return a; });"); 9243 verifyFormat("string abc = SomeFunction(aaaaaaaaaaaaa, aaaaa, []() {\n" 9244 " SomeOtherFunctioooooooooooooooooooooooooon();\n" 9245 "});"); 9246 verifyFormat("Constructor()\n" 9247 " : Field([] { // comment\n" 9248 " int i;\n" 9249 " }) {}"); 9250 verifyFormat("auto my_lambda = [](const string &some_parameter) {\n" 9251 " return some_parameter.size();\n" 9252 "};"); 9253 verifyFormat("std::function<std::string(const std::string &)> my_lambda =\n" 9254 " [](const string &s) { return s; };"); 9255 verifyFormat("int i = aaaaaa ? 1 //\n" 9256 " : [] {\n" 9257 " return 2; //\n" 9258 " }();"); 9259 verifyFormat("llvm::errs() << \"number of twos is \"\n" 9260 " << std::count_if(v.begin(), v.end(), [](int x) {\n" 9261 " return x == 2; // force break\n" 9262 " });"); 9263 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa([=](\n" 9264 " int iiiiiiiiiiii) {\n" 9265 " return aaaaaaaaaaaaaaaaaaaaaaa != aaaaaaaaaaaaaaaaaaaaaaa;\n" 9266 "});", 9267 getLLVMStyleWithColumns(60)); 9268 verifyFormat("SomeFunction({[&] {\n" 9269 " // comment\n" 9270 " },\n" 9271 " [&] {\n" 9272 " // comment\n" 9273 " }});"); 9274 verifyFormat("SomeFunction({[&] {\n" 9275 " // comment\n" 9276 "}});"); 9277 verifyFormat("virtual aaaaaaaaaaaaaaaa(std::function<bool()> bbbbbbbbbbbb =\n" 9278 " [&]() { return true; },\n" 9279 " aaaaa aaaaaaaaa);"); 9280 9281 // Lambdas with return types. 9282 verifyFormat("int c = []() -> int { return 2; }();\n"); 9283 verifyFormat("int c = []() -> int * { return 2; }();\n"); 9284 verifyFormat("int c = []() -> vector<int> { return {2}; }();\n"); 9285 verifyFormat("Foo([]() -> std::vector<int> { return {2}; }());"); 9286 verifyGoogleFormat("auto a = [&b, c](D* d) -> D* {};"); 9287 verifyGoogleFormat("auto a = [&b, c](D* d) -> pair<D*, D*> {};"); 9288 verifyGoogleFormat("auto a = [&b, c](D* d) -> D& {};"); 9289 verifyGoogleFormat("auto a = [&b, c](D* d) -> const D* {};"); 9290 verifyFormat("[a, a]() -> a<1> {};"); 9291 verifyFormat("auto aaaaaaaa = [](int i, // break for some reason\n" 9292 " int j) -> int {\n" 9293 " return ffffffffffffffffffffffffffffffffffffffffffff(i * j);\n" 9294 "};"); 9295 verifyFormat( 9296 "aaaaaaaaaaaaaaaaaaaaaa(\n" 9297 " [](aaaaaaaaaaaaaaaaaaaaaaaaaaa &aaa) -> aaaaaaaaaaaaaaaa {\n" 9298 " return aaaaaaaaaaaaaaaaa;\n" 9299 " });", 9300 getLLVMStyleWithColumns(70)); 9301 verifyFormat("[]() //\n" 9302 " -> int {\n" 9303 " return 1; //\n" 9304 "};"); 9305 9306 // Multiple lambdas in the same parentheses change indentation rules. 9307 verifyFormat("SomeFunction(\n" 9308 " []() {\n" 9309 " int i = 42;\n" 9310 " return i;\n" 9311 " },\n" 9312 " []() {\n" 9313 " int j = 43;\n" 9314 " return j;\n" 9315 " });"); 9316 9317 // More complex introducers. 9318 verifyFormat("return [i, args...] {};"); 9319 9320 // Not lambdas. 9321 verifyFormat("constexpr char hello[]{\"hello\"};"); 9322 verifyFormat("double &operator[](int i) { return 0; }\n" 9323 "int i;"); 9324 verifyFormat("std::unique_ptr<int[]> foo() {}"); 9325 verifyFormat("int i = a[a][a]->f();"); 9326 verifyFormat("int i = (*b)[a]->f();"); 9327 9328 // Other corner cases. 9329 verifyFormat("void f() {\n" 9330 " bar([]() {} // Did not respect SpacesBeforeTrailingComments\n" 9331 " );\n" 9332 "}"); 9333 9334 // Lambdas created through weird macros. 9335 verifyFormat("void f() {\n" 9336 " MACRO((const AA &a) { return 1; });\n" 9337 " MACRO((AA &a) { return 1; });\n" 9338 "}"); 9339 9340 verifyFormat("if (blah_blah(whatever, whatever, [] {\n" 9341 " doo_dah();\n" 9342 " doo_dah();\n" 9343 " })) {\n" 9344 "}"); 9345 verifyFormat("auto lambda = []() {\n" 9346 " int a = 2\n" 9347 "#if A\n" 9348 " + 2\n" 9349 "#endif\n" 9350 " ;\n" 9351 "};"); 9352 } 9353 9354 TEST_F(FormatTest, FormatsBlocks) { 9355 FormatStyle ShortBlocks = getLLVMStyle(); 9356 ShortBlocks.AllowShortBlocksOnASingleLine = true; 9357 verifyFormat("int (^Block)(int, int);", ShortBlocks); 9358 verifyFormat("int (^Block1)(int, int) = ^(int i, int j)", ShortBlocks); 9359 verifyFormat("void (^block)(int) = ^(id test) { int i; };", ShortBlocks); 9360 verifyFormat("void (^block)(int) = ^(int test) { int i; };", ShortBlocks); 9361 verifyFormat("void (^block)(int) = ^id(int test) { int i; };", ShortBlocks); 9362 verifyFormat("void (^block)(int) = ^int(int test) { int i; };", ShortBlocks); 9363 9364 verifyFormat("foo(^{ bar(); });", ShortBlocks); 9365 verifyFormat("foo(a, ^{ bar(); });", ShortBlocks); 9366 verifyFormat("{ void (^block)(Object *x); }", ShortBlocks); 9367 9368 verifyFormat("[operation setCompletionBlock:^{\n" 9369 " [self onOperationDone];\n" 9370 "}];"); 9371 verifyFormat("int i = {[operation setCompletionBlock:^{\n" 9372 " [self onOperationDone];\n" 9373 "}]};"); 9374 verifyFormat("[operation setCompletionBlock:^(int *i) {\n" 9375 " f();\n" 9376 "}];"); 9377 verifyFormat("int a = [operation block:^int(int *i) {\n" 9378 " return 1;\n" 9379 "}];"); 9380 verifyFormat("[myObject doSomethingWith:arg1\n" 9381 " aaa:^int(int *a) {\n" 9382 " return 1;\n" 9383 " }\n" 9384 " bbb:f(a * bbbbbbbb)];"); 9385 9386 verifyFormat("[operation setCompletionBlock:^{\n" 9387 " [self.delegate newDataAvailable];\n" 9388 "}];", 9389 getLLVMStyleWithColumns(60)); 9390 verifyFormat("dispatch_async(_fileIOQueue, ^{\n" 9391 " NSString *path = [self sessionFilePath];\n" 9392 " if (path) {\n" 9393 " // ...\n" 9394 " }\n" 9395 "});"); 9396 verifyFormat("[[SessionService sharedService]\n" 9397 " loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 9398 " if (window) {\n" 9399 " [self windowDidLoad:window];\n" 9400 " } else {\n" 9401 " [self errorLoadingWindow];\n" 9402 " }\n" 9403 " }];"); 9404 verifyFormat("void (^largeBlock)(void) = ^{\n" 9405 " // ...\n" 9406 "};\n", 9407 getLLVMStyleWithColumns(40)); 9408 verifyFormat("[[SessionService sharedService]\n" 9409 " loadWindowWithCompletionBlock: //\n" 9410 " ^(SessionWindow *window) {\n" 9411 " if (window) {\n" 9412 " [self windowDidLoad:window];\n" 9413 " } else {\n" 9414 " [self errorLoadingWindow];\n" 9415 " }\n" 9416 " }];", 9417 getLLVMStyleWithColumns(60)); 9418 verifyFormat("[myObject doSomethingWith:arg1\n" 9419 " firstBlock:^(Foo *a) {\n" 9420 " // ...\n" 9421 " int i;\n" 9422 " }\n" 9423 " secondBlock:^(Bar *b) {\n" 9424 " // ...\n" 9425 " int i;\n" 9426 " }\n" 9427 " thirdBlock:^Foo(Bar *b) {\n" 9428 " // ...\n" 9429 " int i;\n" 9430 " }];"); 9431 verifyFormat("[myObject doSomethingWith:arg1\n" 9432 " firstBlock:-1\n" 9433 " secondBlock:^(Bar *b) {\n" 9434 " // ...\n" 9435 " int i;\n" 9436 " }];"); 9437 9438 verifyFormat("f(^{\n" 9439 " @autoreleasepool {\n" 9440 " if (a) {\n" 9441 " g();\n" 9442 " }\n" 9443 " }\n" 9444 "});"); 9445 verifyFormat("Block b = ^int *(A *a, B *b) {}"); 9446 verifyFormat("BOOL (^aaa)(void) = ^BOOL {\n" 9447 "};"); 9448 9449 FormatStyle FourIndent = getLLVMStyle(); 9450 FourIndent.ObjCBlockIndentWidth = 4; 9451 verifyFormat("[operation setCompletionBlock:^{\n" 9452 " [self onOperationDone];\n" 9453 "}];", 9454 FourIndent); 9455 } 9456 9457 TEST_F(FormatTest, FormatsBlocksWithZeroColumnWidth) { 9458 FormatStyle ZeroColumn = getLLVMStyle(); 9459 ZeroColumn.ColumnLimit = 0; 9460 9461 verifyFormat("[[SessionService sharedService] " 9462 "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 9463 " if (window) {\n" 9464 " [self windowDidLoad:window];\n" 9465 " } else {\n" 9466 " [self errorLoadingWindow];\n" 9467 " }\n" 9468 "}];", 9469 ZeroColumn); 9470 EXPECT_EQ("[[SessionService sharedService]\n" 9471 " loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 9472 " if (window) {\n" 9473 " [self windowDidLoad:window];\n" 9474 " } else {\n" 9475 " [self errorLoadingWindow];\n" 9476 " }\n" 9477 " }];", 9478 format("[[SessionService sharedService]\n" 9479 "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 9480 " if (window) {\n" 9481 " [self windowDidLoad:window];\n" 9482 " } else {\n" 9483 " [self errorLoadingWindow];\n" 9484 " }\n" 9485 "}];", 9486 ZeroColumn)); 9487 verifyFormat("[myObject doSomethingWith:arg1\n" 9488 " firstBlock:^(Foo *a) {\n" 9489 " // ...\n" 9490 " int i;\n" 9491 " }\n" 9492 " secondBlock:^(Bar *b) {\n" 9493 " // ...\n" 9494 " int i;\n" 9495 " }\n" 9496 " thirdBlock:^Foo(Bar *b) {\n" 9497 " // ...\n" 9498 " int i;\n" 9499 " }];", 9500 ZeroColumn); 9501 verifyFormat("f(^{\n" 9502 " @autoreleasepool {\n" 9503 " if (a) {\n" 9504 " g();\n" 9505 " }\n" 9506 " }\n" 9507 "});", 9508 ZeroColumn); 9509 verifyFormat("void (^largeBlock)(void) = ^{\n" 9510 " // ...\n" 9511 "};", 9512 ZeroColumn); 9513 9514 ZeroColumn.AllowShortBlocksOnASingleLine = true; 9515 EXPECT_EQ("void (^largeBlock)(void) = ^{ int i; };", 9516 format("void (^largeBlock)(void) = ^{ int i; };", ZeroColumn)); 9517 ZeroColumn.AllowShortBlocksOnASingleLine = false; 9518 EXPECT_EQ("void (^largeBlock)(void) = ^{\n" 9519 " int i;\n" 9520 "};", 9521 format("void (^largeBlock)(void) = ^{ int i; };", ZeroColumn)); 9522 } 9523 9524 TEST_F(FormatTest, SupportsCRLF) { 9525 EXPECT_EQ("int a;\r\n" 9526 "int b;\r\n" 9527 "int c;\r\n", 9528 format("int a;\r\n" 9529 " int b;\r\n" 9530 " int c;\r\n", 9531 getLLVMStyle())); 9532 EXPECT_EQ("int a;\r\n" 9533 "int b;\r\n" 9534 "int c;\r\n", 9535 format("int a;\r\n" 9536 " int b;\n" 9537 " int c;\r\n", 9538 getLLVMStyle())); 9539 EXPECT_EQ("int a;\n" 9540 "int b;\n" 9541 "int c;\n", 9542 format("int a;\r\n" 9543 " int b;\n" 9544 " int c;\n", 9545 getLLVMStyle())); 9546 EXPECT_EQ("\"aaaaaaa \"\r\n" 9547 "\"bbbbbbb\";\r\n", 9548 format("\"aaaaaaa bbbbbbb\";\r\n", getLLVMStyleWithColumns(10))); 9549 EXPECT_EQ("#define A \\\r\n" 9550 " b; \\\r\n" 9551 " c; \\\r\n" 9552 " d;\r\n", 9553 format("#define A \\\r\n" 9554 " b; \\\r\n" 9555 " c; d; \r\n", 9556 getGoogleStyle())); 9557 9558 EXPECT_EQ("/*\r\n" 9559 "multi line block comments\r\n" 9560 "should not introduce\r\n" 9561 "an extra carriage return\r\n" 9562 "*/\r\n", 9563 format("/*\r\n" 9564 "multi line block comments\r\n" 9565 "should not introduce\r\n" 9566 "an extra carriage return\r\n" 9567 "*/\r\n")); 9568 } 9569 9570 TEST_F(FormatTest, MunchSemicolonAfterBlocks) { 9571 verifyFormat("MY_CLASS(C) {\n" 9572 " int i;\n" 9573 " int j;\n" 9574 "};"); 9575 } 9576 9577 TEST_F(FormatTest, ConfigurableContinuationIndentWidth) { 9578 FormatStyle TwoIndent = getLLVMStyleWithColumns(15); 9579 TwoIndent.ContinuationIndentWidth = 2; 9580 9581 EXPECT_EQ("int i =\n" 9582 " longFunction(\n" 9583 " arg);", 9584 format("int i = longFunction(arg);", TwoIndent)); 9585 9586 FormatStyle SixIndent = getLLVMStyleWithColumns(20); 9587 SixIndent.ContinuationIndentWidth = 6; 9588 9589 EXPECT_EQ("int i =\n" 9590 " longFunction(\n" 9591 " arg);", 9592 format("int i = longFunction(arg);", SixIndent)); 9593 } 9594 9595 TEST_F(FormatTest, SpacesInAngles) { 9596 FormatStyle Spaces = getLLVMStyle(); 9597 Spaces.SpacesInAngles = true; 9598 9599 verifyFormat("static_cast< int >(arg);", Spaces); 9600 verifyFormat("template < typename T0, typename T1 > void f() {}", Spaces); 9601 verifyFormat("f< int, float >();", Spaces); 9602 verifyFormat("template <> g() {}", Spaces); 9603 verifyFormat("template < std::vector< int > > f() {}", Spaces); 9604 verifyFormat("std::function< void(int, int) > fct;", Spaces); 9605 verifyFormat("void inFunction() { std::function< void(int, int) > fct; }", 9606 Spaces); 9607 9608 Spaces.Standard = FormatStyle::LS_Cpp03; 9609 Spaces.SpacesInAngles = true; 9610 verifyFormat("A< A< int > >();", Spaces); 9611 9612 Spaces.SpacesInAngles = false; 9613 verifyFormat("A<A<int> >();", Spaces); 9614 9615 Spaces.Standard = FormatStyle::LS_Cpp11; 9616 Spaces.SpacesInAngles = true; 9617 verifyFormat("A< A< int > >();", Spaces); 9618 9619 Spaces.SpacesInAngles = false; 9620 verifyFormat("A<A<int>>();", Spaces); 9621 } 9622 9623 TEST_F(FormatTest, SpaceAfterTemplateKeyword) { 9624 FormatStyle Style = getLLVMStyle(); 9625 Style.SpaceAfterTemplateKeyword = false; 9626 verifyFormat("template<int> void foo();", Style); 9627 } 9628 9629 TEST_F(FormatTest, TripleAngleBrackets) { 9630 verifyFormat("f<<<1, 1>>>();"); 9631 verifyFormat("f<<<1, 1, 1, s>>>();"); 9632 verifyFormat("f<<<a, b, c, d>>>();"); 9633 EXPECT_EQ("f<<<1, 1>>>();", format("f <<< 1, 1 >>> ();")); 9634 verifyFormat("f<param><<<1, 1>>>();"); 9635 verifyFormat("f<1><<<1, 1>>>();"); 9636 EXPECT_EQ("f<param><<<1, 1>>>();", format("f< param > <<< 1, 1 >>> ();")); 9637 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 9638 "aaaaaaaaaaa<<<\n 1, 1>>>();"); 9639 verifyFormat("aaaaaaaaaaaaaaa<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaa>\n" 9640 " <<<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaaaaaa>>>();"); 9641 } 9642 9643 TEST_F(FormatTest, MergeLessLessAtEnd) { 9644 verifyFormat("<<"); 9645 EXPECT_EQ("< < <", format("\\\n<<<")); 9646 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 9647 "aaallvm::outs() <<"); 9648 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 9649 "aaaallvm::outs()\n <<"); 9650 } 9651 9652 TEST_F(FormatTest, HandleUnbalancedImplicitBracesAcrossPPBranches) { 9653 std::string code = "#if A\n" 9654 "#if B\n" 9655 "a.\n" 9656 "#endif\n" 9657 " a = 1;\n" 9658 "#else\n" 9659 "#endif\n" 9660 "#if C\n" 9661 "#else\n" 9662 "#endif\n"; 9663 EXPECT_EQ(code, format(code)); 9664 } 9665 9666 TEST_F(FormatTest, HandleConflictMarkers) { 9667 // Git/SVN conflict markers. 9668 EXPECT_EQ("int a;\n" 9669 "void f() {\n" 9670 " callme(some(parameter1,\n" 9671 "<<<<<<< text by the vcs\n" 9672 " parameter2),\n" 9673 "||||||| text by the vcs\n" 9674 " parameter2),\n" 9675 " parameter3,\n" 9676 "======= text by the vcs\n" 9677 " parameter2, parameter3),\n" 9678 ">>>>>>> text by the vcs\n" 9679 " otherparameter);\n", 9680 format("int a;\n" 9681 "void f() {\n" 9682 " callme(some(parameter1,\n" 9683 "<<<<<<< text by the vcs\n" 9684 " parameter2),\n" 9685 "||||||| text by the vcs\n" 9686 " parameter2),\n" 9687 " parameter3,\n" 9688 "======= text by the vcs\n" 9689 " parameter2,\n" 9690 " parameter3),\n" 9691 ">>>>>>> text by the vcs\n" 9692 " otherparameter);\n")); 9693 9694 // Perforce markers. 9695 EXPECT_EQ("void f() {\n" 9696 " function(\n" 9697 ">>>> text by the vcs\n" 9698 " parameter,\n" 9699 "==== text by the vcs\n" 9700 " parameter,\n" 9701 "==== text by the vcs\n" 9702 " parameter,\n" 9703 "<<<< text by the vcs\n" 9704 " parameter);\n", 9705 format("void f() {\n" 9706 " function(\n" 9707 ">>>> text by the vcs\n" 9708 " parameter,\n" 9709 "==== text by the vcs\n" 9710 " parameter,\n" 9711 "==== text by the vcs\n" 9712 " parameter,\n" 9713 "<<<< text by the vcs\n" 9714 " parameter);\n")); 9715 9716 EXPECT_EQ("<<<<<<<\n" 9717 "|||||||\n" 9718 "=======\n" 9719 ">>>>>>>", 9720 format("<<<<<<<\n" 9721 "|||||||\n" 9722 "=======\n" 9723 ">>>>>>>")); 9724 9725 EXPECT_EQ("<<<<<<<\n" 9726 "|||||||\n" 9727 "int i;\n" 9728 "=======\n" 9729 ">>>>>>>", 9730 format("<<<<<<<\n" 9731 "|||||||\n" 9732 "int i;\n" 9733 "=======\n" 9734 ">>>>>>>")); 9735 9736 // FIXME: Handle parsing of macros around conflict markers correctly: 9737 EXPECT_EQ("#define Macro \\\n" 9738 "<<<<<<<\n" 9739 "Something \\\n" 9740 "|||||||\n" 9741 "Else \\\n" 9742 "=======\n" 9743 "Other \\\n" 9744 ">>>>>>>\n" 9745 " End int i;\n", 9746 format("#define Macro \\\n" 9747 "<<<<<<<\n" 9748 " Something \\\n" 9749 "|||||||\n" 9750 " Else \\\n" 9751 "=======\n" 9752 " Other \\\n" 9753 ">>>>>>>\n" 9754 " End\n" 9755 "int i;\n")); 9756 } 9757 9758 TEST_F(FormatTest, DisableRegions) { 9759 EXPECT_EQ("int i;\n" 9760 "// clang-format off\n" 9761 " int j;\n" 9762 "// clang-format on\n" 9763 "int k;", 9764 format(" int i;\n" 9765 " // clang-format off\n" 9766 " int j;\n" 9767 " // clang-format on\n" 9768 " int k;")); 9769 EXPECT_EQ("int i;\n" 9770 "/* clang-format off */\n" 9771 " int j;\n" 9772 "/* clang-format on */\n" 9773 "int k;", 9774 format(" int i;\n" 9775 " /* clang-format off */\n" 9776 " int j;\n" 9777 " /* clang-format on */\n" 9778 " int k;")); 9779 9780 // Don't reflow comments within disabled regions. 9781 EXPECT_EQ( 9782 "// clang-format off\n" 9783 "// long long long long long long line\n" 9784 "/* clang-format on */\n" 9785 "/* long long long\n" 9786 " * long long long\n" 9787 " * line */\n" 9788 "int i;\n" 9789 "/* clang-format off */\n" 9790 "/* long long long long long long line */\n", 9791 format("// clang-format off\n" 9792 "// long long long long long long line\n" 9793 "/* clang-format on */\n" 9794 "/* long long long long long long line */\n" 9795 "int i;\n" 9796 "/* clang-format off */\n" 9797 "/* long long long long long long line */\n", 9798 getLLVMStyleWithColumns(20))); 9799 } 9800 9801 TEST_F(FormatTest, DoNotCrashOnInvalidInput) { 9802 format("? ) ="); 9803 verifyNoCrash("#define a\\\n /**/}"); 9804 } 9805 9806 TEST_F(FormatTest, FormatsTableGenCode) { 9807 FormatStyle Style = getLLVMStyle(); 9808 Style.Language = FormatStyle::LK_TableGen; 9809 verifyFormat("include \"a.td\"\ninclude \"b.td\"", Style); 9810 } 9811 9812 TEST_F(FormatTest, ArrayOfTemplates) { 9813 EXPECT_EQ("auto a = new unique_ptr<int>[10];", 9814 format("auto a = new unique_ptr<int > [ 10];")); 9815 9816 FormatStyle Spaces = getLLVMStyle(); 9817 Spaces.SpacesInSquareBrackets = true; 9818 EXPECT_EQ("auto a = new unique_ptr<int>[ 10 ];", 9819 format("auto a = new unique_ptr<int > [10];", Spaces)); 9820 } 9821 9822 TEST_F(FormatTest, ArrayAsTemplateType) { 9823 EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[10]>;", 9824 format("auto a = unique_ptr < Foo < Bar>[ 10]> ;")); 9825 9826 FormatStyle Spaces = getLLVMStyle(); 9827 Spaces.SpacesInSquareBrackets = true; 9828 EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[ 10 ]>;", 9829 format("auto a = unique_ptr < Foo < Bar>[10]> ;", Spaces)); 9830 } 9831 9832 TEST(FormatStyle, GetStyleOfFile) { 9833 vfs::InMemoryFileSystem FS; 9834 // Test 1: format file in the same directory. 9835 ASSERT_TRUE( 9836 FS.addFile("/a/.clang-format", 0, 9837 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM"))); 9838 ASSERT_TRUE( 9839 FS.addFile("/a/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;"))); 9840 auto Style1 = getStyle("file", "/a/.clang-format", "Google", "", &FS); 9841 ASSERT_TRUE((bool)Style1); 9842 ASSERT_EQ(*Style1, getLLVMStyle()); 9843 9844 // Test 2.1: fallback to default. 9845 ASSERT_TRUE( 9846 FS.addFile("/b/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;"))); 9847 auto Style2 = getStyle("file", "/b/test.cpp", "Mozilla", "", &FS); 9848 ASSERT_TRUE((bool)Style2); 9849 ASSERT_EQ(*Style2, getMozillaStyle()); 9850 9851 // Test 2.2: no format on 'none' fallback style. 9852 Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS); 9853 ASSERT_TRUE((bool)Style2); 9854 ASSERT_EQ(*Style2, getNoStyle()); 9855 9856 // Test 2.3: format if config is found with no based style while fallback is 9857 // 'none'. 9858 ASSERT_TRUE(FS.addFile("/b/.clang-format", 0, 9859 llvm::MemoryBuffer::getMemBuffer("IndentWidth: 2"))); 9860 Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS); 9861 ASSERT_TRUE((bool)Style2); 9862 ASSERT_EQ(*Style2, getLLVMStyle()); 9863 9864 // Test 2.4: format if yaml with no based style, while fallback is 'none'. 9865 Style2 = getStyle("{}", "a.h", "none", "", &FS); 9866 ASSERT_TRUE((bool)Style2); 9867 ASSERT_EQ(*Style2, getLLVMStyle()); 9868 9869 // Test 3: format file in parent directory. 9870 ASSERT_TRUE( 9871 FS.addFile("/c/.clang-format", 0, 9872 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: Google"))); 9873 ASSERT_TRUE(FS.addFile("/c/sub/sub/sub/test.cpp", 0, 9874 llvm::MemoryBuffer::getMemBuffer("int i;"))); 9875 auto Style3 = getStyle("file", "/c/sub/sub/sub/test.cpp", "LLVM", "", &FS); 9876 ASSERT_TRUE((bool)Style3); 9877 ASSERT_EQ(*Style3, getGoogleStyle()); 9878 9879 // Test 4: error on invalid fallback style 9880 auto Style4 = getStyle("file", "a.h", "KungFu", "", &FS); 9881 ASSERT_FALSE((bool)Style4); 9882 llvm::consumeError(Style4.takeError()); 9883 9884 // Test 5: error on invalid yaml on command line 9885 auto Style5 = getStyle("{invalid_key=invalid_value}", "a.h", "LLVM", "", &FS); 9886 ASSERT_FALSE((bool)Style5); 9887 llvm::consumeError(Style5.takeError()); 9888 9889 // Test 6: error on invalid style 9890 auto Style6 = getStyle("KungFu", "a.h", "LLVM", "", &FS); 9891 ASSERT_FALSE((bool)Style6); 9892 llvm::consumeError(Style6.takeError()); 9893 9894 // Test 7: found config file, error on parsing it 9895 ASSERT_TRUE( 9896 FS.addFile("/d/.clang-format", 0, 9897 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM\n" 9898 "InvalidKey: InvalidValue"))); 9899 ASSERT_TRUE( 9900 FS.addFile("/d/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;"))); 9901 auto Style7 = getStyle("file", "/d/.clang-format", "LLVM", "", &FS); 9902 ASSERT_FALSE((bool)Style7); 9903 llvm::consumeError(Style7.takeError()); 9904 } 9905 9906 TEST_F(ReplacementTest, FormatCodeAfterReplacements) { 9907 // Column limit is 20. 9908 std::string Code = "Type *a =\n" 9909 " new Type();\n" 9910 "g(iiiii, 0, jjjjj,\n" 9911 " 0, kkkkk, 0, mm);\n" 9912 "int bad = format ;"; 9913 std::string Expected = "auto a = new Type();\n" 9914 "g(iiiii, nullptr,\n" 9915 " jjjjj, nullptr,\n" 9916 " kkkkk, nullptr,\n" 9917 " mm);\n" 9918 "int bad = format ;"; 9919 FileID ID = Context.createInMemoryFile("format.cpp", Code); 9920 tooling::Replacements Replaces = toReplacements( 9921 {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 6, 9922 "auto "), 9923 tooling::Replacement(Context.Sources, Context.getLocation(ID, 3, 10), 1, 9924 "nullptr"), 9925 tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 3), 1, 9926 "nullptr"), 9927 tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 13), 1, 9928 "nullptr")}); 9929 9930 format::FormatStyle Style = format::getLLVMStyle(); 9931 Style.ColumnLimit = 20; // Set column limit to 20 to increase readibility. 9932 auto FormattedReplaces = formatReplacements(Code, Replaces, Style); 9933 EXPECT_TRUE(static_cast<bool>(FormattedReplaces)) 9934 << llvm::toString(FormattedReplaces.takeError()) << "\n"; 9935 auto Result = applyAllReplacements(Code, *FormattedReplaces); 9936 EXPECT_TRUE(static_cast<bool>(Result)); 9937 EXPECT_EQ(Expected, *Result); 9938 } 9939 9940 TEST_F(ReplacementTest, SortIncludesAfterReplacement) { 9941 std::string Code = "#include \"a.h\"\n" 9942 "#include \"c.h\"\n" 9943 "\n" 9944 "int main() {\n" 9945 " return 0;\n" 9946 "}"; 9947 std::string Expected = "#include \"a.h\"\n" 9948 "#include \"b.h\"\n" 9949 "#include \"c.h\"\n" 9950 "\n" 9951 "int main() {\n" 9952 " return 0;\n" 9953 "}"; 9954 FileID ID = Context.createInMemoryFile("fix.cpp", Code); 9955 tooling::Replacements Replaces = toReplacements( 9956 {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 0, 9957 "#include \"b.h\"\n")}); 9958 9959 format::FormatStyle Style = format::getLLVMStyle(); 9960 Style.SortIncludes = true; 9961 auto FormattedReplaces = formatReplacements(Code, Replaces, Style); 9962 EXPECT_TRUE(static_cast<bool>(FormattedReplaces)) 9963 << llvm::toString(FormattedReplaces.takeError()) << "\n"; 9964 auto Result = applyAllReplacements(Code, *FormattedReplaces); 9965 EXPECT_TRUE(static_cast<bool>(Result)); 9966 EXPECT_EQ(Expected, *Result); 9967 } 9968 9969 } // end namespace 9970 } // end namespace format 9971 } // end namespace clang 9972