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