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 StatusCheck { 34 SC_ExpectComplete, 35 SC_ExpectIncomplete, 36 SC_DoNotCheck 37 }; 38 39 std::string format(llvm::StringRef Code, 40 const FormatStyle &Style = getLLVMStyle(), 41 StatusCheck CheckComplete = SC_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 FormattingAttemptStatus Status; 46 tooling::Replacements Replaces = 47 reformat(Style, Code, Ranges, "<stdin>", &Status); 48 if (CheckComplete != SC_DoNotCheck) { 49 bool ExpectedCompleteFormat = CheckComplete == SC_ExpectComplete; 50 EXPECT_EQ(ExpectedCompleteFormat, Status.FormatComplete) 51 << Code << "\n\n"; 52 } 53 ReplacementCount = Replaces.size(); 54 auto Result = applyAllReplacements(Code, Replaces); 55 EXPECT_TRUE(static_cast<bool>(Result)); 56 DEBUG(llvm::errs() << "\n" << *Result << "\n\n"); 57 return *Result; 58 } 59 60 FormatStyle getStyleWithColumns(FormatStyle Style, unsigned ColumnLimit) { 61 Style.ColumnLimit = ColumnLimit; 62 return Style; 63 } 64 65 FormatStyle getLLVMStyleWithColumns(unsigned ColumnLimit) { 66 return getStyleWithColumns(getLLVMStyle(), ColumnLimit); 67 } 68 69 FormatStyle getGoogleStyleWithColumns(unsigned ColumnLimit) { 70 return getStyleWithColumns(getGoogleStyle(), ColumnLimit); 71 } 72 73 void verifyFormat(llvm::StringRef Code, 74 const FormatStyle &Style = getLLVMStyle()) { 75 EXPECT_EQ(Code.str(), format(test::messUp(Code), Style)); 76 if (Style.Language == FormatStyle::LK_Cpp) { 77 // Objective-C++ is a superset of C++, so everything checked for C++ 78 // needs to be checked for Objective-C++ as well. 79 FormatStyle ObjCStyle = Style; 80 ObjCStyle.Language = FormatStyle::LK_ObjC; 81 EXPECT_EQ(Code.str(), format(test::messUp(Code), ObjCStyle)); 82 } 83 } 84 85 void verifyIncompleteFormat(llvm::StringRef Code, 86 const FormatStyle &Style = getLLVMStyle()) { 87 EXPECT_EQ(Code.str(), 88 format(test::messUp(Code), Style, SC_ExpectIncomplete)); 89 } 90 91 void verifyGoogleFormat(llvm::StringRef Code) { 92 verifyFormat(Code, getGoogleStyle()); 93 } 94 95 void verifyIndependentOfContext(llvm::StringRef text) { 96 verifyFormat(text); 97 verifyFormat(llvm::Twine("void f() { " + text + " }").str()); 98 } 99 100 /// \brief Verify that clang-format does not crash on the given input. 101 void verifyNoCrash(llvm::StringRef Code, 102 const FormatStyle &Style = getLLVMStyle()) { 103 format(Code, Style, SC_DoNotCheck); 104 } 105 106 int ReplacementCount; 107 }; 108 109 TEST_F(FormatTest, MessUp) { 110 EXPECT_EQ("1 2 3", test::messUp("1 2 3")); 111 EXPECT_EQ("1 2 3\n", test::messUp("1\n2\n3\n")); 112 EXPECT_EQ("a\n//b\nc", test::messUp("a\n//b\nc")); 113 EXPECT_EQ("a\n#b\nc", test::messUp("a\n#b\nc")); 114 EXPECT_EQ("a\n#b c d\ne", test::messUp("a\n#b\\\nc\\\nd\ne")); 115 } 116 117 //===----------------------------------------------------------------------===// 118 // Basic function tests. 119 //===----------------------------------------------------------------------===// 120 121 TEST_F(FormatTest, DoesNotChangeCorrectlyFormattedCode) { 122 EXPECT_EQ(";", format(";")); 123 } 124 125 TEST_F(FormatTest, FormatsGlobalStatementsAt0) { 126 EXPECT_EQ("int i;", format(" int i;")); 127 EXPECT_EQ("\nint i;", format(" \n\t \v \f int i;")); 128 EXPECT_EQ("int i;\nint j;", format(" int i; int j;")); 129 EXPECT_EQ("int i;\nint j;", format(" int i;\n int j;")); 130 } 131 132 TEST_F(FormatTest, FormatsUnwrappedLinesAtFirstFormat) { 133 EXPECT_EQ("int i;", format("int\ni;")); 134 } 135 136 TEST_F(FormatTest, FormatsNestedBlockStatements) { 137 EXPECT_EQ("{\n {\n {}\n }\n}", format("{{{}}}")); 138 } 139 140 TEST_F(FormatTest, FormatsNestedCall) { 141 verifyFormat("Method(f1, f2(f3));"); 142 verifyFormat("Method(f1(f2, f3()));"); 143 verifyFormat("Method(f1(f2, (f3())));"); 144 } 145 146 TEST_F(FormatTest, NestedNameSpecifiers) { 147 verifyFormat("vector<::Type> v;"); 148 verifyFormat("::ns::SomeFunction(::ns::SomeOtherFunction())"); 149 verifyFormat("static constexpr bool Bar = decltype(bar())::value;"); 150 verifyFormat("bool a = 2 < ::SomeFunction();"); 151 verifyFormat("ALWAYS_INLINE ::std::string getName();"); 152 verifyFormat("some::string getName();"); 153 } 154 155 TEST_F(FormatTest, OnlyGeneratesNecessaryReplacements) { 156 EXPECT_EQ("if (a) {\n" 157 " f();\n" 158 "}", 159 format("if(a){f();}")); 160 EXPECT_EQ(4, ReplacementCount); 161 EXPECT_EQ("if (a) {\n" 162 " f();\n" 163 "}", 164 format("if (a) {\n" 165 " f();\n" 166 "}")); 167 EXPECT_EQ(0, ReplacementCount); 168 EXPECT_EQ("/*\r\n" 169 "\r\n" 170 "*/\r\n", 171 format("/*\r\n" 172 "\r\n" 173 "*/\r\n")); 174 EXPECT_EQ(0, ReplacementCount); 175 } 176 177 TEST_F(FormatTest, RemovesEmptyLines) { 178 EXPECT_EQ("class C {\n" 179 " int i;\n" 180 "};", 181 format("class C {\n" 182 " int i;\n" 183 "\n" 184 "};")); 185 186 // Don't remove empty lines at the start of namespaces or extern "C" blocks. 187 EXPECT_EQ("namespace N {\n" 188 "\n" 189 "int i;\n" 190 "}", 191 format("namespace N {\n" 192 "\n" 193 "int i;\n" 194 "}", 195 getGoogleStyle())); 196 EXPECT_EQ("extern /**/ \"C\" /**/ {\n" 197 "\n" 198 "int i;\n" 199 "}", 200 format("extern /**/ \"C\" /**/ {\n" 201 "\n" 202 "int i;\n" 203 "}", 204 getGoogleStyle())); 205 206 // ...but do keep inlining and removing empty lines for non-block extern "C" 207 // functions. 208 verifyFormat("extern \"C\" int f() { return 42; }", getGoogleStyle()); 209 EXPECT_EQ("extern \"C\" int f() {\n" 210 " int i = 42;\n" 211 " return i;\n" 212 "}", 213 format("extern \"C\" int f() {\n" 214 "\n" 215 " int i = 42;\n" 216 " return i;\n" 217 "}", 218 getGoogleStyle())); 219 220 // Remove empty lines at the beginning and end of blocks. 221 EXPECT_EQ("void f() {\n" 222 "\n" 223 " if (a) {\n" 224 "\n" 225 " f();\n" 226 " }\n" 227 "}", 228 format("void f() {\n" 229 "\n" 230 " if (a) {\n" 231 "\n" 232 " f();\n" 233 "\n" 234 " }\n" 235 "\n" 236 "}", 237 getLLVMStyle())); 238 EXPECT_EQ("void f() {\n" 239 " if (a) {\n" 240 " f();\n" 241 " }\n" 242 "}", 243 format("void f() {\n" 244 "\n" 245 " if (a) {\n" 246 "\n" 247 " f();\n" 248 "\n" 249 " }\n" 250 "\n" 251 "}", 252 getGoogleStyle())); 253 254 // Don't remove empty lines in more complex control statements. 255 EXPECT_EQ("void f() {\n" 256 " if (a) {\n" 257 " f();\n" 258 "\n" 259 " } else if (b) {\n" 260 " f();\n" 261 " }\n" 262 "}", 263 format("void f() {\n" 264 " if (a) {\n" 265 " f();\n" 266 "\n" 267 " } else if (b) {\n" 268 " f();\n" 269 "\n" 270 " }\n" 271 "\n" 272 "}")); 273 274 // FIXME: This is slightly inconsistent. 275 FormatStyle LLVMWithNoNamespaceFix = getLLVMStyle(); 276 LLVMWithNoNamespaceFix.FixNamespaceComments = false; 277 EXPECT_EQ("namespace {\n" 278 "int i;\n" 279 "}", 280 format("namespace {\n" 281 "int i;\n" 282 "\n" 283 "}", LLVMWithNoNamespaceFix)); 284 EXPECT_EQ("namespace {\n" 285 "int i;\n" 286 "}", 287 format("namespace {\n" 288 "int i;\n" 289 "\n" 290 "}")); 291 EXPECT_EQ("namespace {\n" 292 "int i;\n" 293 "\n" 294 "} // namespace", 295 format("namespace {\n" 296 "int i;\n" 297 "\n" 298 "} // namespace")); 299 300 FormatStyle Style = getLLVMStyle(); 301 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 302 Style.MaxEmptyLinesToKeep = 2; 303 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 304 Style.BraceWrapping.AfterClass = true; 305 Style.BraceWrapping.AfterFunction = true; 306 Style.KeepEmptyLinesAtTheStartOfBlocks = false; 307 308 EXPECT_EQ("class Foo\n" 309 "{\n" 310 " Foo() {}\n" 311 "\n" 312 " void funk() {}\n" 313 "};", 314 format("class Foo\n" 315 "{\n" 316 " Foo()\n" 317 " {\n" 318 " }\n" 319 "\n" 320 " void funk() {}\n" 321 "};", 322 Style)); 323 } 324 325 TEST_F(FormatTest, RecognizesBinaryOperatorKeywords) { 326 verifyFormat("x = (a) and (b);"); 327 verifyFormat("x = (a) or (b);"); 328 verifyFormat("x = (a) bitand (b);"); 329 verifyFormat("x = (a) bitor (b);"); 330 verifyFormat("x = (a) not_eq (b);"); 331 verifyFormat("x = (a) and_eq (b);"); 332 verifyFormat("x = (a) or_eq (b);"); 333 verifyFormat("x = (a) xor (b);"); 334 } 335 336 TEST_F(FormatTest, RecognizesUnaryOperatorKeywords) { 337 verifyFormat("x = compl(a);"); 338 verifyFormat("x = not(a);"); 339 verifyFormat("x = bitand(a);"); 340 // Unary operator must not be merged with the next identifier 341 verifyFormat("x = compl a;"); 342 verifyFormat("x = not a;"); 343 verifyFormat("x = bitand a;"); 344 } 345 346 //===----------------------------------------------------------------------===// 347 // Tests for control statements. 348 //===----------------------------------------------------------------------===// 349 350 TEST_F(FormatTest, FormatIfWithoutCompoundStatement) { 351 verifyFormat("if (true)\n f();\ng();"); 352 verifyFormat("if (a)\n if (b)\n if (c)\n g();\nh();"); 353 verifyFormat("if (a)\n if (b) {\n f();\n }\ng();"); 354 verifyFormat("if constexpr (true)\n" 355 " f();\ng();"); 356 verifyFormat("if constexpr (a)\n" 357 " if constexpr (b)\n" 358 " if constexpr (c)\n" 359 " g();\n" 360 "h();"); 361 verifyFormat("if constexpr (a)\n" 362 " if constexpr (b) {\n" 363 " f();\n" 364 " }\n" 365 "g();"); 366 367 FormatStyle AllowsMergedIf = getLLVMStyle(); 368 AllowsMergedIf.AlignEscapedNewlines = FormatStyle::ENAS_Left; 369 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = true; 370 verifyFormat("if (a)\n" 371 " // comment\n" 372 " f();", 373 AllowsMergedIf); 374 verifyFormat("{\n" 375 " if (a)\n" 376 " label:\n" 377 " f();\n" 378 "}", 379 AllowsMergedIf); 380 verifyFormat("#define A \\\n" 381 " if (a) \\\n" 382 " label: \\\n" 383 " f()", 384 AllowsMergedIf); 385 verifyFormat("if (a)\n" 386 " ;", 387 AllowsMergedIf); 388 verifyFormat("if (a)\n" 389 " if (b) return;", 390 AllowsMergedIf); 391 392 verifyFormat("if (a) // Can't merge this\n" 393 " f();\n", 394 AllowsMergedIf); 395 verifyFormat("if (a) /* still don't merge */\n" 396 " f();", 397 AllowsMergedIf); 398 verifyFormat("if (a) { // Never merge this\n" 399 " f();\n" 400 "}", 401 AllowsMergedIf); 402 verifyFormat("if (a) { /* Never merge this */\n" 403 " f();\n" 404 "}", 405 AllowsMergedIf); 406 407 AllowsMergedIf.ColumnLimit = 14; 408 verifyFormat("if (a) return;", AllowsMergedIf); 409 verifyFormat("if (aaaaaaaaa)\n" 410 " return;", 411 AllowsMergedIf); 412 413 AllowsMergedIf.ColumnLimit = 13; 414 verifyFormat("if (a)\n return;", AllowsMergedIf); 415 } 416 417 TEST_F(FormatTest, FormatLoopsWithoutCompoundStatement) { 418 FormatStyle AllowsMergedLoops = getLLVMStyle(); 419 AllowsMergedLoops.AllowShortLoopsOnASingleLine = true; 420 verifyFormat("while (true) continue;", AllowsMergedLoops); 421 verifyFormat("for (;;) continue;", AllowsMergedLoops); 422 verifyFormat("for (int &v : vec) v *= 2;", AllowsMergedLoops); 423 verifyFormat("while (true)\n" 424 " ;", 425 AllowsMergedLoops); 426 verifyFormat("for (;;)\n" 427 " ;", 428 AllowsMergedLoops); 429 verifyFormat("for (;;)\n" 430 " for (;;) continue;", 431 AllowsMergedLoops); 432 verifyFormat("for (;;) // Can't merge this\n" 433 " continue;", 434 AllowsMergedLoops); 435 verifyFormat("for (;;) /* still don't merge */\n" 436 " continue;", 437 AllowsMergedLoops); 438 } 439 440 TEST_F(FormatTest, FormatShortBracedStatements) { 441 FormatStyle AllowSimpleBracedStatements = getLLVMStyle(); 442 AllowSimpleBracedStatements.ColumnLimit = 40; 443 AllowSimpleBracedStatements.AllowShortBlocksOnASingleLine = true; 444 445 AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = true; 446 AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = true; 447 448 AllowSimpleBracedStatements.BreakBeforeBraces = FormatStyle::BS_Custom; 449 AllowSimpleBracedStatements.BraceWrapping.AfterFunction = true; 450 AllowSimpleBracedStatements.BraceWrapping.SplitEmptyRecord = false; 451 452 verifyFormat("if (true) {}", AllowSimpleBracedStatements); 453 verifyFormat("if constexpr (true) {}", AllowSimpleBracedStatements); 454 verifyFormat("while (true) {}", AllowSimpleBracedStatements); 455 verifyFormat("for (;;) {}", AllowSimpleBracedStatements); 456 verifyFormat("if (true) { f(); }", AllowSimpleBracedStatements); 457 verifyFormat("if constexpr (true) { f(); }", AllowSimpleBracedStatements); 458 verifyFormat("while (true) { f(); }", AllowSimpleBracedStatements); 459 verifyFormat("for (;;) { f(); }", AllowSimpleBracedStatements); 460 verifyFormat("if (true) {\n" 461 " ffffffffffffffffffffffffffffffffffffffffffffffffffffff();\n" 462 "}", 463 AllowSimpleBracedStatements); 464 verifyFormat("if (true) { //\n" 465 " f();\n" 466 "}", 467 AllowSimpleBracedStatements); 468 verifyFormat("if (true) {\n" 469 " f();\n" 470 " f();\n" 471 "}", 472 AllowSimpleBracedStatements); 473 verifyFormat("if (true) {\n" 474 " f();\n" 475 "} else {\n" 476 " f();\n" 477 "}", 478 AllowSimpleBracedStatements); 479 480 verifyFormat("struct A2 {\n" 481 " int X;\n" 482 "};", 483 AllowSimpleBracedStatements); 484 verifyFormat("typedef struct A2 {\n" 485 " int X;\n" 486 "} A2_t;", 487 AllowSimpleBracedStatements); 488 verifyFormat("template <int> struct A2 {\n" 489 " struct B {};\n" 490 "};", 491 AllowSimpleBracedStatements); 492 493 AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = false; 494 verifyFormat("if (true) {}", AllowSimpleBracedStatements); 495 verifyFormat("if (true) {\n" 496 " f();\n" 497 "}", 498 AllowSimpleBracedStatements); 499 verifyFormat("if (true) {\n" 500 " f();\n" 501 "} else {\n" 502 " f();\n" 503 "}", 504 AllowSimpleBracedStatements); 505 506 AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = false; 507 verifyFormat("while (true) {}", AllowSimpleBracedStatements); 508 verifyFormat("while (true) {\n" 509 " f();\n" 510 "}", 511 AllowSimpleBracedStatements); 512 verifyFormat("for (;;) {}", AllowSimpleBracedStatements); 513 verifyFormat("for (;;) {\n" 514 " f();\n" 515 "}", 516 AllowSimpleBracedStatements); 517 518 AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = true; 519 AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = true; 520 AllowSimpleBracedStatements.BraceWrapping.AfterControlStatement = true; 521 522 verifyFormat("if (true) {}", AllowSimpleBracedStatements); 523 verifyFormat("if constexpr (true) {}", AllowSimpleBracedStatements); 524 verifyFormat("while (true) {}", AllowSimpleBracedStatements); 525 verifyFormat("for (;;) {}", AllowSimpleBracedStatements); 526 verifyFormat("if (true) { f(); }", AllowSimpleBracedStatements); 527 verifyFormat("if constexpr (true) { f(); }", AllowSimpleBracedStatements); 528 verifyFormat("while (true) { f(); }", AllowSimpleBracedStatements); 529 verifyFormat("for (;;) { f(); }", AllowSimpleBracedStatements); 530 verifyFormat("if (true)\n" 531 "{\n" 532 " ffffffffffffffffffffffffffffffffffffffffffffffffffffff();\n" 533 "}", 534 AllowSimpleBracedStatements); 535 verifyFormat("if (true)\n" 536 "{ //\n" 537 " f();\n" 538 "}", 539 AllowSimpleBracedStatements); 540 verifyFormat("if (true)\n" 541 "{\n" 542 " f();\n" 543 " f();\n" 544 "}", 545 AllowSimpleBracedStatements); 546 verifyFormat("if (true)\n" 547 "{\n" 548 " f();\n" 549 "} else\n" 550 "{\n" 551 " f();\n" 552 "}", 553 AllowSimpleBracedStatements); 554 555 AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = false; 556 verifyFormat("if (true) {}", AllowSimpleBracedStatements); 557 verifyFormat("if (true)\n" 558 "{\n" 559 " f();\n" 560 "}", 561 AllowSimpleBracedStatements); 562 verifyFormat("if (true)\n" 563 "{\n" 564 " f();\n" 565 "} else\n" 566 "{\n" 567 " f();\n" 568 "}", 569 AllowSimpleBracedStatements); 570 571 AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = false; 572 verifyFormat("while (true) {}", AllowSimpleBracedStatements); 573 verifyFormat("while (true)\n" 574 "{\n" 575 " f();\n" 576 "}", 577 AllowSimpleBracedStatements); 578 verifyFormat("for (;;) {}", AllowSimpleBracedStatements); 579 verifyFormat("for (;;)\n" 580 "{\n" 581 " f();\n" 582 "}", 583 AllowSimpleBracedStatements); 584 } 585 586 TEST_F(FormatTest, ParseIfElse) { 587 verifyFormat("if (true)\n" 588 " if (true)\n" 589 " if (true)\n" 590 " f();\n" 591 " else\n" 592 " g();\n" 593 " else\n" 594 " h();\n" 595 "else\n" 596 " i();"); 597 verifyFormat("if (true)\n" 598 " if (true)\n" 599 " if (true) {\n" 600 " if (true)\n" 601 " f();\n" 602 " } else {\n" 603 " g();\n" 604 " }\n" 605 " else\n" 606 " h();\n" 607 "else {\n" 608 " i();\n" 609 "}"); 610 verifyFormat("if (true)\n" 611 " if constexpr (true)\n" 612 " if (true) {\n" 613 " if constexpr (true)\n" 614 " f();\n" 615 " } else {\n" 616 " g();\n" 617 " }\n" 618 " else\n" 619 " h();\n" 620 "else {\n" 621 " i();\n" 622 "}"); 623 verifyFormat("void f() {\n" 624 " if (a) {\n" 625 " } else {\n" 626 " }\n" 627 "}"); 628 } 629 630 TEST_F(FormatTest, ElseIf) { 631 verifyFormat("if (a) {\n} else if (b) {\n}"); 632 verifyFormat("if (a)\n" 633 " f();\n" 634 "else if (b)\n" 635 " g();\n" 636 "else\n" 637 " h();"); 638 verifyFormat("if constexpr (a)\n" 639 " f();\n" 640 "else if constexpr (b)\n" 641 " g();\n" 642 "else\n" 643 " h();"); 644 verifyFormat("if (a) {\n" 645 " f();\n" 646 "}\n" 647 "// or else ..\n" 648 "else {\n" 649 " g()\n" 650 "}"); 651 652 verifyFormat("if (a) {\n" 653 "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 654 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n" 655 "}"); 656 verifyFormat("if (a) {\n" 657 "} else if (\n" 658 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 659 "}", 660 getLLVMStyleWithColumns(62)); 661 verifyFormat("if (a) {\n" 662 "} else if constexpr (\n" 663 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 664 "}", 665 getLLVMStyleWithColumns(62)); 666 } 667 668 TEST_F(FormatTest, FormatsForLoop) { 669 verifyFormat( 670 "for (int VeryVeryLongLoopVariable = 0; VeryVeryLongLoopVariable < 10;\n" 671 " ++VeryVeryLongLoopVariable)\n" 672 " ;"); 673 verifyFormat("for (;;)\n" 674 " f();"); 675 verifyFormat("for (;;) {\n}"); 676 verifyFormat("for (;;) {\n" 677 " f();\n" 678 "}"); 679 verifyFormat("for (int i = 0; (i < 10); ++i) {\n}"); 680 681 verifyFormat( 682 "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n" 683 " E = UnwrappedLines.end();\n" 684 " I != E; ++I) {\n}"); 685 686 verifyFormat( 687 "for (MachineFun::iterator IIII = PrevIt, EEEE = F.end(); IIII != EEEE;\n" 688 " ++IIIII) {\n}"); 689 verifyFormat("for (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaa =\n" 690 " aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa;\n" 691 " aaaaaaaaaaa != aaaaaaaaaaaaaaaaaaa; ++aaaaaaaaaaa) {\n}"); 692 verifyFormat("for (llvm::ArrayRef<NamedDecl *>::iterator\n" 693 " I = FD->getDeclsInPrototypeScope().begin(),\n" 694 " E = FD->getDeclsInPrototypeScope().end();\n" 695 " I != E; ++I) {\n}"); 696 verifyFormat("for (SmallVectorImpl<TemplateIdAnnotationn *>::iterator\n" 697 " I = Container.begin(),\n" 698 " E = Container.end();\n" 699 " I != E; ++I) {\n}", 700 getLLVMStyleWithColumns(76)); 701 702 verifyFormat( 703 "for (aaaaaaaaaaaaaaaaa aaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n" 704 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa !=\n" 705 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 706 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 707 " ++aaaaaaaaaaa) {\n}"); 708 verifyFormat("for (int i = 0; i < aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 709 " bbbbbbbbbbbbbbbbbbbb < ccccccccccccccc;\n" 710 " ++i) {\n}"); 711 verifyFormat("for (int aaaaaaaaaaa = 1; aaaaaaaaaaa <= bbbbbbbbbbbbbbb;\n" 712 " aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n" 713 "}"); 714 verifyFormat("for (some_namespace::SomeIterator iter( // force break\n" 715 " aaaaaaaaaa);\n" 716 " iter; ++iter) {\n" 717 "}"); 718 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 719 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 720 " aaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbbbbbbb;\n" 721 " ++aaaaaaaaaaaaaaaaaaaaaaaaaaa) {"); 722 723 FormatStyle NoBinPacking = getLLVMStyle(); 724 NoBinPacking.BinPackParameters = false; 725 verifyFormat("for (int aaaaaaaaaaa = 1;\n" 726 " aaaaaaaaaaa <= aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa,\n" 727 " aaaaaaaaaaaaaaaa,\n" 728 " aaaaaaaaaaaaaaaa,\n" 729 " aaaaaaaaaaaaaaaa);\n" 730 " aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n" 731 "}", 732 NoBinPacking); 733 verifyFormat( 734 "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n" 735 " E = UnwrappedLines.end();\n" 736 " I != E;\n" 737 " ++I) {\n}", 738 NoBinPacking); 739 740 FormatStyle AlignLeft = getLLVMStyle(); 741 AlignLeft.PointerAlignment = FormatStyle::PAS_Left; 742 verifyFormat("for (A* a = start; a < end; ++a, ++value) {\n}", AlignLeft); 743 } 744 745 TEST_F(FormatTest, RangeBasedForLoops) { 746 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 747 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 748 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaa :\n" 749 " aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa, aaaaaaaaaaaaa)) {\n}"); 750 verifyFormat("for (const aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaa :\n" 751 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 752 verifyFormat("for (aaaaaaaaa aaaaaaaaaaaaaaaaaaaaa :\n" 753 " aaaaaaaaaaaa.aaaaaaaaaaaa().aaaaaaaaa().a()) {\n}"); 754 } 755 756 TEST_F(FormatTest, ForEachLoops) { 757 verifyFormat("void f() {\n" 758 " foreach (Item *item, itemlist) {}\n" 759 " Q_FOREACH (Item *item, itemlist) {}\n" 760 " BOOST_FOREACH (Item *item, itemlist) {}\n" 761 " UNKNOWN_FORACH(Item * item, itemlist) {}\n" 762 "}"); 763 764 // As function-like macros. 765 verifyFormat("#define foreach(x, y)\n" 766 "#define Q_FOREACH(x, y)\n" 767 "#define BOOST_FOREACH(x, y)\n" 768 "#define UNKNOWN_FOREACH(x, y)\n"); 769 770 // Not as function-like macros. 771 verifyFormat("#define foreach (x, y)\n" 772 "#define Q_FOREACH (x, y)\n" 773 "#define BOOST_FOREACH (x, y)\n" 774 "#define UNKNOWN_FOREACH (x, y)\n"); 775 } 776 777 TEST_F(FormatTest, FormatsWhileLoop) { 778 verifyFormat("while (true) {\n}"); 779 verifyFormat("while (true)\n" 780 " f();"); 781 verifyFormat("while () {\n}"); 782 verifyFormat("while () {\n" 783 " f();\n" 784 "}"); 785 } 786 787 TEST_F(FormatTest, FormatsDoWhile) { 788 verifyFormat("do {\n" 789 " do_something();\n" 790 "} while (something());"); 791 verifyFormat("do\n" 792 " do_something();\n" 793 "while (something());"); 794 } 795 796 TEST_F(FormatTest, FormatsSwitchStatement) { 797 verifyFormat("switch (x) {\n" 798 "case 1:\n" 799 " f();\n" 800 " break;\n" 801 "case kFoo:\n" 802 "case ns::kBar:\n" 803 "case kBaz:\n" 804 " break;\n" 805 "default:\n" 806 " g();\n" 807 " break;\n" 808 "}"); 809 verifyFormat("switch (x) {\n" 810 "case 1: {\n" 811 " f();\n" 812 " break;\n" 813 "}\n" 814 "case 2: {\n" 815 " break;\n" 816 "}\n" 817 "}"); 818 verifyFormat("switch (x) {\n" 819 "case 1: {\n" 820 " f();\n" 821 " {\n" 822 " g();\n" 823 " h();\n" 824 " }\n" 825 " break;\n" 826 "}\n" 827 "}"); 828 verifyFormat("switch (x) {\n" 829 "case 1: {\n" 830 " f();\n" 831 " if (foo) {\n" 832 " g();\n" 833 " h();\n" 834 " }\n" 835 " break;\n" 836 "}\n" 837 "}"); 838 verifyFormat("switch (x) {\n" 839 "case 1: {\n" 840 " f();\n" 841 " g();\n" 842 "} break;\n" 843 "}"); 844 verifyFormat("switch (test)\n" 845 " ;"); 846 verifyFormat("switch (x) {\n" 847 "default: {\n" 848 " // Do nothing.\n" 849 "}\n" 850 "}"); 851 verifyFormat("switch (x) {\n" 852 "// comment\n" 853 "// if 1, do f()\n" 854 "case 1:\n" 855 " f();\n" 856 "}"); 857 verifyFormat("switch (x) {\n" 858 "case 1:\n" 859 " // Do amazing stuff\n" 860 " {\n" 861 " f();\n" 862 " g();\n" 863 " }\n" 864 " break;\n" 865 "}"); 866 verifyFormat("#define A \\\n" 867 " switch (x) { \\\n" 868 " case a: \\\n" 869 " foo = b; \\\n" 870 " }", 871 getLLVMStyleWithColumns(20)); 872 verifyFormat("#define OPERATION_CASE(name) \\\n" 873 " case OP_name: \\\n" 874 " return operations::Operation##name\n", 875 getLLVMStyleWithColumns(40)); 876 verifyFormat("switch (x) {\n" 877 "case 1:;\n" 878 "default:;\n" 879 " int i;\n" 880 "}"); 881 882 verifyGoogleFormat("switch (x) {\n" 883 " case 1:\n" 884 " f();\n" 885 " break;\n" 886 " case kFoo:\n" 887 " case ns::kBar:\n" 888 " case kBaz:\n" 889 " break;\n" 890 " default:\n" 891 " g();\n" 892 " break;\n" 893 "}"); 894 verifyGoogleFormat("switch (x) {\n" 895 " case 1: {\n" 896 " f();\n" 897 " break;\n" 898 " }\n" 899 "}"); 900 verifyGoogleFormat("switch (test)\n" 901 " ;"); 902 903 verifyGoogleFormat("#define OPERATION_CASE(name) \\\n" 904 " case OP_name: \\\n" 905 " return operations::Operation##name\n"); 906 verifyGoogleFormat("Operation codeToOperation(OperationCode OpCode) {\n" 907 " // Get the correction operation class.\n" 908 " switch (OpCode) {\n" 909 " CASE(Add);\n" 910 " CASE(Subtract);\n" 911 " default:\n" 912 " return operations::Unknown;\n" 913 " }\n" 914 "#undef OPERATION_CASE\n" 915 "}"); 916 verifyFormat("DEBUG({\n" 917 " switch (x) {\n" 918 " case A:\n" 919 " f();\n" 920 " break;\n" 921 " // fallthrough\n" 922 " case B:\n" 923 " g();\n" 924 " break;\n" 925 " }\n" 926 "});"); 927 EXPECT_EQ("DEBUG({\n" 928 " switch (x) {\n" 929 " case A:\n" 930 " f();\n" 931 " break;\n" 932 " // On B:\n" 933 " case B:\n" 934 " g();\n" 935 " break;\n" 936 " }\n" 937 "});", 938 format("DEBUG({\n" 939 " switch (x) {\n" 940 " case A:\n" 941 " f();\n" 942 " break;\n" 943 " // On B:\n" 944 " case B:\n" 945 " g();\n" 946 " break;\n" 947 " }\n" 948 "});", 949 getLLVMStyle())); 950 verifyFormat("switch (a) {\n" 951 "case (b):\n" 952 " return;\n" 953 "}"); 954 955 verifyFormat("switch (a) {\n" 956 "case some_namespace::\n" 957 " some_constant:\n" 958 " return;\n" 959 "}", 960 getLLVMStyleWithColumns(34)); 961 } 962 963 TEST_F(FormatTest, CaseRanges) { 964 verifyFormat("switch (x) {\n" 965 "case 'A' ... 'Z':\n" 966 "case 1 ... 5:\n" 967 "case a ... b:\n" 968 " break;\n" 969 "}"); 970 } 971 972 TEST_F(FormatTest, ShortCaseLabels) { 973 FormatStyle Style = getLLVMStyle(); 974 Style.AllowShortCaseLabelsOnASingleLine = true; 975 verifyFormat("switch (a) {\n" 976 "case 1: x = 1; break;\n" 977 "case 2: return;\n" 978 "case 3:\n" 979 "case 4:\n" 980 "case 5: return;\n" 981 "case 6: // comment\n" 982 " return;\n" 983 "case 7:\n" 984 " // comment\n" 985 " return;\n" 986 "case 8:\n" 987 " x = 8; // comment\n" 988 " break;\n" 989 "default: y = 1; break;\n" 990 "}", 991 Style); 992 verifyFormat("switch (a) {\n" 993 "case 0: return; // comment\n" 994 "case 1: break; // comment\n" 995 "case 2: return;\n" 996 "// comment\n" 997 "case 3: return;\n" 998 "// comment 1\n" 999 "// comment 2\n" 1000 "// comment 3\n" 1001 "case 4: break; /* comment */\n" 1002 "case 5:\n" 1003 " // comment\n" 1004 " break;\n" 1005 "case 6: /* comment */ x = 1; break;\n" 1006 "case 7: x = /* comment */ 1; break;\n" 1007 "case 8:\n" 1008 " x = 1; /* comment */\n" 1009 " break;\n" 1010 "case 9:\n" 1011 " break; // comment line 1\n" 1012 " // comment line 2\n" 1013 "}", 1014 Style); 1015 EXPECT_EQ("switch (a) {\n" 1016 "case 1:\n" 1017 " x = 8;\n" 1018 " // fall through\n" 1019 "case 2: x = 8;\n" 1020 "// comment\n" 1021 "case 3:\n" 1022 " return; /* comment line 1\n" 1023 " * comment line 2 */\n" 1024 "case 4: i = 8;\n" 1025 "// something else\n" 1026 "#if FOO\n" 1027 "case 5: break;\n" 1028 "#endif\n" 1029 "}", 1030 format("switch (a) {\n" 1031 "case 1: x = 8;\n" 1032 " // fall through\n" 1033 "case 2:\n" 1034 " x = 8;\n" 1035 "// comment\n" 1036 "case 3:\n" 1037 " return; /* comment line 1\n" 1038 " * comment line 2 */\n" 1039 "case 4:\n" 1040 " i = 8;\n" 1041 "// something else\n" 1042 "#if FOO\n" 1043 "case 5: break;\n" 1044 "#endif\n" 1045 "}", 1046 Style)); 1047 EXPECT_EQ("switch (a) {\n" "case 0:\n" 1048 " return; // long long long long long long long long long long long long comment\n" 1049 " // line\n" "}", 1050 format("switch (a) {\n" 1051 "case 0: return; // long long long long long long long long long long long long comment line\n" 1052 "}", 1053 Style)); 1054 EXPECT_EQ("switch (a) {\n" 1055 "case 0:\n" 1056 " return; /* long long long long long long long long long long long long comment\n" 1057 " line */\n" 1058 "}", 1059 format("switch (a) {\n" 1060 "case 0: return; /* long long long long long long long long long long long long comment line */\n" 1061 "}", 1062 Style)); 1063 verifyFormat("switch (a) {\n" 1064 "#if FOO\n" 1065 "case 0: return 0;\n" 1066 "#endif\n" 1067 "}", 1068 Style); 1069 verifyFormat("switch (a) {\n" 1070 "case 1: {\n" 1071 "}\n" 1072 "case 2: {\n" 1073 " return;\n" 1074 "}\n" 1075 "case 3: {\n" 1076 " x = 1;\n" 1077 " return;\n" 1078 "}\n" 1079 "case 4:\n" 1080 " if (x)\n" 1081 " return;\n" 1082 "}", 1083 Style); 1084 Style.ColumnLimit = 21; 1085 verifyFormat("switch (a) {\n" 1086 "case 1: x = 1; break;\n" 1087 "case 2: return;\n" 1088 "case 3:\n" 1089 "case 4:\n" 1090 "case 5: return;\n" 1091 "default:\n" 1092 " y = 1;\n" 1093 " break;\n" 1094 "}", 1095 Style); 1096 } 1097 1098 TEST_F(FormatTest, FormatsLabels) { 1099 verifyFormat("void f() {\n" 1100 " some_code();\n" 1101 "test_label:\n" 1102 " some_other_code();\n" 1103 " {\n" 1104 " some_more_code();\n" 1105 " another_label:\n" 1106 " some_more_code();\n" 1107 " }\n" 1108 "}"); 1109 verifyFormat("{\n" 1110 " some_code();\n" 1111 "test_label:\n" 1112 " some_other_code();\n" 1113 "}"); 1114 verifyFormat("{\n" 1115 " some_code();\n" 1116 "test_label:;\n" 1117 " int i = 0;\n" 1118 "}"); 1119 } 1120 1121 //===----------------------------------------------------------------------===// 1122 // Tests for classes, namespaces, etc. 1123 //===----------------------------------------------------------------------===// 1124 1125 TEST_F(FormatTest, DoesNotBreakSemiAfterClassDecl) { 1126 verifyFormat("class A {};"); 1127 } 1128 1129 TEST_F(FormatTest, UnderstandsAccessSpecifiers) { 1130 verifyFormat("class A {\n" 1131 "public:\n" 1132 "public: // comment\n" 1133 "protected:\n" 1134 "private:\n" 1135 " void f() {}\n" 1136 "};"); 1137 verifyGoogleFormat("class A {\n" 1138 " public:\n" 1139 " protected:\n" 1140 " private:\n" 1141 " void f() {}\n" 1142 "};"); 1143 verifyFormat("class A {\n" 1144 "public slots:\n" 1145 " void f1() {}\n" 1146 "public Q_SLOTS:\n" 1147 " void f2() {}\n" 1148 "protected slots:\n" 1149 " void f3() {}\n" 1150 "protected Q_SLOTS:\n" 1151 " void f4() {}\n" 1152 "private slots:\n" 1153 " void f5() {}\n" 1154 "private Q_SLOTS:\n" 1155 " void f6() {}\n" 1156 "signals:\n" 1157 " void g1();\n" 1158 "Q_SIGNALS:\n" 1159 " void g2();\n" 1160 "};"); 1161 1162 // Don't interpret 'signals' the wrong way. 1163 verifyFormat("signals.set();"); 1164 verifyFormat("for (Signals signals : f()) {\n}"); 1165 verifyFormat("{\n" 1166 " signals.set(); // This needs indentation.\n" 1167 "}"); 1168 verifyFormat("void f() {\n" 1169 "label:\n" 1170 " signals.baz();\n" 1171 "}"); 1172 } 1173 1174 TEST_F(FormatTest, SeparatesLogicalBlocks) { 1175 EXPECT_EQ("class A {\n" 1176 "public:\n" 1177 " void f();\n" 1178 "\n" 1179 "private:\n" 1180 " void g() {}\n" 1181 " // test\n" 1182 "protected:\n" 1183 " int h;\n" 1184 "};", 1185 format("class A {\n" 1186 "public:\n" 1187 "void f();\n" 1188 "private:\n" 1189 "void g() {}\n" 1190 "// test\n" 1191 "protected:\n" 1192 "int h;\n" 1193 "};")); 1194 EXPECT_EQ("class A {\n" 1195 "protected:\n" 1196 "public:\n" 1197 " void f();\n" 1198 "};", 1199 format("class A {\n" 1200 "protected:\n" 1201 "\n" 1202 "public:\n" 1203 "\n" 1204 " void f();\n" 1205 "};")); 1206 1207 // Even ensure proper spacing inside macros. 1208 EXPECT_EQ("#define B \\\n" 1209 " class A { \\\n" 1210 " protected: \\\n" 1211 " public: \\\n" 1212 " void f(); \\\n" 1213 " };", 1214 format("#define B \\\n" 1215 " class A { \\\n" 1216 " protected: \\\n" 1217 " \\\n" 1218 " public: \\\n" 1219 " \\\n" 1220 " void f(); \\\n" 1221 " };", 1222 getGoogleStyle())); 1223 // But don't remove empty lines after macros ending in access specifiers. 1224 EXPECT_EQ("#define A private:\n" 1225 "\n" 1226 "int i;", 1227 format("#define A private:\n" 1228 "\n" 1229 "int i;")); 1230 } 1231 1232 TEST_F(FormatTest, FormatsClasses) { 1233 verifyFormat("class A : public B {};"); 1234 verifyFormat("class A : public ::B {};"); 1235 1236 verifyFormat( 1237 "class AAAAAAAAAAAAAAAAAAAA : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n" 1238 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};"); 1239 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n" 1240 " : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n" 1241 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};"); 1242 verifyFormat( 1243 "class A : public B, public C, public D, public E, public F {};"); 1244 verifyFormat("class AAAAAAAAAAAA : public B,\n" 1245 " public C,\n" 1246 " public D,\n" 1247 " public E,\n" 1248 " public F,\n" 1249 " public G {};"); 1250 1251 verifyFormat("class\n" 1252 " ReallyReallyLongClassName {\n" 1253 " int i;\n" 1254 "};", 1255 getLLVMStyleWithColumns(32)); 1256 verifyFormat("struct aaaaaaaaaaaaa : public aaaaaaaaaaaaaaaaaaa< // break\n" 1257 " aaaaaaaaaaaaaaaa> {};"); 1258 verifyFormat("struct aaaaaaaaaaaaaaaaaaaa\n" 1259 " : public aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaa,\n" 1260 " aaaaaaaaaaaaaaaaaaaaaa> {};"); 1261 verifyFormat("template <class R, class C>\n" 1262 "struct Aaaaaaaaaaaaaaaaa<R (C::*)(int) const>\n" 1263 " : Aaaaaaaaaaaaaaaaa<R (C::*)(int)> {};"); 1264 verifyFormat("class ::A::B {};"); 1265 } 1266 1267 TEST_F(FormatTest, BreakBeforeInheritanceComma) { 1268 FormatStyle StyleWithInheritanceBreak = getLLVMStyle(); 1269 StyleWithInheritanceBreak.BreakBeforeInheritanceComma = true; 1270 1271 verifyFormat("class MyClass : public X {};", StyleWithInheritanceBreak); 1272 verifyFormat("class MyClass\n" 1273 " : public X\n" 1274 " , public Y {};", 1275 StyleWithInheritanceBreak); 1276 } 1277 1278 TEST_F(FormatTest, FormatsVariableDeclarationsAfterStructOrClass) { 1279 verifyFormat("class A {\n} a, b;"); 1280 verifyFormat("struct A {\n} a, b;"); 1281 verifyFormat("union A {\n} a;"); 1282 } 1283 1284 TEST_F(FormatTest, FormatsEnum) { 1285 verifyFormat("enum {\n" 1286 " Zero,\n" 1287 " One = 1,\n" 1288 " Two = One + 1,\n" 1289 " Three = (One + Two),\n" 1290 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1291 " Five = (One, Two, Three, Four, 5)\n" 1292 "};"); 1293 verifyGoogleFormat("enum {\n" 1294 " Zero,\n" 1295 " One = 1,\n" 1296 " Two = One + 1,\n" 1297 " Three = (One + Two),\n" 1298 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1299 " Five = (One, Two, Three, Four, 5)\n" 1300 "};"); 1301 verifyFormat("enum Enum {};"); 1302 verifyFormat("enum {};"); 1303 verifyFormat("enum X E {} d;"); 1304 verifyFormat("enum __attribute__((...)) E {} d;"); 1305 verifyFormat("enum __declspec__((...)) E {} d;"); 1306 verifyFormat("enum {\n" 1307 " Bar = Foo<int, int>::value\n" 1308 "};", 1309 getLLVMStyleWithColumns(30)); 1310 1311 verifyFormat("enum ShortEnum { A, B, C };"); 1312 verifyGoogleFormat("enum ShortEnum { A, B, C };"); 1313 1314 EXPECT_EQ("enum KeepEmptyLines {\n" 1315 " ONE,\n" 1316 "\n" 1317 " TWO,\n" 1318 "\n" 1319 " THREE\n" 1320 "}", 1321 format("enum KeepEmptyLines {\n" 1322 " ONE,\n" 1323 "\n" 1324 " TWO,\n" 1325 "\n" 1326 "\n" 1327 " THREE\n" 1328 "}")); 1329 verifyFormat("enum E { // comment\n" 1330 " ONE,\n" 1331 " TWO\n" 1332 "};\n" 1333 "int i;"); 1334 // Not enums. 1335 verifyFormat("enum X f() {\n" 1336 " a();\n" 1337 " return 42;\n" 1338 "}"); 1339 verifyFormat("enum X Type::f() {\n" 1340 " a();\n" 1341 " return 42;\n" 1342 "}"); 1343 verifyFormat("enum ::X f() {\n" 1344 " a();\n" 1345 " return 42;\n" 1346 "}"); 1347 verifyFormat("enum ns::X f() {\n" 1348 " a();\n" 1349 " return 42;\n" 1350 "}"); 1351 } 1352 1353 TEST_F(FormatTest, FormatsEnumsWithErrors) { 1354 verifyFormat("enum Type {\n" 1355 " One = 0; // These semicolons should be commas.\n" 1356 " Two = 1;\n" 1357 "};"); 1358 verifyFormat("namespace n {\n" 1359 "enum Type {\n" 1360 " One,\n" 1361 " Two, // missing };\n" 1362 " int i;\n" 1363 "}\n" 1364 "void g() {}"); 1365 } 1366 1367 TEST_F(FormatTest, FormatsEnumStruct) { 1368 verifyFormat("enum struct {\n" 1369 " Zero,\n" 1370 " One = 1,\n" 1371 " Two = One + 1,\n" 1372 " Three = (One + Two),\n" 1373 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1374 " Five = (One, Two, Three, Four, 5)\n" 1375 "};"); 1376 verifyFormat("enum struct Enum {};"); 1377 verifyFormat("enum struct {};"); 1378 verifyFormat("enum struct X E {} d;"); 1379 verifyFormat("enum struct __attribute__((...)) E {} d;"); 1380 verifyFormat("enum struct __declspec__((...)) E {} d;"); 1381 verifyFormat("enum struct X f() {\n a();\n return 42;\n}"); 1382 } 1383 1384 TEST_F(FormatTest, FormatsEnumClass) { 1385 verifyFormat("enum class {\n" 1386 " Zero,\n" 1387 " One = 1,\n" 1388 " Two = One + 1,\n" 1389 " Three = (One + Two),\n" 1390 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1391 " Five = (One, Two, Three, Four, 5)\n" 1392 "};"); 1393 verifyFormat("enum class Enum {};"); 1394 verifyFormat("enum class {};"); 1395 verifyFormat("enum class X E {} d;"); 1396 verifyFormat("enum class __attribute__((...)) E {} d;"); 1397 verifyFormat("enum class __declspec__((...)) E {} d;"); 1398 verifyFormat("enum class X f() {\n a();\n return 42;\n}"); 1399 } 1400 1401 TEST_F(FormatTest, FormatsEnumTypes) { 1402 verifyFormat("enum X : int {\n" 1403 " A, // Force multiple lines.\n" 1404 " B\n" 1405 "};"); 1406 verifyFormat("enum X : int { A, B };"); 1407 verifyFormat("enum X : std::uint32_t { A, B };"); 1408 } 1409 1410 TEST_F(FormatTest, FormatsTypedefEnum) { 1411 FormatStyle Style = getLLVMStyle(); 1412 Style.ColumnLimit = 40; 1413 verifyFormat("typedef enum {} EmptyEnum;"); 1414 verifyFormat("typedef enum { A, B, C } ShortEnum;"); 1415 verifyFormat("typedef enum {\n" 1416 " ZERO = 0,\n" 1417 " ONE = 1,\n" 1418 " TWO = 2,\n" 1419 " THREE = 3\n" 1420 "} LongEnum;", 1421 Style); 1422 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 1423 Style.BraceWrapping.AfterEnum = true; 1424 verifyFormat("typedef enum {} EmptyEnum;"); 1425 verifyFormat("typedef enum { A, B, C } ShortEnum;"); 1426 verifyFormat("typedef enum\n" 1427 "{\n" 1428 " ZERO = 0,\n" 1429 " ONE = 1,\n" 1430 " TWO = 2,\n" 1431 " THREE = 3\n" 1432 "} LongEnum;", 1433 Style); 1434 } 1435 1436 TEST_F(FormatTest, FormatsNSEnums) { 1437 verifyGoogleFormat("typedef NS_ENUM(NSInteger, SomeName) { AAA, BBB }"); 1438 verifyGoogleFormat("typedef NS_ENUM(NSInteger, MyType) {\n" 1439 " // Information about someDecentlyLongValue.\n" 1440 " someDecentlyLongValue,\n" 1441 " // Information about anotherDecentlyLongValue.\n" 1442 " anotherDecentlyLongValue,\n" 1443 " // Information about aThirdDecentlyLongValue.\n" 1444 " aThirdDecentlyLongValue\n" 1445 "};"); 1446 verifyGoogleFormat("typedef NS_OPTIONS(NSInteger, MyType) {\n" 1447 " a = 1,\n" 1448 " b = 2,\n" 1449 " c = 3,\n" 1450 "};"); 1451 verifyGoogleFormat("typedef CF_ENUM(NSInteger, MyType) {\n" 1452 " a = 1,\n" 1453 " b = 2,\n" 1454 " c = 3,\n" 1455 "};"); 1456 verifyGoogleFormat("typedef CF_OPTIONS(NSInteger, MyType) {\n" 1457 " a = 1,\n" 1458 " b = 2,\n" 1459 " c = 3,\n" 1460 "};"); 1461 } 1462 1463 TEST_F(FormatTest, FormatsBitfields) { 1464 verifyFormat("struct Bitfields {\n" 1465 " unsigned sClass : 8;\n" 1466 " unsigned ValueKind : 2;\n" 1467 "};"); 1468 verifyFormat("struct A {\n" 1469 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa : 1,\n" 1470 " bbbbbbbbbbbbbbbbbbbbbbbbb;\n" 1471 "};"); 1472 verifyFormat("struct MyStruct {\n" 1473 " uchar data;\n" 1474 " uchar : 8;\n" 1475 " uchar : 8;\n" 1476 " uchar other;\n" 1477 "};"); 1478 } 1479 1480 TEST_F(FormatTest, FormatsNamespaces) { 1481 FormatStyle LLVMWithNoNamespaceFix = getLLVMStyle(); 1482 LLVMWithNoNamespaceFix.FixNamespaceComments = false; 1483 1484 verifyFormat("namespace some_namespace {\n" 1485 "class A {};\n" 1486 "void f() { f(); }\n" 1487 "}", 1488 LLVMWithNoNamespaceFix); 1489 verifyFormat("namespace {\n" 1490 "class A {};\n" 1491 "void f() { f(); }\n" 1492 "}", 1493 LLVMWithNoNamespaceFix); 1494 verifyFormat("inline namespace X {\n" 1495 "class A {};\n" 1496 "void f() { f(); }\n" 1497 "}", 1498 LLVMWithNoNamespaceFix); 1499 verifyFormat("using namespace some_namespace;\n" 1500 "class A {};\n" 1501 "void f() { f(); }", 1502 LLVMWithNoNamespaceFix); 1503 1504 // This code is more common than we thought; if we 1505 // layout this correctly the semicolon will go into 1506 // its own line, which is undesirable. 1507 verifyFormat("namespace {};", 1508 LLVMWithNoNamespaceFix); 1509 verifyFormat("namespace {\n" 1510 "class A {};\n" 1511 "};", 1512 LLVMWithNoNamespaceFix); 1513 1514 verifyFormat("namespace {\n" 1515 "int SomeVariable = 0; // comment\n" 1516 "} // namespace", 1517 LLVMWithNoNamespaceFix); 1518 EXPECT_EQ("#ifndef HEADER_GUARD\n" 1519 "#define HEADER_GUARD\n" 1520 "namespace my_namespace {\n" 1521 "int i;\n" 1522 "} // my_namespace\n" 1523 "#endif // HEADER_GUARD", 1524 format("#ifndef HEADER_GUARD\n" 1525 " #define HEADER_GUARD\n" 1526 " namespace my_namespace {\n" 1527 "int i;\n" 1528 "} // my_namespace\n" 1529 "#endif // HEADER_GUARD", 1530 LLVMWithNoNamespaceFix)); 1531 1532 EXPECT_EQ("namespace A::B {\n" 1533 "class C {};\n" 1534 "}", 1535 format("namespace A::B {\n" 1536 "class C {};\n" 1537 "}", 1538 LLVMWithNoNamespaceFix)); 1539 1540 FormatStyle Style = getLLVMStyle(); 1541 Style.NamespaceIndentation = FormatStyle::NI_All; 1542 EXPECT_EQ("namespace out {\n" 1543 " int i;\n" 1544 " namespace in {\n" 1545 " int i;\n" 1546 " } // namespace in\n" 1547 "} // namespace out", 1548 format("namespace out {\n" 1549 "int i;\n" 1550 "namespace in {\n" 1551 "int i;\n" 1552 "} // namespace in\n" 1553 "} // namespace out", 1554 Style)); 1555 1556 Style.NamespaceIndentation = FormatStyle::NI_Inner; 1557 EXPECT_EQ("namespace out {\n" 1558 "int i;\n" 1559 "namespace in {\n" 1560 " int i;\n" 1561 "} // namespace in\n" 1562 "} // namespace out", 1563 format("namespace out {\n" 1564 "int i;\n" 1565 "namespace in {\n" 1566 "int i;\n" 1567 "} // namespace in\n" 1568 "} // namespace out", 1569 Style)); 1570 } 1571 1572 TEST_F(FormatTest, FormatsCompactNamespaces) { 1573 FormatStyle Style = getLLVMStyle(); 1574 Style.CompactNamespaces = true; 1575 1576 verifyFormat("namespace A { namespace B {\n" 1577 "}} // namespace A::B", 1578 Style); 1579 1580 EXPECT_EQ("namespace out { namespace in {\n" 1581 "}} // namespace out::in", 1582 format("namespace out {\n" 1583 "namespace in {\n" 1584 "} // namespace in\n" 1585 "} // namespace out", 1586 Style)); 1587 1588 // Only namespaces which have both consecutive opening and end get compacted 1589 EXPECT_EQ("namespace out {\n" 1590 "namespace in1 {\n" 1591 "} // namespace in1\n" 1592 "namespace in2 {\n" 1593 "} // namespace in2\n" 1594 "} // namespace out", 1595 format("namespace out {\n" 1596 "namespace in1 {\n" 1597 "} // namespace in1\n" 1598 "namespace in2 {\n" 1599 "} // namespace in2\n" 1600 "} // namespace out", 1601 Style)); 1602 1603 EXPECT_EQ("namespace out {\n" 1604 "int i;\n" 1605 "namespace in {\n" 1606 "int j;\n" 1607 "} // namespace in\n" 1608 "int k;\n" 1609 "} // namespace out", 1610 format("namespace out { int i;\n" 1611 "namespace in { int j; } // namespace in\n" 1612 "int k; } // namespace out", 1613 Style)); 1614 1615 EXPECT_EQ("namespace A { namespace B { namespace C {\n" 1616 "}}} // namespace A::B::C\n", 1617 format("namespace A { namespace B {\n" 1618 "namespace C {\n" 1619 "}} // namespace B::C\n" 1620 "} // namespace A\n", 1621 Style)); 1622 1623 Style.ColumnLimit = 40; 1624 EXPECT_EQ("namespace aaaaaaaaaa {\n" 1625 "namespace bbbbbbbbbb {\n" 1626 "}} // namespace aaaaaaaaaa::bbbbbbbbbb", 1627 format("namespace aaaaaaaaaa {\n" 1628 "namespace bbbbbbbbbb {\n" 1629 "} // namespace bbbbbbbbbb\n" 1630 "} // namespace aaaaaaaaaa", 1631 Style)); 1632 1633 EXPECT_EQ("namespace aaaaaa { namespace bbbbbb {\n" 1634 "namespace cccccc {\n" 1635 "}}} // namespace aaaaaa::bbbbbb::cccccc", 1636 format("namespace aaaaaa {\n" 1637 "namespace bbbbbb {\n" 1638 "namespace cccccc {\n" 1639 "} // namespace cccccc\n" 1640 "} // namespace bbbbbb\n" 1641 "} // namespace aaaaaa", 1642 Style)); 1643 Style.ColumnLimit = 80; 1644 1645 // Extra semicolon after 'inner' closing brace prevents merging 1646 EXPECT_EQ("namespace out { namespace in {\n" 1647 "}; } // namespace out::in", 1648 format("namespace out {\n" 1649 "namespace in {\n" 1650 "}; // namespace in\n" 1651 "} // namespace out", 1652 Style)); 1653 1654 // Extra semicolon after 'outer' closing brace is conserved 1655 EXPECT_EQ("namespace out { namespace in {\n" 1656 "}}; // namespace out::in", 1657 format("namespace out {\n" 1658 "namespace in {\n" 1659 "} // namespace in\n" 1660 "}; // namespace out", 1661 Style)); 1662 1663 Style.NamespaceIndentation = FormatStyle::NI_All; 1664 EXPECT_EQ("namespace out { namespace in {\n" 1665 " int i;\n" 1666 "}} // namespace out::in", 1667 format("namespace out {\n" 1668 "namespace in {\n" 1669 "int i;\n" 1670 "} // namespace in\n" 1671 "} // namespace out", 1672 Style)); 1673 EXPECT_EQ("namespace out { namespace mid {\n" 1674 " namespace in {\n" 1675 " int j;\n" 1676 " } // namespace in\n" 1677 " int k;\n" 1678 "}} // namespace out::mid", 1679 format("namespace out { namespace mid {\n" 1680 "namespace in { int j; } // namespace in\n" 1681 "int k; }} // namespace out::mid", 1682 Style)); 1683 1684 Style.NamespaceIndentation = FormatStyle::NI_Inner; 1685 EXPECT_EQ("namespace out { namespace in {\n" 1686 " int i;\n" 1687 "}} // namespace out::in", 1688 format("namespace out {\n" 1689 "namespace in {\n" 1690 "int i;\n" 1691 "} // namespace in\n" 1692 "} // namespace out", 1693 Style)); 1694 EXPECT_EQ("namespace out { namespace mid { namespace in {\n" 1695 " int i;\n" 1696 "}}} // namespace out::mid::in", 1697 format("namespace out {\n" 1698 "namespace mid {\n" 1699 "namespace in {\n" 1700 "int i;\n" 1701 "} // namespace in\n" 1702 "} // namespace mid\n" 1703 "} // namespace out", 1704 Style)); 1705 } 1706 1707 TEST_F(FormatTest, FormatsExternC) { 1708 verifyFormat("extern \"C\" {\nint a;"); 1709 verifyFormat("extern \"C\" {}"); 1710 verifyFormat("extern \"C\" {\n" 1711 "int foo();\n" 1712 "}"); 1713 verifyFormat("extern \"C\" int foo() {}"); 1714 verifyFormat("extern \"C\" int foo();"); 1715 verifyFormat("extern \"C\" int foo() {\n" 1716 " int i = 42;\n" 1717 " return i;\n" 1718 "}"); 1719 1720 FormatStyle Style = getLLVMStyle(); 1721 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 1722 Style.BraceWrapping.AfterFunction = true; 1723 verifyFormat("extern \"C\" int foo() {}", Style); 1724 verifyFormat("extern \"C\" int foo();", Style); 1725 verifyFormat("extern \"C\" int foo()\n" 1726 "{\n" 1727 " int i = 42;\n" 1728 " return i;\n" 1729 "}", 1730 Style); 1731 1732 Style.BraceWrapping.AfterExternBlock = true; 1733 Style.BraceWrapping.SplitEmptyRecord = false; 1734 verifyFormat("extern \"C\"\n" 1735 "{}", 1736 Style); 1737 verifyFormat("extern \"C\"\n" 1738 "{\n" 1739 " int foo();\n" 1740 "}", 1741 Style); 1742 } 1743 1744 TEST_F(FormatTest, FormatsInlineASM) { 1745 verifyFormat("asm(\"xyz\" : \"=a\"(a), \"=d\"(b) : \"a\"(data));"); 1746 verifyFormat("asm(\"nop\" ::: \"memory\");"); 1747 verifyFormat( 1748 "asm(\"movq\\t%%rbx, %%rsi\\n\\t\"\n" 1749 " \"cpuid\\n\\t\"\n" 1750 " \"xchgq\\t%%rbx, %%rsi\\n\\t\"\n" 1751 " : \"=a\"(*rEAX), \"=S\"(*rEBX), \"=c\"(*rECX), \"=d\"(*rEDX)\n" 1752 " : \"a\"(value));"); 1753 EXPECT_EQ( 1754 "void NS_InvokeByIndex(void *that, unsigned int methodIndex) {\n" 1755 " __asm {\n" 1756 " mov edx,[that] // vtable in edx\n" 1757 " mov eax,methodIndex\n" 1758 " call [edx][eax*4] // stdcall\n" 1759 " }\n" 1760 "}", 1761 format("void NS_InvokeByIndex(void *that, unsigned int methodIndex) {\n" 1762 " __asm {\n" 1763 " mov edx,[that] // vtable in edx\n" 1764 " mov eax,methodIndex\n" 1765 " call [edx][eax*4] // stdcall\n" 1766 " }\n" 1767 "}")); 1768 EXPECT_EQ("_asm {\n" 1769 " xor eax, eax;\n" 1770 " cpuid;\n" 1771 "}", 1772 format("_asm {\n" 1773 " xor eax, eax;\n" 1774 " cpuid;\n" 1775 "}")); 1776 verifyFormat("void function() {\n" 1777 " // comment\n" 1778 " asm(\"\");\n" 1779 "}"); 1780 EXPECT_EQ("__asm {\n" 1781 "}\n" 1782 "int i;", 1783 format("__asm {\n" 1784 "}\n" 1785 "int i;")); 1786 } 1787 1788 TEST_F(FormatTest, FormatTryCatch) { 1789 verifyFormat("try {\n" 1790 " throw a * b;\n" 1791 "} catch (int a) {\n" 1792 " // Do nothing.\n" 1793 "} catch (...) {\n" 1794 " exit(42);\n" 1795 "}"); 1796 1797 // Function-level try statements. 1798 verifyFormat("int f() try { return 4; } catch (...) {\n" 1799 " return 5;\n" 1800 "}"); 1801 verifyFormat("class A {\n" 1802 " int a;\n" 1803 " A() try : a(0) {\n" 1804 " } catch (...) {\n" 1805 " throw;\n" 1806 " }\n" 1807 "};\n"); 1808 1809 // Incomplete try-catch blocks. 1810 verifyIncompleteFormat("try {} catch ("); 1811 } 1812 1813 TEST_F(FormatTest, FormatSEHTryCatch) { 1814 verifyFormat("__try {\n" 1815 " int a = b * c;\n" 1816 "} __except (EXCEPTION_EXECUTE_HANDLER) {\n" 1817 " // Do nothing.\n" 1818 "}"); 1819 1820 verifyFormat("__try {\n" 1821 " int a = b * c;\n" 1822 "} __finally {\n" 1823 " // Do nothing.\n" 1824 "}"); 1825 1826 verifyFormat("DEBUG({\n" 1827 " __try {\n" 1828 " } __finally {\n" 1829 " }\n" 1830 "});\n"); 1831 } 1832 1833 TEST_F(FormatTest, IncompleteTryCatchBlocks) { 1834 verifyFormat("try {\n" 1835 " f();\n" 1836 "} catch {\n" 1837 " g();\n" 1838 "}"); 1839 verifyFormat("try {\n" 1840 " f();\n" 1841 "} catch (A a) MACRO(x) {\n" 1842 " g();\n" 1843 "} catch (B b) MACRO(x) {\n" 1844 " g();\n" 1845 "}"); 1846 } 1847 1848 TEST_F(FormatTest, FormatTryCatchBraceStyles) { 1849 FormatStyle Style = getLLVMStyle(); 1850 for (auto BraceStyle : {FormatStyle::BS_Attach, FormatStyle::BS_Mozilla, 1851 FormatStyle::BS_WebKit}) { 1852 Style.BreakBeforeBraces = BraceStyle; 1853 verifyFormat("try {\n" 1854 " // something\n" 1855 "} catch (...) {\n" 1856 " // something\n" 1857 "}", 1858 Style); 1859 } 1860 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 1861 verifyFormat("try {\n" 1862 " // something\n" 1863 "}\n" 1864 "catch (...) {\n" 1865 " // something\n" 1866 "}", 1867 Style); 1868 verifyFormat("__try {\n" 1869 " // something\n" 1870 "}\n" 1871 "__finally {\n" 1872 " // something\n" 1873 "}", 1874 Style); 1875 verifyFormat("@try {\n" 1876 " // something\n" 1877 "}\n" 1878 "@finally {\n" 1879 " // something\n" 1880 "}", 1881 Style); 1882 Style.BreakBeforeBraces = FormatStyle::BS_Allman; 1883 verifyFormat("try\n" 1884 "{\n" 1885 " // something\n" 1886 "}\n" 1887 "catch (...)\n" 1888 "{\n" 1889 " // something\n" 1890 "}", 1891 Style); 1892 Style.BreakBeforeBraces = FormatStyle::BS_GNU; 1893 verifyFormat("try\n" 1894 " {\n" 1895 " // something\n" 1896 " }\n" 1897 "catch (...)\n" 1898 " {\n" 1899 " // something\n" 1900 " }", 1901 Style); 1902 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 1903 Style.BraceWrapping.BeforeCatch = true; 1904 verifyFormat("try {\n" 1905 " // something\n" 1906 "}\n" 1907 "catch (...) {\n" 1908 " // something\n" 1909 "}", 1910 Style); 1911 } 1912 1913 TEST_F(FormatTest, StaticInitializers) { 1914 verifyFormat("static SomeClass SC = {1, 'a'};"); 1915 1916 verifyFormat("static SomeClass WithALoooooooooooooooooooongName = {\n" 1917 " 100000000, " 1918 "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"};"); 1919 1920 // Here, everything other than the "}" would fit on a line. 1921 verifyFormat("static int LooooooooooooooooooooooooongVariable[1] = {\n" 1922 " 10000000000000000000000000};"); 1923 EXPECT_EQ("S s = {a,\n" 1924 "\n" 1925 " b};", 1926 format("S s = {\n" 1927 " a,\n" 1928 "\n" 1929 " b\n" 1930 "};")); 1931 1932 // FIXME: This would fit into the column limit if we'd fit "{ {" on the first 1933 // line. However, the formatting looks a bit off and this probably doesn't 1934 // happen often in practice. 1935 verifyFormat("static int Variable[1] = {\n" 1936 " {1000000000000000000000000000000000000}};", 1937 getLLVMStyleWithColumns(40)); 1938 } 1939 1940 TEST_F(FormatTest, DesignatedInitializers) { 1941 verifyFormat("const struct A a = {.a = 1, .b = 2};"); 1942 verifyFormat("const struct A a = {.aaaaaaaaaa = 1,\n" 1943 " .bbbbbbbbbb = 2,\n" 1944 " .cccccccccc = 3,\n" 1945 " .dddddddddd = 4,\n" 1946 " .eeeeeeeeee = 5};"); 1947 verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n" 1948 " .aaaaaaaaaaaaaaaaaaaaaaaaaaa = 1,\n" 1949 " .bbbbbbbbbbbbbbbbbbbbbbbbbbb = 2,\n" 1950 " .ccccccccccccccccccccccccccc = 3,\n" 1951 " .ddddddddddddddddddddddddddd = 4,\n" 1952 " .eeeeeeeeeeeeeeeeeeeeeeeeeee = 5};"); 1953 1954 verifyGoogleFormat("const struct A a = {.a = 1, .b = 2};"); 1955 1956 verifyFormat("const struct A a = {[0] = 1, [1] = 2};"); 1957 verifyFormat("const struct A a = {[1] = aaaaaaaaaa,\n" 1958 " [2] = bbbbbbbbbb,\n" 1959 " [3] = cccccccccc,\n" 1960 " [4] = dddddddddd,\n" 1961 " [5] = eeeeeeeeee};"); 1962 verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n" 1963 " [1] = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 1964 " [2] = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" 1965 " [3] = cccccccccccccccccccccccccccccccccccccc,\n" 1966 " [4] = dddddddddddddddddddddddddddddddddddddd,\n" 1967 " [5] = eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee};"); 1968 } 1969 1970 TEST_F(FormatTest, NestedStaticInitializers) { 1971 verifyFormat("static A x = {{{}}};\n"); 1972 verifyFormat("static A x = {{{init1, init2, init3, init4},\n" 1973 " {init1, init2, init3, init4}}};", 1974 getLLVMStyleWithColumns(50)); 1975 1976 verifyFormat("somes Status::global_reps[3] = {\n" 1977 " {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n" 1978 " {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n" 1979 " {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};", 1980 getLLVMStyleWithColumns(60)); 1981 verifyGoogleFormat("SomeType Status::global_reps[3] = {\n" 1982 " {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n" 1983 " {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n" 1984 " {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};"); 1985 verifyFormat("CGRect cg_rect = {{rect.fLeft, rect.fTop},\n" 1986 " {rect.fRight - rect.fLeft, rect.fBottom - " 1987 "rect.fTop}};"); 1988 1989 verifyFormat( 1990 "SomeArrayOfSomeType a = {\n" 1991 " {{1, 2, 3},\n" 1992 " {1, 2, 3},\n" 1993 " {111111111111111111111111111111, 222222222222222222222222222222,\n" 1994 " 333333333333333333333333333333},\n" 1995 " {1, 2, 3},\n" 1996 " {1, 2, 3}}};"); 1997 verifyFormat( 1998 "SomeArrayOfSomeType a = {\n" 1999 " {{1, 2, 3}},\n" 2000 " {{1, 2, 3}},\n" 2001 " {{111111111111111111111111111111, 222222222222222222222222222222,\n" 2002 " 333333333333333333333333333333}},\n" 2003 " {{1, 2, 3}},\n" 2004 " {{1, 2, 3}}};"); 2005 2006 verifyFormat("struct {\n" 2007 " unsigned bit;\n" 2008 " const char *const name;\n" 2009 "} kBitsToOs[] = {{kOsMac, \"Mac\"},\n" 2010 " {kOsWin, \"Windows\"},\n" 2011 " {kOsLinux, \"Linux\"},\n" 2012 " {kOsCrOS, \"Chrome OS\"}};"); 2013 verifyFormat("struct {\n" 2014 " unsigned bit;\n" 2015 " const char *const name;\n" 2016 "} kBitsToOs[] = {\n" 2017 " {kOsMac, \"Mac\"},\n" 2018 " {kOsWin, \"Windows\"},\n" 2019 " {kOsLinux, \"Linux\"},\n" 2020 " {kOsCrOS, \"Chrome OS\"},\n" 2021 "};"); 2022 } 2023 2024 TEST_F(FormatTest, FormatsSmallMacroDefinitionsInSingleLine) { 2025 verifyFormat("#define ALooooooooooooooooooooooooooooooooooooooongMacro(" 2026 " \\\n" 2027 " aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)"); 2028 } 2029 2030 TEST_F(FormatTest, DoesNotBreakPureVirtualFunctionDefinition) { 2031 verifyFormat("virtual void write(ELFWriter *writerrr,\n" 2032 " OwningPtr<FileOutputBuffer> &buffer) = 0;"); 2033 2034 // Do break defaulted and deleted functions. 2035 verifyFormat("virtual void ~Deeeeeeeestructor() =\n" 2036 " default;", 2037 getLLVMStyleWithColumns(40)); 2038 verifyFormat("virtual void ~Deeeeeeeestructor() =\n" 2039 " delete;", 2040 getLLVMStyleWithColumns(40)); 2041 } 2042 2043 TEST_F(FormatTest, BreaksStringLiteralsOnlyInDefine) { 2044 verifyFormat("# 1111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\" 2 3", 2045 getLLVMStyleWithColumns(40)); 2046 verifyFormat("#line 11111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"", 2047 getLLVMStyleWithColumns(40)); 2048 EXPECT_EQ("#define Q \\\n" 2049 " \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/\" \\\n" 2050 " \"aaaaaaaa.cpp\"", 2051 format("#define Q \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"", 2052 getLLVMStyleWithColumns(40))); 2053 } 2054 2055 TEST_F(FormatTest, UnderstandsLinePPDirective) { 2056 EXPECT_EQ("# 123 \"A string literal\"", 2057 format(" # 123 \"A string literal\"")); 2058 } 2059 2060 TEST_F(FormatTest, LayoutUnknownPPDirective) { 2061 EXPECT_EQ("#;", format("#;")); 2062 verifyFormat("#\n;\n;\n;"); 2063 } 2064 2065 TEST_F(FormatTest, UnescapedEndOfLineEndsPPDirective) { 2066 EXPECT_EQ("#line 42 \"test\"\n", 2067 format("# \\\n line \\\n 42 \\\n \"test\"\n")); 2068 EXPECT_EQ("#define A B\n", format("# \\\n define \\\n A \\\n B\n", 2069 getLLVMStyleWithColumns(12))); 2070 } 2071 2072 TEST_F(FormatTest, EndOfFileEndsPPDirective) { 2073 EXPECT_EQ("#line 42 \"test\"", 2074 format("# \\\n line \\\n 42 \\\n \"test\"")); 2075 EXPECT_EQ("#define A B", format("# \\\n define \\\n A \\\n B")); 2076 } 2077 2078 TEST_F(FormatTest, DoesntRemoveUnknownTokens) { 2079 verifyFormat("#define A \\x20"); 2080 verifyFormat("#define A \\ x20"); 2081 EXPECT_EQ("#define A \\ x20", format("#define A \\ x20")); 2082 verifyFormat("#define A ''"); 2083 verifyFormat("#define A ''qqq"); 2084 verifyFormat("#define A `qqq"); 2085 verifyFormat("f(\"aaaa, bbbb, \"\\\"ccccc\\\"\");"); 2086 EXPECT_EQ("const char *c = STRINGIFY(\n" 2087 "\\na : b);", 2088 format("const char * c = STRINGIFY(\n" 2089 "\\na : b);")); 2090 2091 verifyFormat("a\r\\"); 2092 verifyFormat("a\v\\"); 2093 verifyFormat("a\f\\"); 2094 } 2095 2096 TEST_F(FormatTest, IndentsPPDirectiveInReducedSpace) { 2097 verifyFormat("#define A(BB)", getLLVMStyleWithColumns(13)); 2098 verifyFormat("#define A( \\\n BB)", getLLVMStyleWithColumns(12)); 2099 verifyFormat("#define A( \\\n A, B)", getLLVMStyleWithColumns(12)); 2100 // FIXME: We never break before the macro name. 2101 verifyFormat("#define AA( \\\n B)", getLLVMStyleWithColumns(12)); 2102 2103 verifyFormat("#define A A\n#define A A"); 2104 verifyFormat("#define A(X) A\n#define A A"); 2105 2106 verifyFormat("#define Something Other", getLLVMStyleWithColumns(23)); 2107 verifyFormat("#define Something \\\n Other", getLLVMStyleWithColumns(22)); 2108 } 2109 2110 TEST_F(FormatTest, HandlePreprocessorDirectiveContext) { 2111 EXPECT_EQ("// somecomment\n" 2112 "#include \"a.h\"\n" 2113 "#define A( \\\n" 2114 " A, B)\n" 2115 "#include \"b.h\"\n" 2116 "// somecomment\n", 2117 format(" // somecomment\n" 2118 " #include \"a.h\"\n" 2119 "#define A(A,\\\n" 2120 " B)\n" 2121 " #include \"b.h\"\n" 2122 " // somecomment\n", 2123 getLLVMStyleWithColumns(13))); 2124 } 2125 2126 TEST_F(FormatTest, LayoutSingleHash) { EXPECT_EQ("#\na;", format("#\na;")); } 2127 2128 TEST_F(FormatTest, LayoutCodeInMacroDefinitions) { 2129 EXPECT_EQ("#define A \\\n" 2130 " c; \\\n" 2131 " e;\n" 2132 "f;", 2133 format("#define A c; e;\n" 2134 "f;", 2135 getLLVMStyleWithColumns(14))); 2136 } 2137 2138 TEST_F(FormatTest, LayoutRemainingTokens) { EXPECT_EQ("{}", format("{}")); } 2139 2140 TEST_F(FormatTest, MacroDefinitionInsideStatement) { 2141 EXPECT_EQ("int x,\n" 2142 "#define A\n" 2143 " y;", 2144 format("int x,\n#define A\ny;")); 2145 } 2146 2147 TEST_F(FormatTest, HashInMacroDefinition) { 2148 EXPECT_EQ("#define A(c) L#c", format("#define A(c) L#c", getLLVMStyle())); 2149 verifyFormat("#define A \\\n b #c;", getLLVMStyleWithColumns(11)); 2150 verifyFormat("#define A \\\n" 2151 " { \\\n" 2152 " f(#c); \\\n" 2153 " }", 2154 getLLVMStyleWithColumns(11)); 2155 2156 verifyFormat("#define A(X) \\\n" 2157 " void function##X()", 2158 getLLVMStyleWithColumns(22)); 2159 2160 verifyFormat("#define A(a, b, c) \\\n" 2161 " void a##b##c()", 2162 getLLVMStyleWithColumns(22)); 2163 2164 verifyFormat("#define A void # ## #", getLLVMStyleWithColumns(22)); 2165 } 2166 2167 TEST_F(FormatTest, RespectWhitespaceInMacroDefinitions) { 2168 EXPECT_EQ("#define A (x)", format("#define A (x)")); 2169 EXPECT_EQ("#define A(x)", format("#define A(x)")); 2170 } 2171 2172 TEST_F(FormatTest, EmptyLinesInMacroDefinitions) { 2173 EXPECT_EQ("#define A b;", format("#define A \\\n" 2174 " \\\n" 2175 " b;", 2176 getLLVMStyleWithColumns(25))); 2177 EXPECT_EQ("#define A \\\n" 2178 " \\\n" 2179 " a; \\\n" 2180 " b;", 2181 format("#define A \\\n" 2182 " \\\n" 2183 " a; \\\n" 2184 " b;", 2185 getLLVMStyleWithColumns(11))); 2186 EXPECT_EQ("#define A \\\n" 2187 " a; \\\n" 2188 " \\\n" 2189 " b;", 2190 format("#define A \\\n" 2191 " a; \\\n" 2192 " \\\n" 2193 " b;", 2194 getLLVMStyleWithColumns(11))); 2195 } 2196 2197 TEST_F(FormatTest, MacroDefinitionsWithIncompleteCode) { 2198 verifyIncompleteFormat("#define A :"); 2199 verifyFormat("#define SOMECASES \\\n" 2200 " case 1: \\\n" 2201 " case 2\n", 2202 getLLVMStyleWithColumns(20)); 2203 verifyFormat("#define MACRO(a) \\\n" 2204 " if (a) \\\n" 2205 " f(); \\\n" 2206 " else \\\n" 2207 " g()", 2208 getLLVMStyleWithColumns(18)); 2209 verifyFormat("#define A template <typename T>"); 2210 verifyIncompleteFormat("#define STR(x) #x\n" 2211 "f(STR(this_is_a_string_literal{));"); 2212 verifyFormat("#pragma omp threadprivate( \\\n" 2213 " y)), // expected-warning", 2214 getLLVMStyleWithColumns(28)); 2215 verifyFormat("#d, = };"); 2216 verifyFormat("#if \"a"); 2217 verifyIncompleteFormat("({\n" 2218 "#define b \\\n" 2219 " } \\\n" 2220 " a\n" 2221 "a", 2222 getLLVMStyleWithColumns(15)); 2223 verifyFormat("#define A \\\n" 2224 " { \\\n" 2225 " {\n" 2226 "#define B \\\n" 2227 " } \\\n" 2228 " }", 2229 getLLVMStyleWithColumns(15)); 2230 verifyNoCrash("#if a\na(\n#else\n#endif\n{a"); 2231 verifyNoCrash("a={0,1\n#if a\n#else\n;\n#endif\n}"); 2232 verifyNoCrash("#if a\na(\n#else\n#endif\n) a {a,b,c,d,f,g};"); 2233 verifyNoCrash("#ifdef A\n a(\n #else\n #endif\n) = []() { \n)}"); 2234 } 2235 2236 TEST_F(FormatTest, MacrosWithoutTrailingSemicolon) { 2237 verifyFormat("SOME_TYPE_NAME abc;"); // Gated on the newline. 2238 EXPECT_EQ("class A : public QObject {\n" 2239 " Q_OBJECT\n" 2240 "\n" 2241 " A() {}\n" 2242 "};", 2243 format("class A : public QObject {\n" 2244 " Q_OBJECT\n" 2245 "\n" 2246 " A() {\n}\n" 2247 "} ;")); 2248 EXPECT_EQ("MACRO\n" 2249 "/*static*/ int i;", 2250 format("MACRO\n" 2251 " /*static*/ int i;")); 2252 EXPECT_EQ("SOME_MACRO\n" 2253 "namespace {\n" 2254 "void f();\n" 2255 "} // namespace", 2256 format("SOME_MACRO\n" 2257 " namespace {\n" 2258 "void f( );\n" 2259 "} // namespace")); 2260 // Only if the identifier contains at least 5 characters. 2261 EXPECT_EQ("HTTP f();", format("HTTP\nf();")); 2262 EXPECT_EQ("MACRO\nf();", format("MACRO\nf();")); 2263 // Only if everything is upper case. 2264 EXPECT_EQ("class A : public QObject {\n" 2265 " Q_Object A() {}\n" 2266 "};", 2267 format("class A : public QObject {\n" 2268 " Q_Object\n" 2269 " A() {\n}\n" 2270 "} ;")); 2271 2272 // Only if the next line can actually start an unwrapped line. 2273 EXPECT_EQ("SOME_WEIRD_LOG_MACRO << SomeThing;", 2274 format("SOME_WEIRD_LOG_MACRO\n" 2275 "<< SomeThing;")); 2276 2277 verifyFormat("VISIT_GL_CALL(GenBuffers, void, (GLsizei n, GLuint* buffers), " 2278 "(n, buffers))\n", 2279 getChromiumStyle(FormatStyle::LK_Cpp)); 2280 } 2281 2282 TEST_F(FormatTest, MacroCallsWithoutTrailingSemicolon) { 2283 EXPECT_EQ("INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n" 2284 "INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n" 2285 "INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n" 2286 "class X {};\n" 2287 "INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n" 2288 "int *createScopDetectionPass() { return 0; }", 2289 format(" INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n" 2290 " INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n" 2291 " INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n" 2292 " class X {};\n" 2293 " INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n" 2294 " int *createScopDetectionPass() { return 0; }")); 2295 // FIXME: We could probably treat IPC_BEGIN_MESSAGE_MAP/IPC_END_MESSAGE_MAP as 2296 // braces, so that inner block is indented one level more. 2297 EXPECT_EQ("int q() {\n" 2298 " IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n" 2299 " IPC_MESSAGE_HANDLER(xxx, qqq)\n" 2300 " IPC_END_MESSAGE_MAP()\n" 2301 "}", 2302 format("int q() {\n" 2303 " IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n" 2304 " IPC_MESSAGE_HANDLER(xxx, qqq)\n" 2305 " IPC_END_MESSAGE_MAP()\n" 2306 "}")); 2307 2308 // Same inside macros. 2309 EXPECT_EQ("#define LIST(L) \\\n" 2310 " L(A) \\\n" 2311 " L(B) \\\n" 2312 " L(C)", 2313 format("#define LIST(L) \\\n" 2314 " L(A) \\\n" 2315 " L(B) \\\n" 2316 " L(C)", 2317 getGoogleStyle())); 2318 2319 // These must not be recognized as macros. 2320 EXPECT_EQ("int q() {\n" 2321 " f(x);\n" 2322 " f(x) {}\n" 2323 " f(x)->g();\n" 2324 " f(x)->*g();\n" 2325 " f(x).g();\n" 2326 " f(x) = x;\n" 2327 " f(x) += x;\n" 2328 " f(x) -= x;\n" 2329 " f(x) *= x;\n" 2330 " f(x) /= x;\n" 2331 " f(x) %= x;\n" 2332 " f(x) &= x;\n" 2333 " f(x) |= x;\n" 2334 " f(x) ^= x;\n" 2335 " f(x) >>= x;\n" 2336 " f(x) <<= x;\n" 2337 " f(x)[y].z();\n" 2338 " LOG(INFO) << x;\n" 2339 " ifstream(x) >> x;\n" 2340 "}\n", 2341 format("int q() {\n" 2342 " f(x)\n;\n" 2343 " f(x)\n {}\n" 2344 " f(x)\n->g();\n" 2345 " f(x)\n->*g();\n" 2346 " f(x)\n.g();\n" 2347 " f(x)\n = x;\n" 2348 " f(x)\n += x;\n" 2349 " f(x)\n -= x;\n" 2350 " f(x)\n *= x;\n" 2351 " f(x)\n /= x;\n" 2352 " f(x)\n %= x;\n" 2353 " f(x)\n &= x;\n" 2354 " f(x)\n |= x;\n" 2355 " f(x)\n ^= x;\n" 2356 " f(x)\n >>= x;\n" 2357 " f(x)\n <<= x;\n" 2358 " f(x)\n[y].z();\n" 2359 " LOG(INFO)\n << x;\n" 2360 " ifstream(x)\n >> x;\n" 2361 "}\n")); 2362 EXPECT_EQ("int q() {\n" 2363 " F(x)\n" 2364 " if (1) {\n" 2365 " }\n" 2366 " F(x)\n" 2367 " while (1) {\n" 2368 " }\n" 2369 " F(x)\n" 2370 " G(x);\n" 2371 " F(x)\n" 2372 " try {\n" 2373 " Q();\n" 2374 " } catch (...) {\n" 2375 " }\n" 2376 "}\n", 2377 format("int q() {\n" 2378 "F(x)\n" 2379 "if (1) {}\n" 2380 "F(x)\n" 2381 "while (1) {}\n" 2382 "F(x)\n" 2383 "G(x);\n" 2384 "F(x)\n" 2385 "try { Q(); } catch (...) {}\n" 2386 "}\n")); 2387 EXPECT_EQ("class A {\n" 2388 " A() : t(0) {}\n" 2389 " A(int i) noexcept() : {}\n" 2390 " A(X x)\n" // FIXME: function-level try blocks are broken. 2391 " try : t(0) {\n" 2392 " } catch (...) {\n" 2393 " }\n" 2394 "};", 2395 format("class A {\n" 2396 " A()\n : t(0) {}\n" 2397 " A(int i)\n noexcept() : {}\n" 2398 " A(X x)\n" 2399 " try : t(0) {} catch (...) {}\n" 2400 "};")); 2401 EXPECT_EQ("class SomeClass {\n" 2402 "public:\n" 2403 " SomeClass() EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 2404 "};", 2405 format("class SomeClass {\n" 2406 "public:\n" 2407 " SomeClass()\n" 2408 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 2409 "};")); 2410 EXPECT_EQ("class SomeClass {\n" 2411 "public:\n" 2412 " SomeClass()\n" 2413 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 2414 "};", 2415 format("class SomeClass {\n" 2416 "public:\n" 2417 " SomeClass()\n" 2418 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 2419 "};", 2420 getLLVMStyleWithColumns(40))); 2421 2422 verifyFormat("MACRO(>)"); 2423 } 2424 2425 TEST_F(FormatTest, LayoutMacroDefinitionsStatementsSpanningBlocks) { 2426 verifyFormat("#define A \\\n" 2427 " f({ \\\n" 2428 " g(); \\\n" 2429 " });", 2430 getLLVMStyleWithColumns(11)); 2431 } 2432 2433 TEST_F(FormatTest, IndentPreprocessorDirectives) { 2434 FormatStyle Style = getLLVMStyle(); 2435 Style.IndentPPDirectives = FormatStyle::PPDIS_None; 2436 Style.ColumnLimit = 40; 2437 verifyFormat("#ifdef _WIN32\n" 2438 "#define A 0\n" 2439 "#ifdef VAR2\n" 2440 "#define B 1\n" 2441 "#include <someheader.h>\n" 2442 "#define MACRO \\\n" 2443 " some_very_long_func_aaaaaaaaaa();\n" 2444 "#endif\n" 2445 "#else\n" 2446 "#define A 1\n" 2447 "#endif", 2448 Style); 2449 Style.IndentPPDirectives = FormatStyle::PPDIS_AfterHash; 2450 verifyFormat("#ifdef _WIN32\n" 2451 "# define A 0\n" 2452 "# ifdef VAR2\n" 2453 "# define B 1\n" 2454 "# include <someheader.h>\n" 2455 "# define MACRO \\\n" 2456 " some_very_long_func_aaaaaaaaaa();\n" 2457 "# endif\n" 2458 "#else\n" 2459 "# define A 1\n" 2460 "#endif", 2461 Style); 2462 verifyFormat("#if A\n" 2463 "# define MACRO \\\n" 2464 " void a(int x) { \\\n" 2465 " b(); \\\n" 2466 " c(); \\\n" 2467 " d(); \\\n" 2468 " e(); \\\n" 2469 " f(); \\\n" 2470 " }\n" 2471 "#endif", 2472 Style); 2473 // Comments before include guard. 2474 verifyFormat("// file comment\n" 2475 "// file comment\n" 2476 "#ifndef HEADER_H\n" 2477 "#define HEADER_H\n" 2478 "code();\n" 2479 "#endif", 2480 Style); 2481 // Test with include guards. 2482 // EXPECT_EQ is used because verifyFormat() calls messUp() which incorrectly 2483 // merges lines. 2484 verifyFormat("#ifndef HEADER_H\n" 2485 "#define HEADER_H\n" 2486 "code();\n" 2487 "#endif", 2488 Style); 2489 // Include guards must have a #define with the same variable immediately 2490 // after #ifndef. 2491 verifyFormat("#ifndef NOT_GUARD\n" 2492 "# define FOO\n" 2493 "code();\n" 2494 "#endif", 2495 Style); 2496 2497 // Include guards must cover the entire file. 2498 verifyFormat("code();\n" 2499 "code();\n" 2500 "#ifndef NOT_GUARD\n" 2501 "# define NOT_GUARD\n" 2502 "code();\n" 2503 "#endif", 2504 Style); 2505 verifyFormat("#ifndef NOT_GUARD\n" 2506 "# define NOT_GUARD\n" 2507 "code();\n" 2508 "#endif\n" 2509 "code();", 2510 Style); 2511 // Test with trailing blank lines. 2512 verifyFormat("#ifndef HEADER_H\n" 2513 "#define HEADER_H\n" 2514 "code();\n" 2515 "#endif\n", 2516 Style); 2517 // Include guards don't have #else. 2518 verifyFormat("#ifndef NOT_GUARD\n" 2519 "# define NOT_GUARD\n" 2520 "code();\n" 2521 "#else\n" 2522 "#endif", 2523 Style); 2524 verifyFormat("#ifndef NOT_GUARD\n" 2525 "# define NOT_GUARD\n" 2526 "code();\n" 2527 "#elif FOO\n" 2528 "#endif", 2529 Style); 2530 // FIXME: This doesn't handle the case where there's code between the 2531 // #ifndef and #define but all other conditions hold. This is because when 2532 // the #define line is parsed, UnwrappedLineParser::Lines doesn't hold the 2533 // previous code line yet, so we can't detect it. 2534 EXPECT_EQ("#ifndef NOT_GUARD\n" 2535 "code();\n" 2536 "#define NOT_GUARD\n" 2537 "code();\n" 2538 "#endif", 2539 format("#ifndef NOT_GUARD\n" 2540 "code();\n" 2541 "# define NOT_GUARD\n" 2542 "code();\n" 2543 "#endif", 2544 Style)); 2545 // FIXME: This doesn't handle cases where legitimate preprocessor lines may 2546 // be outside an include guard. Examples are #pragma once and 2547 // #pragma GCC diagnostic, or anything else that does not change the meaning 2548 // of the file if it's included multiple times. 2549 EXPECT_EQ("#ifdef WIN32\n" 2550 "# pragma once\n" 2551 "#endif\n" 2552 "#ifndef HEADER_H\n" 2553 "# define HEADER_H\n" 2554 "code();\n" 2555 "#endif", 2556 format("#ifdef WIN32\n" 2557 "# pragma once\n" 2558 "#endif\n" 2559 "#ifndef HEADER_H\n" 2560 "#define HEADER_H\n" 2561 "code();\n" 2562 "#endif", 2563 Style)); 2564 // FIXME: This does not detect when there is a single non-preprocessor line 2565 // in front of an include-guard-like structure where other conditions hold 2566 // because ScopedLineState hides the line. 2567 EXPECT_EQ("code();\n" 2568 "#ifndef HEADER_H\n" 2569 "#define HEADER_H\n" 2570 "code();\n" 2571 "#endif", 2572 format("code();\n" 2573 "#ifndef HEADER_H\n" 2574 "# define HEADER_H\n" 2575 "code();\n" 2576 "#endif", 2577 Style)); 2578 // FIXME: The comment indent corrector in TokenAnnotator gets thrown off by 2579 // preprocessor indentation. 2580 EXPECT_EQ("#if 1\n" 2581 " // comment\n" 2582 "# define A 0\n" 2583 "// comment\n" 2584 "# define B 0\n" 2585 "#endif", 2586 format("#if 1\n" 2587 "// comment\n" 2588 "# define A 0\n" 2589 " // comment\n" 2590 "# define B 0\n" 2591 "#endif", 2592 Style)); 2593 // Test with tabs. 2594 Style.UseTab = FormatStyle::UT_Always; 2595 Style.IndentWidth = 8; 2596 Style.TabWidth = 8; 2597 verifyFormat("#ifdef _WIN32\n" 2598 "#\tdefine A 0\n" 2599 "#\tifdef VAR2\n" 2600 "#\t\tdefine B 1\n" 2601 "#\t\tinclude <someheader.h>\n" 2602 "#\t\tdefine MACRO \\\n" 2603 "\t\t\tsome_very_long_func_aaaaaaaaaa();\n" 2604 "#\tendif\n" 2605 "#else\n" 2606 "#\tdefine A 1\n" 2607 "#endif", 2608 Style); 2609 2610 // Regression test: Multiline-macro inside include guards. 2611 verifyFormat("#ifndef HEADER_H\n" 2612 "#define HEADER_H\n" 2613 "#define A() \\\n" 2614 " int i; \\\n" 2615 " int j;\n" 2616 "#endif // HEADER_H", 2617 getLLVMStyleWithColumns(20)); 2618 } 2619 2620 TEST_F(FormatTest, FormatHashIfNotAtStartOfLine) { 2621 verifyFormat("{\n { a #c; }\n}"); 2622 } 2623 2624 TEST_F(FormatTest, FormatUnbalancedStructuralElements) { 2625 EXPECT_EQ("#define A \\\n { \\\n {\nint i;", 2626 format("#define A { {\nint i;", getLLVMStyleWithColumns(11))); 2627 EXPECT_EQ("#define A \\\n } \\\n }\nint i;", 2628 format("#define A } }\nint i;", getLLVMStyleWithColumns(11))); 2629 } 2630 2631 TEST_F(FormatTest, EscapedNewlines) { 2632 EXPECT_EQ( 2633 "#define A \\\n int i; \\\n int j;", 2634 format("#define A \\\nint i;\\\n int j;", getLLVMStyleWithColumns(11))); 2635 EXPECT_EQ("#define A\n\nint i;", format("#define A \\\n\n int i;")); 2636 EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();")); 2637 EXPECT_EQ("/* \\ \\ \\\n */", format("\\\n/* \\ \\ \\\n */")); 2638 EXPECT_EQ("<a\n\\\\\n>", format("<a\n\\\\\n>")); 2639 2640 FormatStyle DontAlign = getLLVMStyle(); 2641 DontAlign.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign; 2642 DontAlign.MaxEmptyLinesToKeep = 3; 2643 // FIXME: can't use verifyFormat here because the newline before 2644 // "public:" is not inserted the first time it's reformatted 2645 EXPECT_EQ("#define A \\\n" 2646 " class Foo { \\\n" 2647 " void bar(); \\\n" 2648 "\\\n" 2649 "\\\n" 2650 "\\\n" 2651 " public: \\\n" 2652 " void baz(); \\\n" 2653 " };", 2654 format("#define A \\\n" 2655 " class Foo { \\\n" 2656 " void bar(); \\\n" 2657 "\\\n" 2658 "\\\n" 2659 "\\\n" 2660 " public: \\\n" 2661 " void baz(); \\\n" 2662 " };", DontAlign)); 2663 } 2664 2665 TEST_F(FormatTest, CalculateSpaceOnConsecutiveLinesInMacro) { 2666 verifyFormat("#define A \\\n" 2667 " int v( \\\n" 2668 " a); \\\n" 2669 " int i;", 2670 getLLVMStyleWithColumns(11)); 2671 } 2672 2673 TEST_F(FormatTest, MixingPreprocessorDirectivesAndNormalCode) { 2674 EXPECT_EQ( 2675 "#define ALooooooooooooooooooooooooooooooooooooooongMacro(" 2676 " \\\n" 2677 " aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n" 2678 "\n" 2679 "AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n" 2680 " aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n", 2681 format(" #define ALooooooooooooooooooooooooooooooooooooooongMacro(" 2682 "\\\n" 2683 "aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n" 2684 " \n" 2685 " AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n" 2686 " aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n")); 2687 } 2688 2689 TEST_F(FormatTest, LayoutStatementsAroundPreprocessorDirectives) { 2690 EXPECT_EQ("int\n" 2691 "#define A\n" 2692 " a;", 2693 format("int\n#define A\na;")); 2694 verifyFormat("functionCallTo(\n" 2695 " someOtherFunction(\n" 2696 " withSomeParameters, whichInSequence,\n" 2697 " areLongerThanALine(andAnotherCall,\n" 2698 "#define A B\n" 2699 " withMoreParamters,\n" 2700 " whichStronglyInfluenceTheLayout),\n" 2701 " andMoreParameters),\n" 2702 " trailing);", 2703 getLLVMStyleWithColumns(69)); 2704 verifyFormat("Foo::Foo()\n" 2705 "#ifdef BAR\n" 2706 " : baz(0)\n" 2707 "#endif\n" 2708 "{\n" 2709 "}"); 2710 verifyFormat("void f() {\n" 2711 " if (true)\n" 2712 "#ifdef A\n" 2713 " f(42);\n" 2714 " x();\n" 2715 "#else\n" 2716 " g();\n" 2717 " x();\n" 2718 "#endif\n" 2719 "}"); 2720 verifyFormat("void f(param1, param2,\n" 2721 " param3,\n" 2722 "#ifdef A\n" 2723 " param4(param5,\n" 2724 "#ifdef A1\n" 2725 " param6,\n" 2726 "#ifdef A2\n" 2727 " param7),\n" 2728 "#else\n" 2729 " param8),\n" 2730 " param9,\n" 2731 "#endif\n" 2732 " param10,\n" 2733 "#endif\n" 2734 " param11)\n" 2735 "#else\n" 2736 " param12)\n" 2737 "#endif\n" 2738 "{\n" 2739 " x();\n" 2740 "}", 2741 getLLVMStyleWithColumns(28)); 2742 verifyFormat("#if 1\n" 2743 "int i;"); 2744 verifyFormat("#if 1\n" 2745 "#endif\n" 2746 "#if 1\n" 2747 "#else\n" 2748 "#endif\n"); 2749 verifyFormat("DEBUG({\n" 2750 " return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 2751 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n" 2752 "});\n" 2753 "#if a\n" 2754 "#else\n" 2755 "#endif"); 2756 2757 verifyIncompleteFormat("void f(\n" 2758 "#if A\n" 2759 ");\n" 2760 "#else\n" 2761 "#endif"); 2762 } 2763 2764 TEST_F(FormatTest, GraciouslyHandleIncorrectPreprocessorConditions) { 2765 verifyFormat("#endif\n" 2766 "#if B"); 2767 } 2768 2769 TEST_F(FormatTest, FormatsJoinedLinesOnSubsequentRuns) { 2770 FormatStyle SingleLine = getLLVMStyle(); 2771 SingleLine.AllowShortIfStatementsOnASingleLine = true; 2772 verifyFormat("#if 0\n" 2773 "#elif 1\n" 2774 "#endif\n" 2775 "void foo() {\n" 2776 " if (test) foo2();\n" 2777 "}", 2778 SingleLine); 2779 } 2780 2781 TEST_F(FormatTest, LayoutBlockInsideParens) { 2782 verifyFormat("functionCall({ int i; });"); 2783 verifyFormat("functionCall({\n" 2784 " int i;\n" 2785 " int j;\n" 2786 "});"); 2787 verifyFormat("functionCall(\n" 2788 " {\n" 2789 " int i;\n" 2790 " int j;\n" 2791 " },\n" 2792 " aaaa, bbbb, cccc);"); 2793 verifyFormat("functionA(functionB({\n" 2794 " int i;\n" 2795 " int j;\n" 2796 " }),\n" 2797 " aaaa, bbbb, cccc);"); 2798 verifyFormat("functionCall(\n" 2799 " {\n" 2800 " int i;\n" 2801 " int j;\n" 2802 " },\n" 2803 " aaaa, bbbb, // comment\n" 2804 " cccc);"); 2805 verifyFormat("functionA(functionB({\n" 2806 " int i;\n" 2807 " int j;\n" 2808 " }),\n" 2809 " aaaa, bbbb, // comment\n" 2810 " cccc);"); 2811 verifyFormat("functionCall(aaaa, bbbb, { int i; });"); 2812 verifyFormat("functionCall(aaaa, bbbb, {\n" 2813 " int i;\n" 2814 " int j;\n" 2815 "});"); 2816 verifyFormat( 2817 "Aaa(\n" // FIXME: There shouldn't be a linebreak here. 2818 " {\n" 2819 " int i; // break\n" 2820 " },\n" 2821 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" 2822 " ccccccccccccccccc));"); 2823 verifyFormat("DEBUG({\n" 2824 " if (a)\n" 2825 " f();\n" 2826 "});"); 2827 } 2828 2829 TEST_F(FormatTest, LayoutBlockInsideStatement) { 2830 EXPECT_EQ("SOME_MACRO { int i; }\n" 2831 "int i;", 2832 format(" SOME_MACRO {int i;} int i;")); 2833 } 2834 2835 TEST_F(FormatTest, LayoutNestedBlocks) { 2836 verifyFormat("void AddOsStrings(unsigned bitmask) {\n" 2837 " struct s {\n" 2838 " int i;\n" 2839 " };\n" 2840 " s kBitsToOs[] = {{10}};\n" 2841 " for (int i = 0; i < 10; ++i)\n" 2842 " return;\n" 2843 "}"); 2844 verifyFormat("call(parameter, {\n" 2845 " something();\n" 2846 " // Comment using all columns.\n" 2847 " somethingelse();\n" 2848 "});", 2849 getLLVMStyleWithColumns(40)); 2850 verifyFormat("DEBUG( //\n" 2851 " { f(); }, a);"); 2852 verifyFormat("DEBUG( //\n" 2853 " {\n" 2854 " f(); //\n" 2855 " },\n" 2856 " a);"); 2857 2858 EXPECT_EQ("call(parameter, {\n" 2859 " something();\n" 2860 " // Comment too\n" 2861 " // looooooooooong.\n" 2862 " somethingElse();\n" 2863 "});", 2864 format("call(parameter, {\n" 2865 " something();\n" 2866 " // Comment too looooooooooong.\n" 2867 " somethingElse();\n" 2868 "});", 2869 getLLVMStyleWithColumns(29))); 2870 EXPECT_EQ("DEBUG({ int i; });", format("DEBUG({ int i; });")); 2871 EXPECT_EQ("DEBUG({ // comment\n" 2872 " int i;\n" 2873 "});", 2874 format("DEBUG({ // comment\n" 2875 "int i;\n" 2876 "});")); 2877 EXPECT_EQ("DEBUG({\n" 2878 " int i;\n" 2879 "\n" 2880 " // comment\n" 2881 " int j;\n" 2882 "});", 2883 format("DEBUG({\n" 2884 " int i;\n" 2885 "\n" 2886 " // comment\n" 2887 " int j;\n" 2888 "});")); 2889 2890 verifyFormat("DEBUG({\n" 2891 " if (a)\n" 2892 " return;\n" 2893 "});"); 2894 verifyGoogleFormat("DEBUG({\n" 2895 " if (a) return;\n" 2896 "});"); 2897 FormatStyle Style = getGoogleStyle(); 2898 Style.ColumnLimit = 45; 2899 verifyFormat("Debug(aaaaa,\n" 2900 " {\n" 2901 " if (aaaaaaaaaaaaaaaaaaaaaaaa) return;\n" 2902 " },\n" 2903 " a);", 2904 Style); 2905 2906 verifyFormat("SomeFunction({MACRO({ return output; }), b});"); 2907 2908 verifyNoCrash("^{v^{a}}"); 2909 } 2910 2911 TEST_F(FormatTest, FormatNestedBlocksInMacros) { 2912 EXPECT_EQ("#define MACRO() \\\n" 2913 " Debug(aaa, /* force line break */ \\\n" 2914 " { \\\n" 2915 " int i; \\\n" 2916 " int j; \\\n" 2917 " })", 2918 format("#define MACRO() Debug(aaa, /* force line break */ \\\n" 2919 " { int i; int j; })", 2920 getGoogleStyle())); 2921 2922 EXPECT_EQ("#define A \\\n" 2923 " [] { \\\n" 2924 " xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n" 2925 " xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); \\\n" 2926 " }", 2927 format("#define A [] { xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n" 2928 "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); }", 2929 getGoogleStyle())); 2930 } 2931 2932 TEST_F(FormatTest, PutEmptyBlocksIntoOneLine) { 2933 EXPECT_EQ("{}", format("{}")); 2934 verifyFormat("enum E {};"); 2935 verifyFormat("enum E {}"); 2936 } 2937 2938 TEST_F(FormatTest, FormatBeginBlockEndMacros) { 2939 FormatStyle Style = getLLVMStyle(); 2940 Style.MacroBlockBegin = "^[A-Z_]+_BEGIN$"; 2941 Style.MacroBlockEnd = "^[A-Z_]+_END$"; 2942 verifyFormat("FOO_BEGIN\n" 2943 " FOO_ENTRY\n" 2944 "FOO_END", Style); 2945 verifyFormat("FOO_BEGIN\n" 2946 " NESTED_FOO_BEGIN\n" 2947 " NESTED_FOO_ENTRY\n" 2948 " NESTED_FOO_END\n" 2949 "FOO_END", Style); 2950 verifyFormat("FOO_BEGIN(Foo, Bar)\n" 2951 " int x;\n" 2952 " x = 1;\n" 2953 "FOO_END(Baz)", Style); 2954 } 2955 2956 //===----------------------------------------------------------------------===// 2957 // Line break tests. 2958 //===----------------------------------------------------------------------===// 2959 2960 TEST_F(FormatTest, PreventConfusingIndents) { 2961 verifyFormat( 2962 "void f() {\n" 2963 " SomeLongMethodName(SomeReallyLongMethod(CallOtherReallyLongMethod(\n" 2964 " parameter, parameter, parameter)),\n" 2965 " SecondLongCall(parameter));\n" 2966 "}"); 2967 verifyFormat( 2968 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 2969 " aaaaaaaaaaaaaaaaaaaaaaaa(\n" 2970 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 2971 " aaaaaaaaaaaaaaaaaaaaaaaa);"); 2972 verifyFormat( 2973 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2974 " [aaaaaaaaaaaaaaaaaaaaaaaa\n" 2975 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n" 2976 " [aaaaaaaaaaaaaaaaaaaaaaaa]];"); 2977 verifyFormat( 2978 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n" 2979 " aaaaaaaaaaaaaaaaaaaaaaaa<\n" 2980 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>,\n" 2981 " aaaaaaaaaaaaaaaaaaaaaaaa>;"); 2982 verifyFormat("int a = bbbb && ccc &&\n" 2983 " fffff(\n" 2984 "#define A Just forcing a new line\n" 2985 " ddd);"); 2986 } 2987 2988 TEST_F(FormatTest, LineBreakingInBinaryExpressions) { 2989 verifyFormat( 2990 "bool aaaaaaa =\n" 2991 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() ||\n" 2992 " bbbbbbbb();"); 2993 verifyFormat( 2994 "bool aaaaaaa =\n" 2995 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() or\n" 2996 " bbbbbbbb();"); 2997 2998 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n" 2999 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb &&\n" 3000 " ccccccccc == ddddddddddd;"); 3001 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n" 3002 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb and\n" 3003 " ccccccccc == ddddddddddd;"); 3004 verifyFormat( 3005 "bool aaaaaaaaaaaaaaaaaaaaa =\n" 3006 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa not_eq bbbbbbbbbbbbbbbbbb and\n" 3007 " ccccccccc == ddddddddddd;"); 3008 3009 verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n" 3010 " aaaaaa) &&\n" 3011 " bbbbbb && cccccc;"); 3012 verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n" 3013 " aaaaaa) >>\n" 3014 " bbbbbb;"); 3015 verifyFormat("aa = Whitespaces.addUntouchableComment(\n" 3016 " SourceMgr.getSpellingColumnNumber(\n" 3017 " TheLine.Last->FormatTok.Tok.getLocation()) -\n" 3018 " 1);"); 3019 3020 verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 3021 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaaaaaaa\n" 3022 " cccccc) {\n}"); 3023 verifyFormat("if constexpr ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 3024 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaa\n" 3025 " cccccc) {\n}"); 3026 verifyFormat("b = a &&\n" 3027 " // Comment\n" 3028 " b.c && d;"); 3029 3030 // If the LHS of a comparison is not a binary expression itself, the 3031 // additional linebreak confuses many people. 3032 verifyFormat( 3033 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3034 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) > 5) {\n" 3035 "}"); 3036 verifyFormat( 3037 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3038 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n" 3039 "}"); 3040 verifyFormat( 3041 "if (aaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaa(\n" 3042 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n" 3043 "}"); 3044 // Even explicit parentheses stress the precedence enough to make the 3045 // additional break unnecessary. 3046 verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3047 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n" 3048 "}"); 3049 // This cases is borderline, but with the indentation it is still readable. 3050 verifyFormat( 3051 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3052 " aaaaaaaaaaaaaaa) > aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3053 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 3054 "}", 3055 getLLVMStyleWithColumns(75)); 3056 3057 // If the LHS is a binary expression, we should still use the additional break 3058 // as otherwise the formatting hides the operator precedence. 3059 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3060 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 3061 " 5) {\n" 3062 "}"); 3063 3064 FormatStyle OnePerLine = getLLVMStyle(); 3065 OnePerLine.BinPackParameters = false; 3066 verifyFormat( 3067 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 3068 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 3069 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}", 3070 OnePerLine); 3071 3072 verifyFormat("int i = someFunction(aaaaaaa, 0)\n" 3073 " .aaa(aaaaaaaaaaaaa) *\n" 3074 " aaaaaaa +\n" 3075 " aaaaaaa;", 3076 getLLVMStyleWithColumns(40)); 3077 } 3078 3079 TEST_F(FormatTest, ExpressionIndentation) { 3080 verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3081 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3082 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 3083 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 3084 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb +\n" 3085 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb &&\n" 3086 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 3087 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >\n" 3088 " ccccccccccccccccccccccccccccccccccccccccc;"); 3089 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 3090 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3091 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 3092 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); 3093 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3094 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 3095 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 3096 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); 3097 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 3098 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 3099 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3100 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); 3101 verifyFormat("if () {\n" 3102 "} else if (aaaaa && bbbbb > // break\n" 3103 " ccccc) {\n" 3104 "}"); 3105 verifyFormat("if () {\n" 3106 "} else if (aaaaa &&\n" 3107 " bbbbb > // break\n" 3108 " ccccc &&\n" 3109 " ddddd) {\n" 3110 "}"); 3111 3112 // Presence of a trailing comment used to change indentation of b. 3113 verifyFormat("return aaaaaaaaaaaaaaaaaaa +\n" 3114 " b;\n" 3115 "return aaaaaaaaaaaaaaaaaaa +\n" 3116 " b; //", 3117 getLLVMStyleWithColumns(30)); 3118 } 3119 3120 TEST_F(FormatTest, ExpressionIndentationBreakingBeforeOperators) { 3121 // Not sure what the best system is here. Like this, the LHS can be found 3122 // immediately above an operator (everything with the same or a higher 3123 // indent). The RHS is aligned right of the operator and so compasses 3124 // everything until something with the same indent as the operator is found. 3125 // FIXME: Is this a good system? 3126 FormatStyle Style = getLLVMStyle(); 3127 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 3128 verifyFormat( 3129 "bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3130 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3131 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3132 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3133 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 3134 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 3135 " && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3136 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3137 " > ccccccccccccccccccccccccccccccccccccccccc;", 3138 Style); 3139 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3140 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3141 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3142 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 3143 Style); 3144 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3145 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3146 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3147 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 3148 Style); 3149 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3150 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3151 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3152 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 3153 Style); 3154 verifyFormat("if () {\n" 3155 "} else if (aaaaa\n" 3156 " && bbbbb // break\n" 3157 " > ccccc) {\n" 3158 "}", 3159 Style); 3160 verifyFormat("return (a)\n" 3161 " // comment\n" 3162 " + b;", 3163 Style); 3164 verifyFormat( 3165 "int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3166 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 3167 " + cc;", 3168 Style); 3169 3170 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3171 " = aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 3172 Style); 3173 3174 // Forced by comments. 3175 verifyFormat( 3176 "unsigned ContentSize =\n" 3177 " sizeof(int16_t) // DWARF ARange version number\n" 3178 " + sizeof(int32_t) // Offset of CU in the .debug_info section\n" 3179 " + sizeof(int8_t) // Pointer Size (in bytes)\n" 3180 " + sizeof(int8_t); // Segment Size (in bytes)"); 3181 3182 verifyFormat("return boost::fusion::at_c<0>(iiii).second\n" 3183 " == boost::fusion::at_c<1>(iiii).second;", 3184 Style); 3185 3186 Style.ColumnLimit = 60; 3187 verifyFormat("zzzzzzzzzz\n" 3188 " = bbbbbbbbbbbbbbbbb\n" 3189 " >> aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa);", 3190 Style); 3191 } 3192 3193 TEST_F(FormatTest, EnforcedOperatorWraps) { 3194 // Here we'd like to wrap after the || operators, but a comment is forcing an 3195 // earlier wrap. 3196 verifyFormat("bool x = aaaaa //\n" 3197 " || bbbbb\n" 3198 " //\n" 3199 " || cccc;"); 3200 } 3201 3202 TEST_F(FormatTest, NoOperandAlignment) { 3203 FormatStyle Style = getLLVMStyle(); 3204 Style.AlignOperands = false; 3205 verifyFormat("aaaaaaaaaaaaaa(aaaaaaaaaaaa,\n" 3206 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3207 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 3208 Style); 3209 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment; 3210 verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3211 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3212 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3213 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3214 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 3215 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 3216 " && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3217 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3218 " > ccccccccccccccccccccccccccccccccccccccccc;", 3219 Style); 3220 3221 verifyFormat("int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3222 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 3223 " + cc;", 3224 Style); 3225 verifyFormat("int a = aa\n" 3226 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 3227 " * cccccccccccccccccccccccccccccccccccc;\n", 3228 Style); 3229 3230 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 3231 verifyFormat("return (a > b\n" 3232 " // comment1\n" 3233 " // comment2\n" 3234 " || c);", 3235 Style); 3236 } 3237 3238 TEST_F(FormatTest, BreakingBeforeNonAssigmentOperators) { 3239 FormatStyle Style = getLLVMStyle(); 3240 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment; 3241 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 3242 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3243 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;", 3244 Style); 3245 } 3246 3247 TEST_F(FormatTest, AllowBinPackingInsideArguments) { 3248 FormatStyle Style = getLLVMStyle(); 3249 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment; 3250 Style.BinPackArguments = false; 3251 Style.ColumnLimit = 40; 3252 verifyFormat("void test() {\n" 3253 " someFunction(\n" 3254 " this + argument + is + quite\n" 3255 " + long + so + it + gets + wrapped\n" 3256 " + but + remains + bin - packed);\n" 3257 "}", 3258 Style); 3259 verifyFormat("void test() {\n" 3260 " someFunction(arg1,\n" 3261 " this + argument + is\n" 3262 " + quite + long + so\n" 3263 " + it + gets + wrapped\n" 3264 " + but + remains + bin\n" 3265 " - packed,\n" 3266 " arg3);\n" 3267 "}", 3268 Style); 3269 verifyFormat("void test() {\n" 3270 " someFunction(\n" 3271 " arg1,\n" 3272 " this + argument + has\n" 3273 " + anotherFunc(nested,\n" 3274 " calls + whose\n" 3275 " + arguments\n" 3276 " + are + also\n" 3277 " + wrapped,\n" 3278 " in + addition)\n" 3279 " + to + being + bin - packed,\n" 3280 " arg3);\n" 3281 "}", 3282 Style); 3283 3284 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 3285 verifyFormat("void test() {\n" 3286 " someFunction(\n" 3287 " arg1,\n" 3288 " this + argument + has +\n" 3289 " anotherFunc(nested,\n" 3290 " calls + whose +\n" 3291 " arguments +\n" 3292 " are + also +\n" 3293 " wrapped,\n" 3294 " in + addition) +\n" 3295 " to + being + bin - packed,\n" 3296 " arg3);\n" 3297 "}", 3298 Style); 3299 } 3300 3301 TEST_F(FormatTest, ConstructorInitializers) { 3302 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}"); 3303 verifyFormat("Constructor() : Inttializer(FitsOnTheLine) {}", 3304 getLLVMStyleWithColumns(45)); 3305 verifyFormat("Constructor()\n" 3306 " : Inttializer(FitsOnTheLine) {}", 3307 getLLVMStyleWithColumns(44)); 3308 verifyFormat("Constructor()\n" 3309 " : Inttializer(FitsOnTheLine) {}", 3310 getLLVMStyleWithColumns(43)); 3311 3312 verifyFormat("template <typename T>\n" 3313 "Constructor() : Initializer(FitsOnTheLine) {}", 3314 getLLVMStyleWithColumns(45)); 3315 3316 verifyFormat( 3317 "SomeClass::Constructor()\n" 3318 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}"); 3319 3320 verifyFormat( 3321 "SomeClass::Constructor()\n" 3322 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 3323 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}"); 3324 verifyFormat( 3325 "SomeClass::Constructor()\n" 3326 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 3327 " aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}"); 3328 verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 3329 " aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 3330 " : aaaaaaaaaa(aaaaaa) {}"); 3331 3332 verifyFormat("Constructor()\n" 3333 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 3334 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 3335 " aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 3336 " aaaaaaaaaaaaaaaaaaaaaaa() {}"); 3337 3338 verifyFormat("Constructor()\n" 3339 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3340 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); 3341 3342 verifyFormat("Constructor(int Parameter = 0)\n" 3343 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n" 3344 " aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}"); 3345 verifyFormat("Constructor()\n" 3346 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n" 3347 "}", 3348 getLLVMStyleWithColumns(60)); 3349 verifyFormat("Constructor()\n" 3350 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3351 " aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}"); 3352 3353 // Here a line could be saved by splitting the second initializer onto two 3354 // lines, but that is not desirable. 3355 verifyFormat("Constructor()\n" 3356 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n" 3357 " aaaaaaaaaaa(aaaaaaaaaaa),\n" 3358 " aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); 3359 3360 FormatStyle OnePerLine = getLLVMStyle(); 3361 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 3362 OnePerLine.AllowAllParametersOfDeclarationOnNextLine = false; 3363 verifyFormat("SomeClass::Constructor()\n" 3364 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 3365 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 3366 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 3367 OnePerLine); 3368 verifyFormat("SomeClass::Constructor()\n" 3369 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n" 3370 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 3371 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 3372 OnePerLine); 3373 verifyFormat("MyClass::MyClass(int var)\n" 3374 " : some_var_(var), // 4 space indent\n" 3375 " some_other_var_(var + 1) { // lined up\n" 3376 "}", 3377 OnePerLine); 3378 verifyFormat("Constructor()\n" 3379 " : aaaaa(aaaaaa),\n" 3380 " aaaaa(aaaaaa),\n" 3381 " aaaaa(aaaaaa),\n" 3382 " aaaaa(aaaaaa),\n" 3383 " aaaaa(aaaaaa) {}", 3384 OnePerLine); 3385 verifyFormat("Constructor()\n" 3386 " : aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n" 3387 " aaaaaaaaaaaaaaaaaaaaaa) {}", 3388 OnePerLine); 3389 OnePerLine.BinPackParameters = false; 3390 verifyFormat( 3391 "Constructor()\n" 3392 " : aaaaaaaaaaaaaaaaaaaaaaaa(\n" 3393 " aaaaaaaaaaa().aaa(),\n" 3394 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 3395 OnePerLine); 3396 OnePerLine.ColumnLimit = 60; 3397 verifyFormat("Constructor()\n" 3398 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 3399 " bbbbbbbbbbbbbbbbbbbbbbbb(b) {}", 3400 OnePerLine); 3401 3402 EXPECT_EQ("Constructor()\n" 3403 " : // Comment forcing unwanted break.\n" 3404 " aaaa(aaaa) {}", 3405 format("Constructor() :\n" 3406 " // Comment forcing unwanted break.\n" 3407 " aaaa(aaaa) {}")); 3408 } 3409 3410 TEST_F(FormatTest, BreakConstructorInitializersAfterColon) { 3411 FormatStyle Style = getLLVMStyle(); 3412 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 3413 3414 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}"); 3415 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}", 3416 getStyleWithColumns(Style, 45)); 3417 verifyFormat("Constructor() :\n" 3418 " Initializer(FitsOnTheLine) {}", 3419 getStyleWithColumns(Style, 44)); 3420 verifyFormat("Constructor() :\n" 3421 " Initializer(FitsOnTheLine) {}", 3422 getStyleWithColumns(Style, 43)); 3423 3424 verifyFormat("template <typename T>\n" 3425 "Constructor() : Initializer(FitsOnTheLine) {}", 3426 getStyleWithColumns(Style, 50)); 3427 3428 verifyFormat( 3429 "SomeClass::Constructor() :\n" 3430 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}", 3431 Style); 3432 3433 verifyFormat( 3434 "SomeClass::Constructor() :\n" 3435 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 3436 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 3437 Style); 3438 verifyFormat( 3439 "SomeClass::Constructor() :\n" 3440 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 3441 " aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}", 3442 Style); 3443 verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 3444 " aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n" 3445 " aaaaaaaaaa(aaaaaa) {}", 3446 Style); 3447 3448 verifyFormat("Constructor() :\n" 3449 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 3450 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 3451 " aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 3452 " aaaaaaaaaaaaaaaaaaaaaaa() {}", 3453 Style); 3454 3455 verifyFormat("Constructor() :\n" 3456 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3457 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 3458 Style); 3459 3460 verifyFormat("Constructor(int Parameter = 0) :\n" 3461 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n" 3462 " aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}", 3463 Style); 3464 verifyFormat("Constructor() :\n" 3465 " aaaaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n" 3466 "}", 3467 getStyleWithColumns(Style, 60)); 3468 verifyFormat("Constructor() :\n" 3469 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3470 " aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}", 3471 Style); 3472 3473 // Here a line could be saved by splitting the second initializer onto two 3474 // lines, but that is not desirable. 3475 verifyFormat("Constructor() :\n" 3476 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n" 3477 " aaaaaaaaaaa(aaaaaaaaaaa),\n" 3478 " aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 3479 Style); 3480 3481 FormatStyle OnePerLine = Style; 3482 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 3483 OnePerLine.AllowAllParametersOfDeclarationOnNextLine = false; 3484 verifyFormat("SomeClass::Constructor() :\n" 3485 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 3486 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 3487 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 3488 OnePerLine); 3489 verifyFormat("SomeClass::Constructor() :\n" 3490 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n" 3491 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 3492 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 3493 OnePerLine); 3494 verifyFormat("MyClass::MyClass(int var) :\n" 3495 " some_var_(var), // 4 space indent\n" 3496 " some_other_var_(var + 1) { // lined up\n" 3497 "}", 3498 OnePerLine); 3499 verifyFormat("Constructor() :\n" 3500 " aaaaa(aaaaaa),\n" 3501 " aaaaa(aaaaaa),\n" 3502 " aaaaa(aaaaaa),\n" 3503 " aaaaa(aaaaaa),\n" 3504 " aaaaa(aaaaaa) {}", 3505 OnePerLine); 3506 verifyFormat("Constructor() :\n" 3507 " aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n" 3508 " aaaaaaaaaaaaaaaaaaaaaa) {}", 3509 OnePerLine); 3510 OnePerLine.BinPackParameters = false; 3511 verifyFormat( 3512 "Constructor() :\n" 3513 " aaaaaaaaaaaaaaaaaaaaaaaa(\n" 3514 " aaaaaaaaaaa().aaa(),\n" 3515 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 3516 OnePerLine); 3517 OnePerLine.ColumnLimit = 60; 3518 verifyFormat("Constructor() :\n" 3519 " aaaaaaaaaaaaaaaaaaaa(a),\n" 3520 " bbbbbbbbbbbbbbbbbbbbbbbb(b) {}", 3521 OnePerLine); 3522 3523 EXPECT_EQ("Constructor() :\n" 3524 " // Comment forcing unwanted break.\n" 3525 " aaaa(aaaa) {}", 3526 format("Constructor() :\n" 3527 " // Comment forcing unwanted break.\n" 3528 " aaaa(aaaa) {}", 3529 Style)); 3530 3531 Style.ColumnLimit = 0; 3532 verifyFormat("SomeClass::Constructor() :\n" 3533 " a(a) {}", 3534 Style); 3535 verifyFormat("SomeClass::Constructor() noexcept :\n" 3536 " a(a) {}", 3537 Style); 3538 verifyFormat("SomeClass::Constructor() :\n" 3539 " a(a), b(b), c(c) {}", 3540 Style); 3541 verifyFormat("SomeClass::Constructor() :\n" 3542 " a(a) {\n" 3543 " foo();\n" 3544 " bar();\n" 3545 "}", 3546 Style); 3547 3548 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 3549 verifyFormat("SomeClass::Constructor() :\n" 3550 " a(a), b(b), c(c) {\n" 3551 "}", 3552 Style); 3553 verifyFormat("SomeClass::Constructor() :\n" 3554 " a(a) {\n" 3555 "}", 3556 Style); 3557 3558 Style.ColumnLimit = 80; 3559 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 3560 Style.ConstructorInitializerIndentWidth = 2; 3561 verifyFormat("SomeClass::Constructor() : a(a), b(b), c(c) {}", 3562 Style); 3563 verifyFormat("SomeClass::Constructor() :\n" 3564 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 3565 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {}", 3566 Style); 3567 } 3568 3569 #ifndef EXPENSIVE_CHECKS 3570 // Expensive checks enables libstdc++ checking which includes validating the 3571 // state of ranges used in std::priority_queue - this blows out the 3572 // runtime/scalability of the function and makes this test unacceptably slow. 3573 TEST_F(FormatTest, MemoizationTests) { 3574 // This breaks if the memoization lookup does not take \c Indent and 3575 // \c LastSpace into account. 3576 verifyFormat( 3577 "extern CFRunLoopTimerRef\n" 3578 "CFRunLoopTimerCreate(CFAllocatorRef allocato, CFAbsoluteTime fireDate,\n" 3579 " CFTimeInterval interval, CFOptionFlags flags,\n" 3580 " CFIndex order, CFRunLoopTimerCallBack callout,\n" 3581 " CFRunLoopTimerContext *context) {}"); 3582 3583 // Deep nesting somewhat works around our memoization. 3584 verifyFormat( 3585 "aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 3586 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 3587 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 3588 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 3589 " aaaaa())))))))))))))))))))))))))))))))))))))));", 3590 getLLVMStyleWithColumns(65)); 3591 verifyFormat( 3592 "aaaaa(\n" 3593 " aaaaa,\n" 3594 " aaaaa(\n" 3595 " aaaaa,\n" 3596 " aaaaa(\n" 3597 " aaaaa,\n" 3598 " aaaaa(\n" 3599 " aaaaa,\n" 3600 " aaaaa(\n" 3601 " aaaaa,\n" 3602 " aaaaa(\n" 3603 " aaaaa,\n" 3604 " aaaaa(\n" 3605 " aaaaa,\n" 3606 " aaaaa(\n" 3607 " aaaaa,\n" 3608 " aaaaa(\n" 3609 " aaaaa,\n" 3610 " aaaaa(\n" 3611 " aaaaa,\n" 3612 " aaaaa(\n" 3613 " aaaaa,\n" 3614 " aaaaa(\n" 3615 " aaaaa,\n" 3616 " aaaaa))))))))))));", 3617 getLLVMStyleWithColumns(65)); 3618 verifyFormat( 3619 "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" 3620 " a),\n" 3621 " a),\n" 3622 " a),\n" 3623 " a),\n" 3624 " a),\n" 3625 " a),\n" 3626 " a),\n" 3627 " a),\n" 3628 " a),\n" 3629 " a),\n" 3630 " a),\n" 3631 " a),\n" 3632 " a),\n" 3633 " a),\n" 3634 " a),\n" 3635 " a),\n" 3636 " a)", 3637 getLLVMStyleWithColumns(65)); 3638 3639 // This test takes VERY long when memoization is broken. 3640 FormatStyle OnePerLine = getLLVMStyle(); 3641 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 3642 OnePerLine.BinPackParameters = false; 3643 std::string input = "Constructor()\n" 3644 " : aaaa(a,\n"; 3645 for (unsigned i = 0, e = 80; i != e; ++i) { 3646 input += " a,\n"; 3647 } 3648 input += " a) {}"; 3649 verifyFormat(input, OnePerLine); 3650 } 3651 #endif 3652 3653 TEST_F(FormatTest, BreaksAsHighAsPossible) { 3654 verifyFormat( 3655 "void f() {\n" 3656 " if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaaaaaaaa) ||\n" 3657 " (bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb && bbbbbbbbbbbbbbbbbbbbbbbbbb))\n" 3658 " f();\n" 3659 "}"); 3660 verifyFormat("if (Intervals[i].getRange().getFirst() <\n" 3661 " Intervals[i - 1].getRange().getLast()) {\n}"); 3662 } 3663 3664 TEST_F(FormatTest, BreaksFunctionDeclarations) { 3665 // Principially, we break function declarations in a certain order: 3666 // 1) break amongst arguments. 3667 verifyFormat("Aaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccc,\n" 3668 " Cccccccccccccc cccccccccccccc);"); 3669 verifyFormat("template <class TemplateIt>\n" 3670 "SomeReturnType SomeFunction(TemplateIt begin, TemplateIt end,\n" 3671 " TemplateIt *stop) {}"); 3672 3673 // 2) break after return type. 3674 verifyFormat( 3675 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3676 "bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccccccccccccccc);", 3677 getGoogleStyle()); 3678 3679 // 3) break after (. 3680 verifyFormat( 3681 "Aaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbb(\n" 3682 " Cccccccccccccccccccccccccccccc cccccccccccccccccccccccccccccccc);", 3683 getGoogleStyle()); 3684 3685 // 4) break before after nested name specifiers. 3686 verifyFormat( 3687 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3688 "SomeClasssssssssssssssssssssssssssssssssssssss::\n" 3689 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc);", 3690 getGoogleStyle()); 3691 3692 // However, there are exceptions, if a sufficient amount of lines can be 3693 // saved. 3694 // FIXME: The precise cut-offs wrt. the number of saved lines might need some 3695 // more adjusting. 3696 verifyFormat("Aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n" 3697 " Cccccccccccccc cccccccccc,\n" 3698 " Cccccccccccccc cccccccccc,\n" 3699 " Cccccccccccccc cccccccccc,\n" 3700 " Cccccccccccccc cccccccccc);"); 3701 verifyFormat( 3702 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3703 "bbbbbbbbbbb(Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 3704 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 3705 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);", 3706 getGoogleStyle()); 3707 verifyFormat( 3708 "Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n" 3709 " Cccccccccccccc cccccccccc,\n" 3710 " Cccccccccccccc cccccccccc,\n" 3711 " Cccccccccccccc cccccccccc,\n" 3712 " Cccccccccccccc cccccccccc,\n" 3713 " Cccccccccccccc cccccccccc,\n" 3714 " Cccccccccccccc cccccccccc);"); 3715 verifyFormat("Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 3716 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 3717 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 3718 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 3719 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);"); 3720 3721 // Break after multi-line parameters. 3722 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3723 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3724 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 3725 " bbbb bbbb);"); 3726 verifyFormat("void SomeLoooooooooooongFunction(\n" 3727 " std::unique_ptr<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n" 3728 " aaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 3729 " int bbbbbbbbbbbbb);"); 3730 3731 // Treat overloaded operators like other functions. 3732 verifyFormat("SomeLoooooooooooooooooooooooooogType\n" 3733 "operator>(const SomeLoooooooooooooooooooooooooogType &other);"); 3734 verifyFormat("SomeLoooooooooooooooooooooooooogType\n" 3735 "operator>>(const SomeLooooooooooooooooooooooooogType &other);"); 3736 verifyFormat("SomeLoooooooooooooooooooooooooogType\n" 3737 "operator<<(const SomeLooooooooooooooooooooooooogType &other);"); 3738 verifyGoogleFormat( 3739 "SomeLoooooooooooooooooooooooooooooogType operator>>(\n" 3740 " const SomeLooooooooogType &a, const SomeLooooooooogType &b);"); 3741 verifyGoogleFormat( 3742 "SomeLoooooooooooooooooooooooooooooogType operator<<(\n" 3743 " const SomeLooooooooogType &a, const SomeLooooooooogType &b);"); 3744 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3745 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = 1);"); 3746 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa\n" 3747 "aaaaaaaaaaaaaaaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaa = 1);"); 3748 verifyGoogleFormat( 3749 "typename aaaaaaaaaa<aaaaaa>::aaaaaaaaaaa\n" 3750 "aaaaaaaaaa<aaaaaa>::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3751 " bool *aaaaaaaaaaaaaaaaaa, bool *aa) {}"); 3752 verifyGoogleFormat( 3753 "template <typename T>\n" 3754 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3755 "aaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaaaaa(\n" 3756 " aaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaa);"); 3757 3758 FormatStyle Style = getLLVMStyle(); 3759 Style.PointerAlignment = FormatStyle::PAS_Left; 3760 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3761 " aaaaaaaaaaaaaaaaaaaaaaaaa* const aaaaaaaaaaaa) {}", 3762 Style); 3763 verifyFormat("void aaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*\n" 3764 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 3765 Style); 3766 } 3767 3768 TEST_F(FormatTest, TrailingReturnType) { 3769 verifyFormat("auto foo() -> int;\n"); 3770 verifyFormat("struct S {\n" 3771 " auto bar() const -> int;\n" 3772 "};"); 3773 verifyFormat("template <size_t Order, typename T>\n" 3774 "auto load_img(const std::string &filename)\n" 3775 " -> alias::tensor<Order, T, mem::tag::cpu> {}"); 3776 verifyFormat("auto SomeFunction(A aaaaaaaaaaaaaaaaaaaaa) const\n" 3777 " -> decltype(f(aaaaaaaaaaaaaaaaaaaaa)) {}"); 3778 verifyFormat("auto doSomething(Aaaaaa *aaaaaa) -> decltype(aaaaaa->f()) {}"); 3779 verifyFormat("template <typename T>\n" 3780 "auto aaaaaaaaaaaaaaaaaaaaaa(T t)\n" 3781 " -> decltype(eaaaaaaaaaaaaaaa<T>(t.a).aaaaaaaa());"); 3782 3783 // Not trailing return types. 3784 verifyFormat("void f() { auto a = b->c(); }"); 3785 } 3786 3787 TEST_F(FormatTest, BreaksFunctionDeclarationsWithTrailingTokens) { 3788 // Avoid breaking before trailing 'const' or other trailing annotations, if 3789 // they are not function-like. 3790 FormatStyle Style = getGoogleStyle(); 3791 Style.ColumnLimit = 47; 3792 verifyFormat("void someLongFunction(\n" 3793 " int someLoooooooooooooongParameter) const {\n}", 3794 getLLVMStyleWithColumns(47)); 3795 verifyFormat("LoooooongReturnType\n" 3796 "someLoooooooongFunction() const {}", 3797 getLLVMStyleWithColumns(47)); 3798 verifyFormat("LoooooongReturnType someLoooooooongFunction()\n" 3799 " const {}", 3800 Style); 3801 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n" 3802 " aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE;"); 3803 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n" 3804 " aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE FINAL;"); 3805 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n" 3806 " aaaaa aaaaaaaaaaaaaaaaaaaa) override final;"); 3807 verifyFormat("virtual void aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa,\n" 3808 " aaaaaaaaaaa aaaaa) const override;"); 3809 verifyGoogleFormat( 3810 "virtual void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 3811 " const override;"); 3812 3813 // Even if the first parameter has to be wrapped. 3814 verifyFormat("void someLongFunction(\n" 3815 " int someLongParameter) const {}", 3816 getLLVMStyleWithColumns(46)); 3817 verifyFormat("void someLongFunction(\n" 3818 " int someLongParameter) const {}", 3819 Style); 3820 verifyFormat("void someLongFunction(\n" 3821 " int someLongParameter) override {}", 3822 Style); 3823 verifyFormat("void someLongFunction(\n" 3824 " int someLongParameter) OVERRIDE {}", 3825 Style); 3826 verifyFormat("void someLongFunction(\n" 3827 " int someLongParameter) final {}", 3828 Style); 3829 verifyFormat("void someLongFunction(\n" 3830 " int someLongParameter) FINAL {}", 3831 Style); 3832 verifyFormat("void someLongFunction(\n" 3833 " int parameter) const override {}", 3834 Style); 3835 3836 Style.BreakBeforeBraces = FormatStyle::BS_Allman; 3837 verifyFormat("void someLongFunction(\n" 3838 " int someLongParameter) const\n" 3839 "{\n" 3840 "}", 3841 Style); 3842 3843 // Unless these are unknown annotations. 3844 verifyFormat("void SomeFunction(aaaaaaaaaa aaaaaaaaaaaaaaa,\n" 3845 " aaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 3846 " LONG_AND_UGLY_ANNOTATION;"); 3847 3848 // Breaking before function-like trailing annotations is fine to keep them 3849 // close to their arguments. 3850 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 3851 " LOCKS_EXCLUDED(aaaaaaaaaaaaa);"); 3852 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n" 3853 " LOCKS_EXCLUDED(aaaaaaaaaaaaa);"); 3854 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n" 3855 " LOCKS_EXCLUDED(aaaaaaaaaaaaa) {}"); 3856 verifyGoogleFormat("void aaaaaaaaaaaaaa(aaaaaaaa aaa) override\n" 3857 " AAAAAAAAAAAAAAAAAAAAAAAA(aaaaaaaaaaaaaaa);"); 3858 verifyFormat("SomeFunction([](int i) LOCKS_EXCLUDED(a) {});"); 3859 3860 verifyFormat( 3861 "void aaaaaaaaaaaaaaaaaa()\n" 3862 " __attribute__((aaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaa,\n" 3863 " aaaaaaaaaaaaaaaaaaaaaaaaa));"); 3864 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3865 " __attribute__((unused));"); 3866 verifyGoogleFormat( 3867 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3868 " GUARDED_BY(aaaaaaaaaaaa);"); 3869 verifyGoogleFormat( 3870 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3871 " GUARDED_BY(aaaaaaaaaaaa);"); 3872 verifyGoogleFormat( 3873 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n" 3874 " aaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 3875 verifyGoogleFormat( 3876 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n" 3877 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 3878 } 3879 3880 TEST_F(FormatTest, FunctionAnnotations) { 3881 verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n" 3882 "int OldFunction(const string ¶meter) {}"); 3883 verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n" 3884 "string OldFunction(const string ¶meter) {}"); 3885 verifyFormat("template <typename T>\n" 3886 "DEPRECATED(\"Use NewClass::NewFunction instead.\")\n" 3887 "string OldFunction(const string ¶meter) {}"); 3888 3889 // Not function annotations. 3890 verifyFormat("ASSERT(\"aaaaa\") << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3891 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"); 3892 verifyFormat("TEST_F(ThisIsATestFixtureeeeeeeeeeeee,\n" 3893 " ThisIsATestWithAReallyReallyReallyReallyLongName) {}"); 3894 verifyFormat("MACRO(abc).function() // wrap\n" 3895 " << abc;"); 3896 verifyFormat("MACRO(abc)->function() // wrap\n" 3897 " << abc;"); 3898 verifyFormat("MACRO(abc)::function() // wrap\n" 3899 " << abc;"); 3900 } 3901 3902 TEST_F(FormatTest, BreaksDesireably) { 3903 verifyFormat("if (aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n" 3904 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n" 3905 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa)) {\n}"); 3906 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3907 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n" 3908 "}"); 3909 3910 verifyFormat( 3911 "aaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 3912 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); 3913 3914 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3915 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3916 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 3917 3918 verifyFormat( 3919 "aaaaaaaa(aaaaaaaaaaaaa,\n" 3920 " aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3921 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n" 3922 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3923 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));"); 3924 3925 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 3926 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 3927 3928 verifyFormat( 3929 "void f() {\n" 3930 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&\n" 3931 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 3932 "}"); 3933 verifyFormat( 3934 "aaaaaa(new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3935 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 3936 verifyFormat( 3937 "aaaaaa(aaa, new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3938 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 3939 verifyFormat( 3940 "aaaaaa(aaa,\n" 3941 " new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3942 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 3943 " aaaa);"); 3944 verifyFormat("aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3945 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 3946 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 3947 3948 // Indent consistently independent of call expression and unary operator. 3949 verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 3950 " dddddddddddddddddddddddddddddd));"); 3951 verifyFormat("aaaaaaaaaaa(!bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 3952 " dddddddddddddddddddddddddddddd));"); 3953 verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbb.ccccccccccccccccc(\n" 3954 " dddddddddddddddddddddddddddddd));"); 3955 3956 // This test case breaks on an incorrect memoization, i.e. an optimization not 3957 // taking into account the StopAt value. 3958 verifyFormat( 3959 "return aaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 3960 " aaaaaaaaaaa(aaaaaaaaa) || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 3961 " aaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 3962 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 3963 3964 verifyFormat("{\n {\n {\n" 3965 " Annotation.SpaceRequiredBefore =\n" 3966 " Line.Tokens[i - 1].Tok.isNot(tok::l_paren) &&\n" 3967 " Line.Tokens[i - 1].Tok.isNot(tok::l_square);\n" 3968 " }\n }\n}"); 3969 3970 // Break on an outer level if there was a break on an inner level. 3971 EXPECT_EQ("f(g(h(a, // comment\n" 3972 " b, c),\n" 3973 " d, e),\n" 3974 " x, y);", 3975 format("f(g(h(a, // comment\n" 3976 " b, c), d, e), x, y);")); 3977 3978 // Prefer breaking similar line breaks. 3979 verifyFormat( 3980 "const int kTrackingOptions = NSTrackingMouseMoved |\n" 3981 " NSTrackingMouseEnteredAndExited |\n" 3982 " NSTrackingActiveAlways;"); 3983 } 3984 3985 TEST_F(FormatTest, FormatsDeclarationsOnePerLine) { 3986 FormatStyle NoBinPacking = getGoogleStyle(); 3987 NoBinPacking.BinPackParameters = false; 3988 NoBinPacking.BinPackArguments = true; 3989 verifyFormat("void f() {\n" 3990 " f(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa,\n" 3991 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 3992 "}", 3993 NoBinPacking); 3994 verifyFormat("void f(int aaaaaaaaaaaaaaaaaaaa,\n" 3995 " int aaaaaaaaaaaaaaaaaaaa,\n" 3996 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 3997 NoBinPacking); 3998 3999 NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false; 4000 verifyFormat("void aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4001 " vector<int> bbbbbbbbbbbbbbb);", 4002 NoBinPacking); 4003 // FIXME: This behavior difference is probably not wanted. However, currently 4004 // we cannot distinguish BreakBeforeParameter being set because of the wrapped 4005 // template arguments from BreakBeforeParameter being set because of the 4006 // one-per-line formatting. 4007 verifyFormat( 4008 "void fffffffffff(aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa,\n" 4009 " aaaaaaaaaa> aaaaaaaaaa);", 4010 NoBinPacking); 4011 verifyFormat( 4012 "void fffffffffff(\n" 4013 " aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaa>\n" 4014 " aaaaaaaaaa);"); 4015 } 4016 4017 TEST_F(FormatTest, FormatsOneParameterPerLineIfNecessary) { 4018 FormatStyle NoBinPacking = getGoogleStyle(); 4019 NoBinPacking.BinPackParameters = false; 4020 NoBinPacking.BinPackArguments = false; 4021 verifyFormat("f(aaaaaaaaaaaaaaaaaaaa,\n" 4022 " aaaaaaaaaaaaaaaaaaaa,\n" 4023 " aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaa);", 4024 NoBinPacking); 4025 verifyFormat("aaaaaaa(aaaaaaaaaaaaa,\n" 4026 " aaaaaaaaaaaaa,\n" 4027 " aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));", 4028 NoBinPacking); 4029 verifyFormat( 4030 "aaaaaaaa(aaaaaaaaaaaaa,\n" 4031 " aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4032 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n" 4033 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4034 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));", 4035 NoBinPacking); 4036 verifyFormat("aaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n" 4037 " .aaaaaaaaaaaaaaaaaa();", 4038 NoBinPacking); 4039 verifyFormat("void f() {\n" 4040 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4041 " aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaa);\n" 4042 "}", 4043 NoBinPacking); 4044 4045 verifyFormat( 4046 "aaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4047 " aaaaaaaaaaaa,\n" 4048 " aaaaaaaaaaaa);", 4049 NoBinPacking); 4050 verifyFormat( 4051 "somefunction(someotherFunction(ddddddddddddddddddddddddddddddddddd,\n" 4052 " ddddddddddddddddddddddddddddd),\n" 4053 " test);", 4054 NoBinPacking); 4055 4056 verifyFormat("std::vector<aaaaaaaaaaaaaaaaaaaaaaa,\n" 4057 " aaaaaaaaaaaaaaaaaaaaaaa,\n" 4058 " aaaaaaaaaaaaaaaaaaaaaaa>\n" 4059 " aaaaaaaaaaaaaaaaaa;", 4060 NoBinPacking); 4061 verifyFormat("a(\"a\"\n" 4062 " \"a\",\n" 4063 " a);"); 4064 4065 NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false; 4066 verifyFormat("void aaaaaaaaaa(aaaaaaaaa,\n" 4067 " aaaaaaaaa,\n" 4068 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 4069 NoBinPacking); 4070 verifyFormat( 4071 "void f() {\n" 4072 " aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n" 4073 " .aaaaaaa();\n" 4074 "}", 4075 NoBinPacking); 4076 verifyFormat( 4077 "template <class SomeType, class SomeOtherType>\n" 4078 "SomeType SomeFunction(SomeType Type, SomeOtherType OtherType) {}", 4079 NoBinPacking); 4080 } 4081 4082 TEST_F(FormatTest, AdaptiveOnePerLineFormatting) { 4083 FormatStyle Style = getLLVMStyleWithColumns(15); 4084 Style.ExperimentalAutoDetectBinPacking = true; 4085 EXPECT_EQ("aaa(aaaa,\n" 4086 " aaaa,\n" 4087 " aaaa);\n" 4088 "aaa(aaaa,\n" 4089 " aaaa,\n" 4090 " aaaa);", 4091 format("aaa(aaaa,\n" // one-per-line 4092 " aaaa,\n" 4093 " aaaa );\n" 4094 "aaa(aaaa, aaaa, aaaa);", // inconclusive 4095 Style)); 4096 EXPECT_EQ("aaa(aaaa, aaaa,\n" 4097 " aaaa);\n" 4098 "aaa(aaaa, aaaa,\n" 4099 " aaaa);", 4100 format("aaa(aaaa, aaaa,\n" // bin-packed 4101 " aaaa );\n" 4102 "aaa(aaaa, aaaa, aaaa);", // inconclusive 4103 Style)); 4104 } 4105 4106 TEST_F(FormatTest, FormatsBuilderPattern) { 4107 verifyFormat("return llvm::StringSwitch<Reference::Kind>(name)\n" 4108 " .StartsWith(\".eh_frame_hdr\", ORDER_EH_FRAMEHDR)\n" 4109 " .StartsWith(\".eh_frame\", ORDER_EH_FRAME)\n" 4110 " .StartsWith(\".init\", ORDER_INIT)\n" 4111 " .StartsWith(\".fini\", ORDER_FINI)\n" 4112 " .StartsWith(\".hash\", ORDER_HASH)\n" 4113 " .Default(ORDER_TEXT);\n"); 4114 4115 verifyFormat("return aaaaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa() <\n" 4116 " aaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa();"); 4117 verifyFormat( 4118 "aaaaaaa->aaaaaaa\n" 4119 " ->aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4120 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 4121 " ->aaaaaaaa(aaaaaaaaaaaaaaa);"); 4122 verifyFormat( 4123 "aaaaaaa->aaaaaaa\n" 4124 " ->aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 4125 " ->aaaaaaaa(aaaaaaaaaaaaaaa);"); 4126 verifyFormat( 4127 "aaaaaaaaaaaaaaaaaaa()->aaaaaa(bbbbb)->aaaaaaaaaaaaaaaaaaa( // break\n" 4128 " aaaaaaaaaaaaaa);"); 4129 verifyFormat( 4130 "aaaaaaaaaaaaaaaaaaaaaaa *aaaaaaaaa =\n" 4131 " aaaaaa->aaaaaaaaaaaa()\n" 4132 " ->aaaaaaaaaaaaaaaa(\n" 4133 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 4134 " ->aaaaaaaaaaaaaaaaa();"); 4135 verifyGoogleFormat( 4136 "void f() {\n" 4137 " someo->Add((new util::filetools::Handler(dir))\n" 4138 " ->OnEvent1(NewPermanentCallback(\n" 4139 " this, &HandlerHolderClass::EventHandlerCBA))\n" 4140 " ->OnEvent2(NewPermanentCallback(\n" 4141 " this, &HandlerHolderClass::EventHandlerCBB))\n" 4142 " ->OnEvent3(NewPermanentCallback(\n" 4143 " this, &HandlerHolderClass::EventHandlerCBC))\n" 4144 " ->OnEvent5(NewPermanentCallback(\n" 4145 " this, &HandlerHolderClass::EventHandlerCBD))\n" 4146 " ->OnEvent6(NewPermanentCallback(\n" 4147 " this, &HandlerHolderClass::EventHandlerCBE)));\n" 4148 "}"); 4149 4150 verifyFormat( 4151 "aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa();"); 4152 verifyFormat("aaaaaaaaaaaaaaa()\n" 4153 " .aaaaaaaaaaaaaaa()\n" 4154 " .aaaaaaaaaaaaaaa()\n" 4155 " .aaaaaaaaaaaaaaa()\n" 4156 " .aaaaaaaaaaaaaaa();"); 4157 verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n" 4158 " .aaaaaaaaaaaaaaa()\n" 4159 " .aaaaaaaaaaaaaaa()\n" 4160 " .aaaaaaaaaaaaaaa();"); 4161 verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n" 4162 " .aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n" 4163 " .aaaaaaaaaaaaaaa();"); 4164 verifyFormat("aaaaaaaaaaaaa->aaaaaaaaaaaaaaaaaaaaaaaa()\n" 4165 " ->aaaaaaaaaaaaaae(0)\n" 4166 " ->aaaaaaaaaaaaaaa();"); 4167 4168 // Don't linewrap after very short segments. 4169 verifyFormat("a().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 4170 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 4171 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 4172 verifyFormat("aa().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 4173 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 4174 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 4175 verifyFormat("aaa()\n" 4176 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 4177 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 4178 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 4179 4180 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n" 4181 " .aaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 4182 " .has<bbbbbbbbbbbbbbbbbbbbb>();"); 4183 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n" 4184 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n" 4185 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>();"); 4186 4187 // Prefer not to break after empty parentheses. 4188 verifyFormat("FirstToken->WhitespaceRange.getBegin().getLocWithOffset(\n" 4189 " First->LastNewlineOffset);"); 4190 4191 // Prefer not to create "hanging" indents. 4192 verifyFormat( 4193 "return !soooooooooooooome_map\n" 4194 " .insert(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 4195 " .second;"); 4196 verifyFormat( 4197 "return aaaaaaaaaaaaaaaa\n" 4198 " .aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa)\n" 4199 " .aaaa(aaaaaaaaaaaaaa);"); 4200 // No hanging indent here. 4201 verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa.aaaaaaaaaaaaaaa(\n" 4202 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 4203 verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa().aaaaaaaaaaaaaaa(\n" 4204 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 4205 verifyFormat("aaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n" 4206 " .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 4207 getLLVMStyleWithColumns(60)); 4208 verifyFormat("aaaaaaaaaaaaaaaaaa\n" 4209 " .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n" 4210 " .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 4211 getLLVMStyleWithColumns(59)); 4212 verifyFormat("aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4213 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 4214 " .aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 4215 } 4216 4217 TEST_F(FormatTest, BreaksAccordingToOperatorPrecedence) { 4218 verifyFormat( 4219 "if (aaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 4220 " bbbbbbbbbbbbbbbbbbbbbbbbb && ccccccccccccccccccccccccc) {\n}"); 4221 verifyFormat( 4222 "if (aaaaaaaaaaaaaaaaaaaaaaaaa or\n" 4223 " bbbbbbbbbbbbbbbbbbbbbbbbb and cccccccccccccccccccccccc) {\n}"); 4224 4225 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa && bbbbbbbbbbbbbbbbbbbbbbbbb ||\n" 4226 " ccccccccccccccccccccccccc) {\n}"); 4227 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa and bbbbbbbbbbbbbbbbbbbbbbbb or\n" 4228 " ccccccccccccccccccccccccc) {\n}"); 4229 4230 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb ||\n" 4231 " ccccccccccccccccccccccccc) {\n}"); 4232 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb or\n" 4233 " ccccccccccccccccccccccccc) {\n}"); 4234 4235 verifyFormat( 4236 "if ((aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb) &&\n" 4237 " ccccccccccccccccccccccccc) {\n}"); 4238 verifyFormat( 4239 "if ((aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb) and\n" 4240 " ccccccccccccccccccccccccc) {\n}"); 4241 4242 verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA ||\n" 4243 " bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB ||\n" 4244 " cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC ||\n" 4245 " dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;"); 4246 verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA or\n" 4247 " bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB or\n" 4248 " cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC or\n" 4249 " dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;"); 4250 4251 verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa ||\n" 4252 " aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) &&\n" 4253 " aaaaaaaaaaaaaaa != aa) {\n}"); 4254 verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa or\n" 4255 " aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) and\n" 4256 " aaaaaaaaaaaaaaa != aa) {\n}"); 4257 } 4258 4259 TEST_F(FormatTest, BreaksAfterAssignments) { 4260 verifyFormat( 4261 "unsigned Cost =\n" 4262 " TTI.getMemoryOpCost(I->getOpcode(), VectorTy, SI->getAlignment(),\n" 4263 " SI->getPointerAddressSpaceee());\n"); 4264 verifyFormat( 4265 "CharSourceRange LineRange = CharSourceRange::getTokenRange(\n" 4266 " Line.Tokens.front().Tok.getLo(), Line.Tokens.back().Tok.getLoc());"); 4267 4268 verifyFormat( 4269 "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa = aaaaaaaaaaaaaa(0).aaaa().aaaaaaaaa(\n" 4270 " aaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaa);"); 4271 verifyFormat("unsigned OriginalStartColumn =\n" 4272 " SourceMgr.getSpellingColumnNumber(\n" 4273 " Current.FormatTok.getStartOfNonWhitespace()) -\n" 4274 " 1;"); 4275 } 4276 4277 TEST_F(FormatTest, ConfigurableBreakAssignmentPenalty) { 4278 FormatStyle Style = getLLVMStyle(); 4279 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 4280 " bbbbbbbbbbbbbbbbbbbbbbbbbb + cccccccccccccccccccccccccc;", 4281 Style); 4282 4283 Style.PenaltyBreakAssignment = 20; 4284 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa = bbbbbbbbbbbbbbbbbbbbbbbbbb +\n" 4285 " cccccccccccccccccccccccccc;", 4286 Style); 4287 } 4288 4289 TEST_F(FormatTest, AlignsAfterAssignments) { 4290 verifyFormat( 4291 "int Result = aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4292 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 4293 verifyFormat( 4294 "Result += aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4295 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 4296 verifyFormat( 4297 "Result >>= aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4298 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 4299 verifyFormat( 4300 "int Result = (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4301 " aaaaaaaaaaaaaaaaaaaaaaaaa);"); 4302 verifyFormat( 4303 "double LooooooooooooooooooooooooongResult = aaaaaaaaaaaaaaaaaaaaaaaa +\n" 4304 " aaaaaaaaaaaaaaaaaaaaaaaa +\n" 4305 " aaaaaaaaaaaaaaaaaaaaaaaa;"); 4306 } 4307 4308 TEST_F(FormatTest, AlignsAfterReturn) { 4309 verifyFormat( 4310 "return aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4311 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 4312 verifyFormat( 4313 "return (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4314 " aaaaaaaaaaaaaaaaaaaaaaaaa);"); 4315 verifyFormat( 4316 "return aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n" 4317 " aaaaaaaaaaaaaaaaaaaaaa();"); 4318 verifyFormat( 4319 "return (aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n" 4320 " aaaaaaaaaaaaaaaaaaaaaa());"); 4321 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4322 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 4323 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4324 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) &&\n" 4325 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 4326 verifyFormat("return\n" 4327 " // true if code is one of a or b.\n" 4328 " code == a || code == b;"); 4329 } 4330 4331 TEST_F(FormatTest, AlignsAfterOpenBracket) { 4332 verifyFormat( 4333 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n" 4334 " aaaaaaaaa aaaaaaa) {}"); 4335 verifyFormat( 4336 "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n" 4337 " aaaaaaaaaaa aaaaaaaaa);"); 4338 verifyFormat( 4339 "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n" 4340 " aaaaaaaaaaaaaaaaaaaaa));"); 4341 FormatStyle Style = getLLVMStyle(); 4342 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 4343 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4344 " aaaaaaaaaaa aaaaaaaa, aaaaaaaaa aaaaaaa) {}", 4345 Style); 4346 verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n" 4347 " aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaa aaaaaaaaa);", 4348 Style); 4349 verifyFormat("SomeLongVariableName->someFunction(\n" 4350 " foooooooo(aaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa));", 4351 Style); 4352 verifyFormat( 4353 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n" 4354 " aaaaaaaaa aaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4355 Style); 4356 verifyFormat( 4357 "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n" 4358 " aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 4359 Style); 4360 verifyFormat( 4361 "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n" 4362 " aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));", 4363 Style); 4364 4365 verifyFormat("bbbbbbbbbbbb(aaaaaaaaaaaaaaaaaaaaaaaa, //\n" 4366 " ccccccc(aaaaaaaaaaaaaaaaa, //\n" 4367 " b));", 4368 Style); 4369 4370 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 4371 Style.BinPackArguments = false; 4372 Style.BinPackParameters = false; 4373 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4374 " aaaaaaaaaaa aaaaaaaa,\n" 4375 " aaaaaaaaa aaaaaaa,\n" 4376 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4377 Style); 4378 verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n" 4379 " aaaaaaaaaaa aaaaaaaaa,\n" 4380 " aaaaaaaaaaa aaaaaaaaa,\n" 4381 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 4382 Style); 4383 verifyFormat("SomeLongVariableName->someFunction(foooooooo(\n" 4384 " aaaaaaaaaaaaaaa,\n" 4385 " aaaaaaaaaaaaaaaaaaaaa,\n" 4386 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));", 4387 Style); 4388 verifyFormat( 4389 "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa(\n" 4390 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));", 4391 Style); 4392 verifyFormat( 4393 "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaa.aaaaaaaaaa(\n" 4394 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));", 4395 Style); 4396 verifyFormat( 4397 "aaaaaaaaaaaaaaaaaaaaaaaa(\n" 4398 " aaaaaaaaaaaaaaaaaaaaa(\n" 4399 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)),\n" 4400 " aaaaaaaaaaaaaaaa);", 4401 Style); 4402 verifyFormat( 4403 "aaaaaaaaaaaaaaaaaaaaaaaa(\n" 4404 " aaaaaaaaaaaaaaaaaaaaa(\n" 4405 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)) &&\n" 4406 " aaaaaaaaaaaaaaaa);", 4407 Style); 4408 } 4409 4410 TEST_F(FormatTest, ParenthesesAndOperandAlignment) { 4411 FormatStyle Style = getLLVMStyleWithColumns(40); 4412 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 4413 " bbbbbbbbbbbbbbbbbbbbbb);", 4414 Style); 4415 Style.AlignAfterOpenBracket = FormatStyle::BAS_Align; 4416 Style.AlignOperands = false; 4417 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 4418 " bbbbbbbbbbbbbbbbbbbbbb);", 4419 Style); 4420 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 4421 Style.AlignOperands = true; 4422 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 4423 " bbbbbbbbbbbbbbbbbbbbbb);", 4424 Style); 4425 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 4426 Style.AlignOperands = false; 4427 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 4428 " bbbbbbbbbbbbbbbbbbbbbb);", 4429 Style); 4430 } 4431 4432 TEST_F(FormatTest, BreaksConditionalExpressions) { 4433 verifyFormat( 4434 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4435 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4436 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 4437 verifyFormat( 4438 "aaaa(aaaaaaaaaa, aaaaaaaa,\n" 4439 " aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4440 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 4441 verifyFormat( 4442 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4443 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 4444 verifyFormat( 4445 "aaaa(aaaaaaaaa, aaaaaaaaa,\n" 4446 " aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4447 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 4448 verifyFormat( 4449 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa)\n" 4450 " : aaaaaaaaaaaaa);"); 4451 verifyFormat( 4452 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4453 " aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4454 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4455 " aaaaaaaaaaaaa);"); 4456 verifyFormat( 4457 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4458 " aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4459 " aaaaaaaaaaaaa);"); 4460 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4461 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4462 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 4463 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4464 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 4465 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4466 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4467 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4468 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 4469 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4470 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4471 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 4472 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4473 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4474 " ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4475 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4476 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 4477 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4478 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4479 " : aaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 4480 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n" 4481 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4482 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4483 " : aaaaaaaaaaaaaaaa;"); 4484 verifyFormat( 4485 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4486 " ? aaaaaaaaaaaaaaa\n" 4487 " : aaaaaaaaaaaaaaa;"); 4488 verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n" 4489 " aaaaaaaaa\n" 4490 " ? b\n" 4491 " : c);"); 4492 verifyFormat("return aaaa == bbbb\n" 4493 " // comment\n" 4494 " ? aaaa\n" 4495 " : bbbb;"); 4496 verifyFormat("unsigned Indent =\n" 4497 " format(TheLine.First,\n" 4498 " IndentForLevel[TheLine.Level] >= 0\n" 4499 " ? IndentForLevel[TheLine.Level]\n" 4500 " : TheLine * 2,\n" 4501 " TheLine.InPPDirective, PreviousEndOfLineColumn);", 4502 getLLVMStyleWithColumns(60)); 4503 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n" 4504 " ? aaaaaaaaaaaaaaa\n" 4505 " : bbbbbbbbbbbbbbb //\n" 4506 " ? ccccccccccccccc\n" 4507 " : ddddddddddddddd;"); 4508 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n" 4509 " ? aaaaaaaaaaaaaaa\n" 4510 " : (bbbbbbbbbbbbbbb //\n" 4511 " ? ccccccccccccccc\n" 4512 " : ddddddddddddddd);"); 4513 verifyFormat( 4514 "int aaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4515 " ? aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4516 " aaaaaaaaaaaaaaaaaaaaa +\n" 4517 " aaaaaaaaaaaaaaaaaaaaa\n" 4518 " : aaaaaaaaaa;"); 4519 verifyFormat( 4520 "aaaaaa = aaaaaaaaaaaa ? aaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4521 " : aaaaaaaaaaaaaaaaaaaaaa\n" 4522 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 4523 4524 FormatStyle NoBinPacking = getLLVMStyle(); 4525 NoBinPacking.BinPackArguments = false; 4526 verifyFormat( 4527 "void f() {\n" 4528 " g(aaa,\n" 4529 " aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n" 4530 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4531 " ? aaaaaaaaaaaaaaa\n" 4532 " : aaaaaaaaaaaaaaa);\n" 4533 "}", 4534 NoBinPacking); 4535 verifyFormat( 4536 "void f() {\n" 4537 " g(aaa,\n" 4538 " aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n" 4539 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4540 " ?: aaaaaaaaaaaaaaa);\n" 4541 "}", 4542 NoBinPacking); 4543 4544 verifyFormat("SomeFunction(aaaaaaaaaaaaaaaaa,\n" 4545 " // comment.\n" 4546 " ccccccccccccccccccccccccccccccccccccccc\n" 4547 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4548 " : bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);"); 4549 4550 // Assignments in conditional expressions. Apparently not uncommon :-(. 4551 verifyFormat("return a != b\n" 4552 " // comment\n" 4553 " ? a = b\n" 4554 " : a = b;"); 4555 verifyFormat("return a != b\n" 4556 " // comment\n" 4557 " ? a = a != b\n" 4558 " // comment\n" 4559 " ? a = b\n" 4560 " : a\n" 4561 " : a;\n"); 4562 verifyFormat("return a != b\n" 4563 " // comment\n" 4564 " ? a\n" 4565 " : a = a != b\n" 4566 " // comment\n" 4567 " ? a = b\n" 4568 " : a;"); 4569 } 4570 4571 TEST_F(FormatTest, BreaksConditionalExpressionsAfterOperator) { 4572 FormatStyle Style = getLLVMStyle(); 4573 Style.BreakBeforeTernaryOperators = false; 4574 Style.ColumnLimit = 70; 4575 verifyFormat( 4576 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 4577 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 4578 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 4579 Style); 4580 verifyFormat( 4581 "aaaa(aaaaaaaaaa, aaaaaaaa,\n" 4582 " aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 4583 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 4584 Style); 4585 verifyFormat( 4586 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 4587 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 4588 Style); 4589 verifyFormat( 4590 "aaaa(aaaaaaaa, aaaaaaaaaa,\n" 4591 " aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 4592 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 4593 Style); 4594 verifyFormat( 4595 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa) :\n" 4596 " aaaaaaaaaaaaa);", 4597 Style); 4598 verifyFormat( 4599 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4600 " aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 4601 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4602 " aaaaaaaaaaaaa);", 4603 Style); 4604 verifyFormat( 4605 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4606 " aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4607 " aaaaaaaaaaaaa);", 4608 Style); 4609 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 4610 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4611 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n" 4612 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4613 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 4614 Style); 4615 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4616 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 4617 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4618 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n" 4619 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4620 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4621 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);", 4622 Style); 4623 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4624 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?:\n" 4625 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4626 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4627 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);", 4628 Style); 4629 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 4630 " aaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 4631 " aaaaaaaaaaaaaaaaaaaaaaaaaaa;", 4632 Style); 4633 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n" 4634 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 4635 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 4636 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 4637 Style); 4638 verifyFormat( 4639 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 4640 " aaaaaaaaaaaaaaa :\n" 4641 " aaaaaaaaaaaaaaa;", 4642 Style); 4643 verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n" 4644 " aaaaaaaaa ?\n" 4645 " b :\n" 4646 " c);", 4647 Style); 4648 verifyFormat("unsigned Indent =\n" 4649 " format(TheLine.First,\n" 4650 " IndentForLevel[TheLine.Level] >= 0 ?\n" 4651 " IndentForLevel[TheLine.Level] :\n" 4652 " TheLine * 2,\n" 4653 " TheLine.InPPDirective, PreviousEndOfLineColumn);", 4654 Style); 4655 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n" 4656 " aaaaaaaaaaaaaaa :\n" 4657 " bbbbbbbbbbbbbbb ? //\n" 4658 " ccccccccccccccc :\n" 4659 " ddddddddddddddd;", 4660 Style); 4661 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n" 4662 " aaaaaaaaaaaaaaa :\n" 4663 " (bbbbbbbbbbbbbbb ? //\n" 4664 " ccccccccccccccc :\n" 4665 " ddddddddddddddd);", 4666 Style); 4667 verifyFormat("int i = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 4668 " /*bbbbbbbbbbbbbbb=*/bbbbbbbbbbbbbbbbbbbbbbbbb :\n" 4669 " ccccccccccccccccccccccccccc;", 4670 Style); 4671 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 4672 " aaaaa :\n" 4673 " bbbbbbbbbbbbbbb + cccccccccccccccc;", 4674 Style); 4675 } 4676 4677 TEST_F(FormatTest, DeclarationsOfMultipleVariables) { 4678 verifyFormat("bool aaaaaaaaaaaaaaaaa = aaaaaa->aaaaaaaaaaaaaaaaa(),\n" 4679 " aaaaaaaaaaa = aaaaaa->aaaaaaaaaaa();"); 4680 verifyFormat("bool a = true, b = false;"); 4681 4682 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaa =\n" 4683 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa),\n" 4684 " bbbbbbbbbbbbbbbbbbbbbbbbb =\n" 4685 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(bbbbbbbbbbbbbbbb);"); 4686 verifyFormat( 4687 "bool aaaaaaaaaaaaaaaaaaaaa =\n" 4688 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb && cccccccccccccccccccccccccccc,\n" 4689 " d = e && f;"); 4690 verifyFormat("aaaaaaaaa a = aaaaaaaaaaaaaaaaaaaa, b = bbbbbbbbbbbbbbbbbbbb,\n" 4691 " c = cccccccccccccccccccc, d = dddddddddddddddddddd;"); 4692 verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n" 4693 " *c = ccccccccccccccccccc, *d = ddddddddddddddddddd;"); 4694 verifyFormat("aaaaaaaaa ***a = aaaaaaaaaaaaaaaaaaa, ***b = bbbbbbbbbbbbbbb,\n" 4695 " ***c = ccccccccccccccccccc, ***d = ddddddddddddddd;"); 4696 4697 FormatStyle Style = getGoogleStyle(); 4698 Style.PointerAlignment = FormatStyle::PAS_Left; 4699 Style.DerivePointerAlignment = false; 4700 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4701 " *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaa,\n" 4702 " *b = bbbbbbbbbbbbbbbbbbb;", 4703 Style); 4704 verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n" 4705 " *b = bbbbbbbbbbbbbbbbbbb, *d = ddddddddddddddddddd;", 4706 Style); 4707 verifyFormat("vector<int*> a, b;", Style); 4708 verifyFormat("for (int *p, *q; p != q; p = p->next) {\n}", Style); 4709 } 4710 4711 TEST_F(FormatTest, ConditionalExpressionsInBrackets) { 4712 verifyFormat("arr[foo ? bar : baz];"); 4713 verifyFormat("f()[foo ? bar : baz];"); 4714 verifyFormat("(a + b)[foo ? bar : baz];"); 4715 verifyFormat("arr[foo ? (4 > 5 ? 4 : 5) : 5 < 5 ? 5 : 7];"); 4716 } 4717 4718 TEST_F(FormatTest, AlignsStringLiterals) { 4719 verifyFormat("loooooooooooooooooooooooooongFunction(\"short literal \"\n" 4720 " \"short literal\");"); 4721 verifyFormat( 4722 "looooooooooooooooooooooooongFunction(\n" 4723 " \"short literal\"\n" 4724 " \"looooooooooooooooooooooooooooooooooooooooooooooooong literal\");"); 4725 verifyFormat("someFunction(\"Always break between multi-line\"\n" 4726 " \" string literals\",\n" 4727 " and, other, parameters);"); 4728 EXPECT_EQ("fun + \"1243\" /* comment */\n" 4729 " \"5678\";", 4730 format("fun + \"1243\" /* comment */\n" 4731 " \"5678\";", 4732 getLLVMStyleWithColumns(28))); 4733 EXPECT_EQ( 4734 "aaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 4735 " \"aaaaaaaaaaaaaaaaaaaaa\"\n" 4736 " \"aaaaaaaaaaaaaaaa\";", 4737 format("aaaaaa =" 4738 "\"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa " 4739 "aaaaaaaaaaaaaaaaaaaaa\" " 4740 "\"aaaaaaaaaaaaaaaa\";")); 4741 verifyFormat("a = a + \"a\"\n" 4742 " \"a\"\n" 4743 " \"a\";"); 4744 verifyFormat("f(\"a\", \"b\"\n" 4745 " \"c\");"); 4746 4747 verifyFormat( 4748 "#define LL_FORMAT \"ll\"\n" 4749 "printf(\"aaaaa: %d, bbbbbb: %\" LL_FORMAT \"d, cccccccc: %\" LL_FORMAT\n" 4750 " \"d, ddddddddd: %\" LL_FORMAT \"d\");"); 4751 4752 verifyFormat("#define A(X) \\\n" 4753 " \"aaaaa\" #X \"bbbbbb\" \\\n" 4754 " \"ccccc\"", 4755 getLLVMStyleWithColumns(23)); 4756 verifyFormat("#define A \"def\"\n" 4757 "f(\"abc\" A \"ghi\"\n" 4758 " \"jkl\");"); 4759 4760 verifyFormat("f(L\"a\"\n" 4761 " L\"b\");"); 4762 verifyFormat("#define A(X) \\\n" 4763 " L\"aaaaa\" #X L\"bbbbbb\" \\\n" 4764 " L\"ccccc\"", 4765 getLLVMStyleWithColumns(25)); 4766 4767 verifyFormat("f(@\"a\"\n" 4768 " @\"b\");"); 4769 verifyFormat("NSString s = @\"a\"\n" 4770 " @\"b\"\n" 4771 " @\"c\";"); 4772 verifyFormat("NSString s = @\"a\"\n" 4773 " \"b\"\n" 4774 " \"c\";"); 4775 } 4776 4777 TEST_F(FormatTest, ReturnTypeBreakingStyle) { 4778 FormatStyle Style = getLLVMStyle(); 4779 // No declarations or definitions should be moved to own line. 4780 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_None; 4781 verifyFormat("class A {\n" 4782 " int f() { return 1; }\n" 4783 " int g();\n" 4784 "};\n" 4785 "int f() { return 1; }\n" 4786 "int g();\n", 4787 Style); 4788 4789 // All declarations and definitions should have the return type moved to its 4790 // own 4791 // line. 4792 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All; 4793 verifyFormat("class E {\n" 4794 " int\n" 4795 " f() {\n" 4796 " return 1;\n" 4797 " }\n" 4798 " int\n" 4799 " g();\n" 4800 "};\n" 4801 "int\n" 4802 "f() {\n" 4803 " return 1;\n" 4804 "}\n" 4805 "int\n" 4806 "g();\n", 4807 Style); 4808 4809 // Top-level definitions, and no kinds of declarations should have the 4810 // return type moved to its own line. 4811 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevelDefinitions; 4812 verifyFormat("class B {\n" 4813 " int f() { return 1; }\n" 4814 " int g();\n" 4815 "};\n" 4816 "int\n" 4817 "f() {\n" 4818 " return 1;\n" 4819 "}\n" 4820 "int g();\n", 4821 Style); 4822 4823 // Top-level definitions and declarations should have the return type moved 4824 // to its own line. 4825 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevel; 4826 verifyFormat("class C {\n" 4827 " int f() { return 1; }\n" 4828 " int g();\n" 4829 "};\n" 4830 "int\n" 4831 "f() {\n" 4832 " return 1;\n" 4833 "}\n" 4834 "int\n" 4835 "g();\n", 4836 Style); 4837 4838 // All definitions should have the return type moved to its own line, but no 4839 // kinds of declarations. 4840 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions; 4841 verifyFormat("class D {\n" 4842 " int\n" 4843 " f() {\n" 4844 " return 1;\n" 4845 " }\n" 4846 " int g();\n" 4847 "};\n" 4848 "int\n" 4849 "f() {\n" 4850 " return 1;\n" 4851 "}\n" 4852 "int g();\n", 4853 Style); 4854 verifyFormat("const char *\n" 4855 "f(void) {\n" // Break here. 4856 " return \"\";\n" 4857 "}\n" 4858 "const char *bar(void);\n", // No break here. 4859 Style); 4860 verifyFormat("template <class T>\n" 4861 "T *\n" 4862 "f(T &c) {\n" // Break here. 4863 " return NULL;\n" 4864 "}\n" 4865 "template <class T> T *f(T &c);\n", // No break here. 4866 Style); 4867 verifyFormat("class C {\n" 4868 " int\n" 4869 " operator+() {\n" 4870 " return 1;\n" 4871 " }\n" 4872 " int\n" 4873 " operator()() {\n" 4874 " return 1;\n" 4875 " }\n" 4876 "};\n", 4877 Style); 4878 verifyFormat("void\n" 4879 "A::operator()() {}\n" 4880 "void\n" 4881 "A::operator>>() {}\n" 4882 "void\n" 4883 "A::operator+() {}\n", 4884 Style); 4885 verifyFormat("void *operator new(std::size_t s);", // No break here. 4886 Style); 4887 verifyFormat("void *\n" 4888 "operator new(std::size_t s) {}", 4889 Style); 4890 verifyFormat("void *\n" 4891 "operator delete[](void *ptr) {}", 4892 Style); 4893 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 4894 verifyFormat("const char *\n" 4895 "f(void)\n" // Break here. 4896 "{\n" 4897 " return \"\";\n" 4898 "}\n" 4899 "const char *bar(void);\n", // No break here. 4900 Style); 4901 verifyFormat("template <class T>\n" 4902 "T *\n" // Problem here: no line break 4903 "f(T &c)\n" // Break here. 4904 "{\n" 4905 " return NULL;\n" 4906 "}\n" 4907 "template <class T> T *f(T &c);\n", // No break here. 4908 Style); 4909 } 4910 4911 TEST_F(FormatTest, AlwaysBreakBeforeMultilineStrings) { 4912 FormatStyle NoBreak = getLLVMStyle(); 4913 NoBreak.AlwaysBreakBeforeMultilineStrings = false; 4914 FormatStyle Break = getLLVMStyle(); 4915 Break.AlwaysBreakBeforeMultilineStrings = true; 4916 verifyFormat("aaaa = \"bbbb\"\n" 4917 " \"cccc\";", 4918 NoBreak); 4919 verifyFormat("aaaa =\n" 4920 " \"bbbb\"\n" 4921 " \"cccc\";", 4922 Break); 4923 verifyFormat("aaaa(\"bbbb\"\n" 4924 " \"cccc\");", 4925 NoBreak); 4926 verifyFormat("aaaa(\n" 4927 " \"bbbb\"\n" 4928 " \"cccc\");", 4929 Break); 4930 verifyFormat("aaaa(qqq, \"bbbb\"\n" 4931 " \"cccc\");", 4932 NoBreak); 4933 verifyFormat("aaaa(qqq,\n" 4934 " \"bbbb\"\n" 4935 " \"cccc\");", 4936 Break); 4937 verifyFormat("aaaa(qqq,\n" 4938 " L\"bbbb\"\n" 4939 " L\"cccc\");", 4940 Break); 4941 verifyFormat("aaaaa(aaaaaa, aaaaaaa(\"aaaa\"\n" 4942 " \"bbbb\"));", 4943 Break); 4944 verifyFormat("string s = someFunction(\n" 4945 " \"abc\"\n" 4946 " \"abc\");", 4947 Break); 4948 4949 // As we break before unary operators, breaking right after them is bad. 4950 verifyFormat("string foo = abc ? \"x\"\n" 4951 " \"blah blah blah blah blah blah\"\n" 4952 " : \"y\";", 4953 Break); 4954 4955 // Don't break if there is no column gain. 4956 verifyFormat("f(\"aaaa\"\n" 4957 " \"bbbb\");", 4958 Break); 4959 4960 // Treat literals with escaped newlines like multi-line string literals. 4961 EXPECT_EQ("x = \"a\\\n" 4962 "b\\\n" 4963 "c\";", 4964 format("x = \"a\\\n" 4965 "b\\\n" 4966 "c\";", 4967 NoBreak)); 4968 EXPECT_EQ("xxxx =\n" 4969 " \"a\\\n" 4970 "b\\\n" 4971 "c\";", 4972 format("xxxx = \"a\\\n" 4973 "b\\\n" 4974 "c\";", 4975 Break)); 4976 4977 EXPECT_EQ("NSString *const kString =\n" 4978 " @\"aaaa\"\n" 4979 " @\"bbbb\";", 4980 format("NSString *const kString = @\"aaaa\"\n" 4981 "@\"bbbb\";", 4982 Break)); 4983 4984 Break.ColumnLimit = 0; 4985 verifyFormat("const char *hello = \"hello llvm\";", Break); 4986 } 4987 4988 TEST_F(FormatTest, AlignsPipes) { 4989 verifyFormat( 4990 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4991 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4992 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 4993 verifyFormat( 4994 "aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa\n" 4995 " << aaaaaaaaaaaaaaaaaaaa;"); 4996 verifyFormat( 4997 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4998 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 4999 verifyFormat( 5000 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5001 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5002 verifyFormat( 5003 "llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"\n" 5004 " \"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\"\n" 5005 " << \"ccccccccccccccccccccccccccccccccccccccccccccccccc\";"); 5006 verifyFormat( 5007 "aaaaaaaa << (aaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5008 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5009 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5010 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5011 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5012 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5013 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 5014 verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaaaaaa: \"\n" 5015 " << aaaaaaaaaaaaaaaaa(aaaaaaaa, aaaaaaaaaaa);"); 5016 verifyFormat( 5017 "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5018 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5019 verifyFormat( 5020 "auto Diag = diag() << aaaaaaaaaaaaaaaa(aaaaaaaaaaaa, aaaaaaaaaaaaa,\n" 5021 " aaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5022 5023 verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \"\n" 5024 " << aaaaaaaa.aaaaaaaaaaaa(aaa)->aaaaaaaaaaaaaa();"); 5025 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5026 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5027 " aaaaaaaaaaaaaaaaaaaaa)\n" 5028 " << aaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5029 verifyFormat("LOG_IF(aaa == //\n" 5030 " bbb)\n" 5031 " << a << b;"); 5032 5033 // But sometimes, breaking before the first "<<" is desirable. 5034 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n" 5035 " << aaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaa);"); 5036 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbb)\n" 5037 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5038 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5039 verifyFormat("SemaRef.Diag(Loc, diag::note_for_range_begin_end)\n" 5040 " << BEF << IsTemplate << Description << E->getType();"); 5041 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n" 5042 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5043 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5044 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n" 5045 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5046 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5047 " << aaa;"); 5048 5049 verifyFormat( 5050 "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5051 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 5052 5053 // Incomplete string literal. 5054 EXPECT_EQ("llvm::errs() << \"\n" 5055 " << a;", 5056 format("llvm::errs() << \"\n<<a;")); 5057 5058 verifyFormat("void f() {\n" 5059 " CHECK_EQ(aaaa, (*bbbbbbbbb)->cccccc)\n" 5060 " << \"qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\";\n" 5061 "}"); 5062 5063 // Handle 'endl'. 5064 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << endl\n" 5065 " << bbbbbbbbbbbbbbbbbbbbbb << endl;"); 5066 verifyFormat("llvm::errs() << endl << bbbbbbbbbbbbbbbbbbbbbb << endl;"); 5067 5068 // Handle '\n'. 5069 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \"\\n\"\n" 5070 " << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";"); 5071 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \'\\n\'\n" 5072 " << bbbbbbbbbbbbbbbbbbbbbb << \'\\n\';"); 5073 verifyFormat("llvm::errs() << aaaa << \"aaaaaaaaaaaaaaaaaa\\n\"\n" 5074 " << bbbb << \"bbbbbbbbbbbbbbbbbb\\n\";"); 5075 verifyFormat("llvm::errs() << \"\\n\" << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";"); 5076 } 5077 5078 TEST_F(FormatTest, KeepStringLabelValuePairsOnALine) { 5079 verifyFormat("return out << \"somepacket = {\\n\"\n" 5080 " << \" aaaaaa = \" << pkt.aaaaaa << \"\\n\"\n" 5081 " << \" bbbb = \" << pkt.bbbb << \"\\n\"\n" 5082 " << \" cccccc = \" << pkt.cccccc << \"\\n\"\n" 5083 " << \" ddd = [\" << pkt.ddd << \"]\\n\"\n" 5084 " << \"}\";"); 5085 5086 verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n" 5087 " << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n" 5088 " << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa;"); 5089 verifyFormat( 5090 "llvm::outs() << \"aaaaaaaaaaaaaaaaa = \" << aaaaaaaaaaaaaaaaa\n" 5091 " << \"bbbbbbbbbbbbbbbbb = \" << bbbbbbbbbbbbbbbbb\n" 5092 " << \"ccccccccccccccccc = \" << ccccccccccccccccc\n" 5093 " << \"ddddddddddddddddd = \" << ddddddddddddddddd\n" 5094 " << \"eeeeeeeeeeeeeeeee = \" << eeeeeeeeeeeeeeeee;"); 5095 verifyFormat("llvm::outs() << aaaaaaaaaaaaaaaaaaaaaaaa << \"=\"\n" 5096 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 5097 verifyFormat( 5098 "void f() {\n" 5099 " llvm::outs() << \"aaaaaaaaaaaaaaaaaaaa: \"\n" 5100 " << aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 5101 "}"); 5102 5103 // Breaking before the first "<<" is generally not desirable. 5104 verifyFormat( 5105 "llvm::errs()\n" 5106 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5107 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5108 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5109 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 5110 getLLVMStyleWithColumns(70)); 5111 verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaa: \"\n" 5112 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5113 " << \"aaaaaaaaaaaaaaaaaaa: \"\n" 5114 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5115 " << \"aaaaaaaaaaaaaaaaaaa: \"\n" 5116 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 5117 getLLVMStyleWithColumns(70)); 5118 5119 verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n" 5120 " \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n" 5121 " \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa;"); 5122 verifyFormat("string v = StrCat(\"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n" 5123 " \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n" 5124 " \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa);"); 5125 verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" +\n" 5126 " (aaaa + aaaa);", 5127 getLLVMStyleWithColumns(40)); 5128 verifyFormat("string v = StrCat(\"aaaaaaaaaaaa: \" +\n" 5129 " (aaaaaaa + aaaaa));", 5130 getLLVMStyleWithColumns(40)); 5131 verifyFormat( 5132 "string v = StrCat(\"aaaaaaaaaaaaaaaaaaaaaaaaaaa: \",\n" 5133 " SomeFunction(aaaaaaaaaaaa, aaaaaaaa.aaaaaaa),\n" 5134 " bbbbbbbbbbbbbbbbbbbbbbb);"); 5135 } 5136 5137 TEST_F(FormatTest, UnderstandsEquals) { 5138 verifyFormat( 5139 "aaaaaaaaaaaaaaaaa =\n" 5140 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5141 verifyFormat( 5142 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 5143 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 5144 verifyFormat( 5145 "if (a) {\n" 5146 " f();\n" 5147 "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 5148 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 5149 "}"); 5150 5151 verifyFormat("if (int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 5152 " 100000000 + 10000000) {\n}"); 5153 } 5154 5155 TEST_F(FormatTest, WrapsAtFunctionCallsIfNecessary) { 5156 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n" 5157 " .looooooooooooooooooooooooooooooooooooooongFunction();"); 5158 5159 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n" 5160 " ->looooooooooooooooooooooooooooooooooooooongFunction();"); 5161 5162 verifyFormat( 5163 "LooooooooooooooooooooooooooooooooongObject->shortFunction(Parameter1,\n" 5164 " Parameter2);"); 5165 5166 verifyFormat( 5167 "ShortObject->shortFunction(\n" 5168 " LooooooooooooooooooooooooooooooooooooooooooooooongParameter1,\n" 5169 " LooooooooooooooooooooooooooooooooooooooooooooooongParameter2);"); 5170 5171 verifyFormat("loooooooooooooongFunction(\n" 5172 " LoooooooooooooongObject->looooooooooooooooongFunction());"); 5173 5174 verifyFormat( 5175 "function(LoooooooooooooooooooooooooooooooooooongObject\n" 5176 " ->loooooooooooooooooooooooooooooooooooooooongFunction());"); 5177 5178 verifyFormat("EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n" 5179 " .WillRepeatedly(Return(SomeValue));"); 5180 verifyFormat("void f() {\n" 5181 " EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n" 5182 " .Times(2)\n" 5183 " .WillRepeatedly(Return(SomeValue));\n" 5184 "}"); 5185 verifyFormat("SomeMap[std::pair(aaaaaaaaaaaa, bbbbbbbbbbbbbbb)].insert(\n" 5186 " ccccccccccccccccccccccc);"); 5187 verifyFormat("aaaaa(aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5188 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5189 " .aaaaa(aaaaa),\n" 5190 " aaaaaaaaaaaaaaaaaaaaa);"); 5191 verifyFormat("void f() {\n" 5192 " aaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5193 " aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa)->aaaaaaaaa());\n" 5194 "}"); 5195 verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5196 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5197 " .aaaaaaaaaaaaaaa(aa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5198 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5199 " aaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 5200 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5201 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5202 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5203 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()) {\n" 5204 "}"); 5205 5206 // Here, it is not necessary to wrap at "." or "->". 5207 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaa) ||\n" 5208 " aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 5209 verifyFormat( 5210 "aaaaaaaaaaa->aaaaaaaaa(\n" 5211 " aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5212 " aaaaaaaaaaaaaaaaaa->aaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa));\n"); 5213 5214 verifyFormat( 5215 "aaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5216 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa().aaaaaaaaaaaaaaaaa());"); 5217 verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() *\n" 5218 " aaaaaaaaa()->aaaaaa()->aaaaa());"); 5219 verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() ||\n" 5220 " aaaaaaaaa()->aaaaaa()->aaaaa());"); 5221 5222 verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5223 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5224 " .a();"); 5225 5226 FormatStyle NoBinPacking = getLLVMStyle(); 5227 NoBinPacking.BinPackParameters = false; 5228 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n" 5229 " .aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n" 5230 " .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa,\n" 5231 " aaaaaaaaaaaaaaaaaaa,\n" 5232 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5233 NoBinPacking); 5234 5235 // If there is a subsequent call, change to hanging indentation. 5236 verifyFormat( 5237 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5238 " aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa))\n" 5239 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 5240 verifyFormat( 5241 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5242 " aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa));"); 5243 verifyFormat("aaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5244 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5245 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 5246 verifyFormat("aaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5247 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5248 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());"); 5249 } 5250 5251 TEST_F(FormatTest, WrapsTemplateDeclarations) { 5252 verifyFormat("template <typename T>\n" 5253 "virtual void loooooooooooongFunction(int Param1, int Param2);"); 5254 verifyFormat("template <typename T>\n" 5255 "// T should be one of {A, B}.\n" 5256 "virtual void loooooooooooongFunction(int Param1, int Param2);"); 5257 verifyFormat( 5258 "template <typename T>\n" 5259 "using comment_to_xml_conversion = comment_to_xml_conversion<T, int>;"); 5260 verifyFormat("template <typename T>\n" 5261 "void f(int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram1,\n" 5262 " int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram2);"); 5263 verifyFormat( 5264 "template <typename T>\n" 5265 "void looooooooooooooooooooongFunction(int Paaaaaaaaaaaaaaaaaaaaram1,\n" 5266 " int Paaaaaaaaaaaaaaaaaaaaram2);"); 5267 verifyFormat( 5268 "template <typename T>\n" 5269 "aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaa,\n" 5270 " aaaaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaa,\n" 5271 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5272 verifyFormat("template <typename T>\n" 5273 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5274 " int aaaaaaaaaaaaaaaaaaaaaa);"); 5275 verifyFormat( 5276 "template <typename T1, typename T2 = char, typename T3 = char,\n" 5277 " typename T4 = char>\n" 5278 "void f();"); 5279 verifyFormat("template <typename aaaaaaaaaaa, typename bbbbbbbbbbbbb,\n" 5280 " template <typename> class cccccccccccccccccccccc,\n" 5281 " typename ddddddddddddd>\n" 5282 "class C {};"); 5283 verifyFormat( 5284 "aaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>(\n" 5285 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5286 5287 verifyFormat("void f() {\n" 5288 " a<aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaa>(\n" 5289 " a(aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));\n" 5290 "}"); 5291 5292 verifyFormat("template <typename T> class C {};"); 5293 verifyFormat("template <typename T> void f();"); 5294 verifyFormat("template <typename T> void f() {}"); 5295 verifyFormat( 5296 "aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n" 5297 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5298 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> *aaaa =\n" 5299 " new aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n" 5300 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5301 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>(\n" 5302 " bbbbbbbbbbbbbbbbbbbbbbbb);", 5303 getLLVMStyleWithColumns(72)); 5304 EXPECT_EQ("static_cast<A< //\n" 5305 " B> *>(\n" 5306 "\n" 5307 ");", 5308 format("static_cast<A<//\n" 5309 " B>*>(\n" 5310 "\n" 5311 " );")); 5312 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5313 " const typename aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaa);"); 5314 5315 FormatStyle AlwaysBreak = getLLVMStyle(); 5316 AlwaysBreak.AlwaysBreakTemplateDeclarations = true; 5317 verifyFormat("template <typename T>\nclass C {};", AlwaysBreak); 5318 verifyFormat("template <typename T>\nvoid f();", AlwaysBreak); 5319 verifyFormat("template <typename T>\nvoid f() {}", AlwaysBreak); 5320 verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5321 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n" 5322 " ccccccccccccccccccccccccccccccccccccccccccccccc);"); 5323 verifyFormat("template <template <typename> class Fooooooo,\n" 5324 " template <typename> class Baaaaaaar>\n" 5325 "struct C {};", 5326 AlwaysBreak); 5327 verifyFormat("template <typename T> // T can be A, B or C.\n" 5328 "struct C {};", 5329 AlwaysBreak); 5330 verifyFormat("template <enum E> class A {\n" 5331 "public:\n" 5332 " E *f();\n" 5333 "};"); 5334 } 5335 5336 TEST_F(FormatTest, WrapsTemplateParameters) { 5337 FormatStyle Style = getLLVMStyle(); 5338 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 5339 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 5340 verifyFormat( 5341 "template <typename... a> struct q {};\n" 5342 "extern q<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n" 5343 " aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n" 5344 " y;", 5345 Style); 5346 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 5347 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 5348 verifyFormat( 5349 "template <typename... a> struct r {};\n" 5350 "extern r<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n" 5351 " aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n" 5352 " y;", 5353 Style); 5354 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 5355 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 5356 verifyFormat( 5357 "template <typename... a> struct s {};\n" 5358 "extern s<\n" 5359 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n" 5360 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa>\n" 5361 " y;", 5362 Style); 5363 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 5364 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 5365 verifyFormat( 5366 "template <typename... a> struct t {};\n" 5367 "extern t<\n" 5368 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n" 5369 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa>\n" 5370 " y;", 5371 Style); 5372 } 5373 5374 TEST_F(FormatTest, WrapsAtNestedNameSpecifiers) { 5375 verifyFormat( 5376 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 5377 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 5378 verifyFormat( 5379 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 5380 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5381 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());"); 5382 5383 // FIXME: Should we have the extra indent after the second break? 5384 verifyFormat( 5385 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 5386 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 5387 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 5388 5389 verifyFormat( 5390 "aaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb::\n" 5391 " cccccccccccccccccccccccccccccccccccccccccccccc());"); 5392 5393 // Breaking at nested name specifiers is generally not desirable. 5394 verifyFormat( 5395 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5396 " aaaaaaaaaaaaaaaaaaaaaaa);"); 5397 5398 verifyFormat( 5399 "aaaaaaaaaaaaaaaaaa(aaaaaaaa,\n" 5400 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 5401 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5402 " aaaaaaaaaaaaaaaaaaaaa);", 5403 getLLVMStyleWithColumns(74)); 5404 5405 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 5406 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5407 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 5408 } 5409 5410 TEST_F(FormatTest, UnderstandsTemplateParameters) { 5411 verifyFormat("A<int> a;"); 5412 verifyFormat("A<A<A<int>>> a;"); 5413 verifyFormat("A<A<A<int, 2>, 3>, 4> a;"); 5414 verifyFormat("bool x = a < 1 || 2 > a;"); 5415 verifyFormat("bool x = 5 < f<int>();"); 5416 verifyFormat("bool x = f<int>() > 5;"); 5417 verifyFormat("bool x = 5 < a<int>::x;"); 5418 verifyFormat("bool x = a < 4 ? a > 2 : false;"); 5419 verifyFormat("bool x = f() ? a < 2 : a > 2;"); 5420 5421 verifyGoogleFormat("A<A<int>> a;"); 5422 verifyGoogleFormat("A<A<A<int>>> a;"); 5423 verifyGoogleFormat("A<A<A<A<int>>>> a;"); 5424 verifyGoogleFormat("A<A<int> > a;"); 5425 verifyGoogleFormat("A<A<A<int> > > a;"); 5426 verifyGoogleFormat("A<A<A<A<int> > > > a;"); 5427 verifyGoogleFormat("A<::A<int>> a;"); 5428 verifyGoogleFormat("A<::A> a;"); 5429 verifyGoogleFormat("A< ::A> a;"); 5430 verifyGoogleFormat("A< ::A<int> > a;"); 5431 EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A> >> a;", getGoogleStyle())); 5432 EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A>> > a;", getGoogleStyle())); 5433 EXPECT_EQ("A<::A<int>> a;", format("A< ::A<int>> a;", getGoogleStyle())); 5434 EXPECT_EQ("A<::A<int>> a;", format("A<::A<int> > a;", getGoogleStyle())); 5435 EXPECT_EQ("auto x = [] { A<A<A<A>>> a; };", 5436 format("auto x=[]{A<A<A<A> >> a;};", getGoogleStyle())); 5437 5438 verifyFormat("A<A>> a;", getChromiumStyle(FormatStyle::LK_Cpp)); 5439 5440 verifyFormat("test >> a >> b;"); 5441 verifyFormat("test << a >> b;"); 5442 5443 verifyFormat("f<int>();"); 5444 verifyFormat("template <typename T> void f() {}"); 5445 verifyFormat("struct A<std::enable_if<sizeof(T2) < sizeof(int32)>::type>;"); 5446 verifyFormat("struct A<std::enable_if<sizeof(T2) ? sizeof(int32) : " 5447 "sizeof(char)>::type>;"); 5448 verifyFormat("template <class T> struct S<std::is_arithmetic<T>{}> {};"); 5449 verifyFormat("f(a.operator()<A>());"); 5450 verifyFormat("f(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5451 " .template operator()<A>());", 5452 getLLVMStyleWithColumns(35)); 5453 5454 // Not template parameters. 5455 verifyFormat("return a < b && c > d;"); 5456 verifyFormat("void f() {\n" 5457 " while (a < b && c > d) {\n" 5458 " }\n" 5459 "}"); 5460 verifyFormat("template <typename... Types>\n" 5461 "typename enable_if<0 < sizeof...(Types)>::type Foo() {}"); 5462 5463 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5464 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa >> aaaaa);", 5465 getLLVMStyleWithColumns(60)); 5466 verifyFormat("static_assert(is_convertible<A &&, B>::value, \"AAA\");"); 5467 verifyFormat("Constructor(A... a) : a_(X<A>{std::forward<A>(a)}...) {}"); 5468 verifyFormat("< < < < < < < < < < < < < < < < < < < < < < < < < < < < < <"); 5469 } 5470 5471 TEST_F(FormatTest, BitshiftOperatorWidth) { 5472 EXPECT_EQ("int a = 1 << 2; /* foo\n" 5473 " bar */", 5474 format("int a=1<<2; /* foo\n" 5475 " bar */")); 5476 5477 EXPECT_EQ("int b = 256 >> 1; /* foo\n" 5478 " bar */", 5479 format("int b =256>>1 ; /* foo\n" 5480 " bar */")); 5481 } 5482 5483 TEST_F(FormatTest, UnderstandsBinaryOperators) { 5484 verifyFormat("COMPARE(a, ==, b);"); 5485 verifyFormat("auto s = sizeof...(Ts) - 1;"); 5486 } 5487 5488 TEST_F(FormatTest, UnderstandsPointersToMembers) { 5489 verifyFormat("int A::*x;"); 5490 verifyFormat("int (S::*func)(void *);"); 5491 verifyFormat("void f() { int (S::*func)(void *); }"); 5492 verifyFormat("typedef bool *(Class::*Member)() const;"); 5493 verifyFormat("void f() {\n" 5494 " (a->*f)();\n" 5495 " a->*x;\n" 5496 " (a.*f)();\n" 5497 " ((*a).*f)();\n" 5498 " a.*x;\n" 5499 "}"); 5500 verifyFormat("void f() {\n" 5501 " (a->*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n" 5502 " aaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);\n" 5503 "}"); 5504 verifyFormat( 5505 "(aaaaaaaaaa->*bbbbbbb)(\n" 5506 " aaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 5507 FormatStyle Style = getLLVMStyle(); 5508 Style.PointerAlignment = FormatStyle::PAS_Left; 5509 verifyFormat("typedef bool* (Class::*Member)() const;", Style); 5510 } 5511 5512 TEST_F(FormatTest, UnderstandsUnaryOperators) { 5513 verifyFormat("int a = -2;"); 5514 verifyFormat("f(-1, -2, -3);"); 5515 verifyFormat("a[-1] = 5;"); 5516 verifyFormat("int a = 5 + -2;"); 5517 verifyFormat("if (i == -1) {\n}"); 5518 verifyFormat("if (i != -1) {\n}"); 5519 verifyFormat("if (i > -1) {\n}"); 5520 verifyFormat("if (i < -1) {\n}"); 5521 verifyFormat("++(a->f());"); 5522 verifyFormat("--(a->f());"); 5523 verifyFormat("(a->f())++;"); 5524 verifyFormat("a[42]++;"); 5525 verifyFormat("if (!(a->f())) {\n}"); 5526 5527 verifyFormat("a-- > b;"); 5528 verifyFormat("b ? -a : c;"); 5529 verifyFormat("n * sizeof char16;"); 5530 verifyFormat("n * alignof char16;", getGoogleStyle()); 5531 verifyFormat("sizeof(char);"); 5532 verifyFormat("alignof(char);", getGoogleStyle()); 5533 5534 verifyFormat("return -1;"); 5535 verifyFormat("switch (a) {\n" 5536 "case -1:\n" 5537 " break;\n" 5538 "}"); 5539 verifyFormat("#define X -1"); 5540 verifyFormat("#define X -kConstant"); 5541 5542 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {-5, +3};"); 5543 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {+5, -3};"); 5544 5545 verifyFormat("int a = /* confusing comment */ -1;"); 5546 // FIXME: The space after 'i' is wrong, but hopefully, this is a rare case. 5547 verifyFormat("int a = i /* confusing comment */++;"); 5548 } 5549 5550 TEST_F(FormatTest, DoesNotIndentRelativeToUnaryOperators) { 5551 verifyFormat("if (!aaaaaaaaaa( // break\n" 5552 " aaaaa)) {\n" 5553 "}"); 5554 verifyFormat("aaaaaaaaaa(!aaaaaaaaaa( // break\n" 5555 " aaaaa));"); 5556 verifyFormat("*aaa = aaaaaaa( // break\n" 5557 " bbbbbb);"); 5558 } 5559 5560 TEST_F(FormatTest, UnderstandsOverloadedOperators) { 5561 verifyFormat("bool operator<();"); 5562 verifyFormat("bool operator>();"); 5563 verifyFormat("bool operator=();"); 5564 verifyFormat("bool operator==();"); 5565 verifyFormat("bool operator!=();"); 5566 verifyFormat("int operator+();"); 5567 verifyFormat("int operator++();"); 5568 verifyFormat("bool operator,();"); 5569 verifyFormat("bool operator();"); 5570 verifyFormat("bool operator()();"); 5571 verifyFormat("bool operator[]();"); 5572 verifyFormat("operator bool();"); 5573 verifyFormat("operator int();"); 5574 verifyFormat("operator void *();"); 5575 verifyFormat("operator SomeType<int>();"); 5576 verifyFormat("operator SomeType<int, int>();"); 5577 verifyFormat("operator SomeType<SomeType<int>>();"); 5578 verifyFormat("void *operator new(std::size_t size);"); 5579 verifyFormat("void *operator new[](std::size_t size);"); 5580 verifyFormat("void operator delete(void *ptr);"); 5581 verifyFormat("void operator delete[](void *ptr);"); 5582 verifyFormat("template <typename AAAAAAA, typename BBBBBBB>\n" 5583 "AAAAAAA operator/(const AAAAAAA &a, BBBBBBB &b);"); 5584 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa operator,(\n" 5585 " aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaaaaaaaaaaaaaaaaaaa) const;"); 5586 5587 verifyFormat( 5588 "ostream &operator<<(ostream &OutputStream,\n" 5589 " SomeReallyLongType WithSomeReallyLongValue);"); 5590 verifyFormat("bool operator<(const aaaaaaaaaaaaaaaaaaaaa &left,\n" 5591 " const aaaaaaaaaaaaaaaaaaaaa &right) {\n" 5592 " return left.group < right.group;\n" 5593 "}"); 5594 verifyFormat("SomeType &operator=(const SomeType &S);"); 5595 verifyFormat("f.template operator()<int>();"); 5596 5597 verifyGoogleFormat("operator void*();"); 5598 verifyGoogleFormat("operator SomeType<SomeType<int>>();"); 5599 verifyGoogleFormat("operator ::A();"); 5600 5601 verifyFormat("using A::operator+;"); 5602 verifyFormat("inline A operator^(const A &lhs, const A &rhs) {}\n" 5603 "int i;"); 5604 } 5605 5606 TEST_F(FormatTest, UnderstandsFunctionRefQualification) { 5607 verifyFormat("Deleted &operator=(const Deleted &) & = default;"); 5608 verifyFormat("Deleted &operator=(const Deleted &) && = delete;"); 5609 verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;"); 5610 verifyFormat("SomeType MemberFunction(const Deleted &) && = delete;"); 5611 verifyFormat("Deleted &operator=(const Deleted &) &;"); 5612 verifyFormat("Deleted &operator=(const Deleted &) &&;"); 5613 verifyFormat("SomeType MemberFunction(const Deleted &) &;"); 5614 verifyFormat("SomeType MemberFunction(const Deleted &) &&;"); 5615 verifyFormat("SomeType MemberFunction(const Deleted &) && {}"); 5616 verifyFormat("SomeType MemberFunction(const Deleted &) && final {}"); 5617 verifyFormat("SomeType MemberFunction(const Deleted &) && override {}"); 5618 verifyFormat("void Fn(T const &) const &;"); 5619 verifyFormat("void Fn(T const volatile &&) const volatile &&;"); 5620 verifyFormat("template <typename T>\n" 5621 "void F(T) && = delete;", 5622 getGoogleStyle()); 5623 5624 FormatStyle AlignLeft = getLLVMStyle(); 5625 AlignLeft.PointerAlignment = FormatStyle::PAS_Left; 5626 verifyFormat("void A::b() && {}", AlignLeft); 5627 verifyFormat("Deleted& operator=(const Deleted&) & = default;", AlignLeft); 5628 verifyFormat("SomeType MemberFunction(const Deleted&) & = delete;", 5629 AlignLeft); 5630 verifyFormat("Deleted& operator=(const Deleted&) &;", AlignLeft); 5631 verifyFormat("SomeType MemberFunction(const Deleted&) &;", AlignLeft); 5632 verifyFormat("auto Function(T t) & -> void {}", AlignLeft); 5633 verifyFormat("auto Function(T... t) & -> void {}", AlignLeft); 5634 verifyFormat("auto Function(T) & -> void {}", AlignLeft); 5635 verifyFormat("auto Function(T) & -> void;", AlignLeft); 5636 verifyFormat("void Fn(T const&) const&;", AlignLeft); 5637 verifyFormat("void Fn(T const volatile&&) const volatile&&;", AlignLeft); 5638 5639 FormatStyle Spaces = getLLVMStyle(); 5640 Spaces.SpacesInCStyleCastParentheses = true; 5641 verifyFormat("Deleted &operator=(const Deleted &) & = default;", Spaces); 5642 verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;", Spaces); 5643 verifyFormat("Deleted &operator=(const Deleted &) &;", Spaces); 5644 verifyFormat("SomeType MemberFunction(const Deleted &) &;", Spaces); 5645 5646 Spaces.SpacesInCStyleCastParentheses = false; 5647 Spaces.SpacesInParentheses = true; 5648 verifyFormat("Deleted &operator=( const Deleted & ) & = default;", Spaces); 5649 verifyFormat("SomeType MemberFunction( const Deleted & ) & = delete;", Spaces); 5650 verifyFormat("Deleted &operator=( const Deleted & ) &;", Spaces); 5651 verifyFormat("SomeType MemberFunction( const Deleted & ) &;", Spaces); 5652 } 5653 5654 TEST_F(FormatTest, UnderstandsNewAndDelete) { 5655 verifyFormat("void f() {\n" 5656 " A *a = new A;\n" 5657 " A *a = new (placement) A;\n" 5658 " delete a;\n" 5659 " delete (A *)a;\n" 5660 "}"); 5661 verifyFormat("new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n" 5662 " typename aaaaaaaaaaaaaaaaaaaaaaaa();"); 5663 verifyFormat("auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 5664 " new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n" 5665 " typename aaaaaaaaaaaaaaaaaaaaaaaa();"); 5666 verifyFormat("delete[] h->p;"); 5667 } 5668 5669 TEST_F(FormatTest, UnderstandsUsesOfStarAndAmp) { 5670 verifyFormat("int *f(int *a) {}"); 5671 verifyFormat("int main(int argc, char **argv) {}"); 5672 verifyFormat("Test::Test(int b) : a(b * b) {}"); 5673 verifyIndependentOfContext("f(a, *a);"); 5674 verifyFormat("void g() { f(*a); }"); 5675 verifyIndependentOfContext("int a = b * 10;"); 5676 verifyIndependentOfContext("int a = 10 * b;"); 5677 verifyIndependentOfContext("int a = b * c;"); 5678 verifyIndependentOfContext("int a += b * c;"); 5679 verifyIndependentOfContext("int a -= b * c;"); 5680 verifyIndependentOfContext("int a *= b * c;"); 5681 verifyIndependentOfContext("int a /= b * c;"); 5682 verifyIndependentOfContext("int a = *b;"); 5683 verifyIndependentOfContext("int a = *b * c;"); 5684 verifyIndependentOfContext("int a = b * *c;"); 5685 verifyIndependentOfContext("int a = b * (10);"); 5686 verifyIndependentOfContext("S << b * (10);"); 5687 verifyIndependentOfContext("return 10 * b;"); 5688 verifyIndependentOfContext("return *b * *c;"); 5689 verifyIndependentOfContext("return a & ~b;"); 5690 verifyIndependentOfContext("f(b ? *c : *d);"); 5691 verifyIndependentOfContext("int a = b ? *c : *d;"); 5692 verifyIndependentOfContext("*b = a;"); 5693 verifyIndependentOfContext("a * ~b;"); 5694 verifyIndependentOfContext("a * !b;"); 5695 verifyIndependentOfContext("a * +b;"); 5696 verifyIndependentOfContext("a * -b;"); 5697 verifyIndependentOfContext("a * ++b;"); 5698 verifyIndependentOfContext("a * --b;"); 5699 verifyIndependentOfContext("a[4] * b;"); 5700 verifyIndependentOfContext("a[a * a] = 1;"); 5701 verifyIndependentOfContext("f() * b;"); 5702 verifyIndependentOfContext("a * [self dostuff];"); 5703 verifyIndependentOfContext("int x = a * (a + b);"); 5704 verifyIndependentOfContext("(a *)(a + b);"); 5705 verifyIndependentOfContext("*(int *)(p & ~3UL) = 0;"); 5706 verifyIndependentOfContext("int *pa = (int *)&a;"); 5707 verifyIndependentOfContext("return sizeof(int **);"); 5708 verifyIndependentOfContext("return sizeof(int ******);"); 5709 verifyIndependentOfContext("return (int **&)a;"); 5710 verifyIndependentOfContext("f((*PointerToArray)[10]);"); 5711 verifyFormat("void f(Type (*parameter)[10]) {}"); 5712 verifyFormat("void f(Type (¶meter)[10]) {}"); 5713 verifyGoogleFormat("return sizeof(int**);"); 5714 verifyIndependentOfContext("Type **A = static_cast<Type **>(P);"); 5715 verifyGoogleFormat("Type** A = static_cast<Type**>(P);"); 5716 verifyFormat("auto a = [](int **&, int ***) {};"); 5717 verifyFormat("auto PointerBinding = [](const char *S) {};"); 5718 verifyFormat("typedef typeof(int(int, int)) *MyFunc;"); 5719 verifyFormat("[](const decltype(*a) &value) {}"); 5720 verifyFormat("decltype(a * b) F();"); 5721 verifyFormat("#define MACRO() [](A *a) { return 1; }"); 5722 verifyFormat("Constructor() : member([](A *a, B *b) {}) {}"); 5723 verifyIndependentOfContext("typedef void (*f)(int *a);"); 5724 verifyIndependentOfContext("int i{a * b};"); 5725 verifyIndependentOfContext("aaa && aaa->f();"); 5726 verifyIndependentOfContext("int x = ~*p;"); 5727 verifyFormat("Constructor() : a(a), area(width * height) {}"); 5728 verifyFormat("Constructor() : a(a), area(a, width * height) {}"); 5729 verifyGoogleFormat("MACRO Constructor(const int& i) : a(a), b(b) {}"); 5730 verifyFormat("void f() { f(a, c * d); }"); 5731 verifyFormat("void f() { f(new a(), c * d); }"); 5732 verifyFormat("void f(const MyOverride &override);"); 5733 verifyFormat("void f(const MyFinal &final);"); 5734 verifyIndependentOfContext("bool a = f() && override.f();"); 5735 verifyIndependentOfContext("bool a = f() && final.f();"); 5736 5737 verifyIndependentOfContext("InvalidRegions[*R] = 0;"); 5738 5739 verifyIndependentOfContext("A<int *> a;"); 5740 verifyIndependentOfContext("A<int **> a;"); 5741 verifyIndependentOfContext("A<int *, int *> a;"); 5742 verifyIndependentOfContext("A<int *[]> a;"); 5743 verifyIndependentOfContext( 5744 "const char *const p = reinterpret_cast<const char *const>(q);"); 5745 verifyIndependentOfContext("A<int **, int **> a;"); 5746 verifyIndependentOfContext("void f(int *a = d * e, int *b = c * d);"); 5747 verifyFormat("for (char **a = b; *a; ++a) {\n}"); 5748 verifyFormat("for (; a && b;) {\n}"); 5749 verifyFormat("bool foo = true && [] { return false; }();"); 5750 5751 verifyFormat( 5752 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5753 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa, *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5754 5755 verifyGoogleFormat("int const* a = &b;"); 5756 verifyGoogleFormat("**outparam = 1;"); 5757 verifyGoogleFormat("*outparam = a * b;"); 5758 verifyGoogleFormat("int main(int argc, char** argv) {}"); 5759 verifyGoogleFormat("A<int*> a;"); 5760 verifyGoogleFormat("A<int**> a;"); 5761 verifyGoogleFormat("A<int*, int*> a;"); 5762 verifyGoogleFormat("A<int**, int**> a;"); 5763 verifyGoogleFormat("f(b ? *c : *d);"); 5764 verifyGoogleFormat("int a = b ? *c : *d;"); 5765 verifyGoogleFormat("Type* t = **x;"); 5766 verifyGoogleFormat("Type* t = *++*x;"); 5767 verifyGoogleFormat("*++*x;"); 5768 verifyGoogleFormat("Type* t = const_cast<T*>(&*x);"); 5769 verifyGoogleFormat("Type* t = x++ * y;"); 5770 verifyGoogleFormat( 5771 "const char* const p = reinterpret_cast<const char* const>(q);"); 5772 verifyGoogleFormat("void f(int i = 0, SomeType** temps = NULL);"); 5773 verifyGoogleFormat("void f(Bar* a = nullptr, Bar* b);"); 5774 verifyGoogleFormat("template <typename T>\n" 5775 "void f(int i = 0, SomeType** temps = NULL);"); 5776 5777 FormatStyle Left = getLLVMStyle(); 5778 Left.PointerAlignment = FormatStyle::PAS_Left; 5779 verifyFormat("x = *a(x) = *a(y);", Left); 5780 verifyFormat("for (;; *a = b) {\n}", Left); 5781 verifyFormat("return *this += 1;", Left); 5782 verifyFormat("throw *x;", Left); 5783 verifyFormat("delete *x;", Left); 5784 verifyFormat("typedef typeof(int(int, int))* MyFuncPtr;", Left); 5785 verifyFormat("[](const decltype(*a)* ptr) {}", Left); 5786 verifyFormat("typedef typeof /*comment*/ (int(int, int))* MyFuncPtr;", Left); 5787 5788 verifyIndependentOfContext("a = *(x + y);"); 5789 verifyIndependentOfContext("a = &(x + y);"); 5790 verifyIndependentOfContext("*(x + y).call();"); 5791 verifyIndependentOfContext("&(x + y)->call();"); 5792 verifyFormat("void f() { &(*I).first; }"); 5793 5794 verifyIndependentOfContext("f(b * /* confusing comment */ ++c);"); 5795 verifyFormat( 5796 "int *MyValues = {\n" 5797 " *A, // Operator detection might be confused by the '{'\n" 5798 " *BB // Operator detection might be confused by previous comment\n" 5799 "};"); 5800 5801 verifyIndependentOfContext("if (int *a = &b)"); 5802 verifyIndependentOfContext("if (int &a = *b)"); 5803 verifyIndependentOfContext("if (a & b[i])"); 5804 verifyIndependentOfContext("if (a::b::c::d & b[i])"); 5805 verifyIndependentOfContext("if (*b[i])"); 5806 verifyIndependentOfContext("if (int *a = (&b))"); 5807 verifyIndependentOfContext("while (int *a = &b)"); 5808 verifyIndependentOfContext("size = sizeof *a;"); 5809 verifyIndependentOfContext("if (a && (b = c))"); 5810 verifyFormat("void f() {\n" 5811 " for (const int &v : Values) {\n" 5812 " }\n" 5813 "}"); 5814 verifyFormat("for (int i = a * a; i < 10; ++i) {\n}"); 5815 verifyFormat("for (int i = 0; i < a * a; ++i) {\n}"); 5816 verifyGoogleFormat("for (int i = 0; i * 2 < z; i *= 2) {\n}"); 5817 5818 verifyFormat("#define A (!a * b)"); 5819 verifyFormat("#define MACRO \\\n" 5820 " int *i = a * b; \\\n" 5821 " void f(a *b);", 5822 getLLVMStyleWithColumns(19)); 5823 5824 verifyIndependentOfContext("A = new SomeType *[Length];"); 5825 verifyIndependentOfContext("A = new SomeType *[Length]();"); 5826 verifyIndependentOfContext("T **t = new T *;"); 5827 verifyIndependentOfContext("T **t = new T *();"); 5828 verifyGoogleFormat("A = new SomeType*[Length]();"); 5829 verifyGoogleFormat("A = new SomeType*[Length];"); 5830 verifyGoogleFormat("T** t = new T*;"); 5831 verifyGoogleFormat("T** t = new T*();"); 5832 5833 verifyFormat("STATIC_ASSERT((a & b) == 0);"); 5834 verifyFormat("STATIC_ASSERT(0 == (a & b));"); 5835 verifyFormat("template <bool a, bool b> " 5836 "typename t::if<x && y>::type f() {}"); 5837 verifyFormat("template <int *y> f() {}"); 5838 verifyFormat("vector<int *> v;"); 5839 verifyFormat("vector<int *const> v;"); 5840 verifyFormat("vector<int *const **const *> v;"); 5841 verifyFormat("vector<int *volatile> v;"); 5842 verifyFormat("vector<a * b> v;"); 5843 verifyFormat("foo<b && false>();"); 5844 verifyFormat("foo<b & 1>();"); 5845 verifyFormat("decltype(*::std::declval<const T &>()) void F();"); 5846 verifyFormat( 5847 "template <class T, class = typename std::enable_if<\n" 5848 " std::is_integral<T>::value &&\n" 5849 " (sizeof(T) > 1 || sizeof(T) < 8)>::type>\n" 5850 "void F();", 5851 getLLVMStyleWithColumns(70)); 5852 verifyFormat( 5853 "template <class T,\n" 5854 " class = typename std::enable_if<\n" 5855 " std::is_integral<T>::value &&\n" 5856 " (sizeof(T) > 1 || sizeof(T) < 8)>::type,\n" 5857 " class U>\n" 5858 "void F();", 5859 getLLVMStyleWithColumns(70)); 5860 verifyFormat( 5861 "template <class T,\n" 5862 " class = typename ::std::enable_if<\n" 5863 " ::std::is_array<T>{} && ::std::is_array<T>{}>::type>\n" 5864 "void F();", 5865 getGoogleStyleWithColumns(68)); 5866 5867 verifyIndependentOfContext("MACRO(int *i);"); 5868 verifyIndependentOfContext("MACRO(auto *a);"); 5869 verifyIndependentOfContext("MACRO(const A *a);"); 5870 verifyIndependentOfContext("MACRO(A *const a);"); 5871 verifyIndependentOfContext("MACRO('0' <= c && c <= '9');"); 5872 verifyFormat("void f() { f(float{1}, a * a); }"); 5873 // FIXME: Is there a way to make this work? 5874 // verifyIndependentOfContext("MACRO(A *a);"); 5875 5876 verifyFormat("DatumHandle const *operator->() const { return input_; }"); 5877 verifyFormat("return options != nullptr && operator==(*options);"); 5878 5879 EXPECT_EQ("#define OP(x) \\\n" 5880 " ostream &operator<<(ostream &s, const A &a) { \\\n" 5881 " return s << a.DebugString(); \\\n" 5882 " }", 5883 format("#define OP(x) \\\n" 5884 " ostream &operator<<(ostream &s, const A &a) { \\\n" 5885 " return s << a.DebugString(); \\\n" 5886 " }", 5887 getLLVMStyleWithColumns(50))); 5888 5889 // FIXME: We cannot handle this case yet; we might be able to figure out that 5890 // foo<x> d > v; doesn't make sense. 5891 verifyFormat("foo<a<b && c> d> v;"); 5892 5893 FormatStyle PointerMiddle = getLLVMStyle(); 5894 PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle; 5895 verifyFormat("delete *x;", PointerMiddle); 5896 verifyFormat("int * x;", PointerMiddle); 5897 verifyFormat("template <int * y> f() {}", PointerMiddle); 5898 verifyFormat("int * f(int * a) {}", PointerMiddle); 5899 verifyFormat("int main(int argc, char ** argv) {}", PointerMiddle); 5900 verifyFormat("Test::Test(int b) : a(b * b) {}", PointerMiddle); 5901 verifyFormat("A<int *> a;", PointerMiddle); 5902 verifyFormat("A<int **> a;", PointerMiddle); 5903 verifyFormat("A<int *, int *> a;", PointerMiddle); 5904 verifyFormat("A<int * []> a;", PointerMiddle); 5905 verifyFormat("A = new SomeType *[Length]();", PointerMiddle); 5906 verifyFormat("A = new SomeType *[Length];", PointerMiddle); 5907 verifyFormat("T ** t = new T *;", PointerMiddle); 5908 5909 // Member function reference qualifiers aren't binary operators. 5910 verifyFormat("string // break\n" 5911 "operator()() & {}"); 5912 verifyFormat("string // break\n" 5913 "operator()() && {}"); 5914 verifyGoogleFormat("template <typename T>\n" 5915 "auto x() & -> int {}"); 5916 } 5917 5918 TEST_F(FormatTest, UnderstandsAttributes) { 5919 verifyFormat("SomeType s __attribute__((unused)) (InitValue);"); 5920 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa __attribute__((unused))\n" 5921 "aaaaaaaaaaaaaaaaaaaaaaa(int i);"); 5922 FormatStyle AfterType = getLLVMStyle(); 5923 AfterType.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions; 5924 verifyFormat("__attribute__((nodebug)) void\n" 5925 "foo() {}\n", 5926 AfterType); 5927 } 5928 5929 TEST_F(FormatTest, UnderstandsEllipsis) { 5930 verifyFormat("int printf(const char *fmt, ...);"); 5931 verifyFormat("template <class... Ts> void Foo(Ts... ts) { Foo(ts...); }"); 5932 verifyFormat("template <class... Ts> void Foo(Ts *... ts) {}"); 5933 5934 FormatStyle PointersLeft = getLLVMStyle(); 5935 PointersLeft.PointerAlignment = FormatStyle::PAS_Left; 5936 verifyFormat("template <class... Ts> void Foo(Ts*... ts) {}", PointersLeft); 5937 } 5938 5939 TEST_F(FormatTest, AdaptivelyFormatsPointersAndReferences) { 5940 EXPECT_EQ("int *a;\n" 5941 "int *a;\n" 5942 "int *a;", 5943 format("int *a;\n" 5944 "int* a;\n" 5945 "int *a;", 5946 getGoogleStyle())); 5947 EXPECT_EQ("int* a;\n" 5948 "int* a;\n" 5949 "int* a;", 5950 format("int* a;\n" 5951 "int* a;\n" 5952 "int *a;", 5953 getGoogleStyle())); 5954 EXPECT_EQ("int *a;\n" 5955 "int *a;\n" 5956 "int *a;", 5957 format("int *a;\n" 5958 "int * a;\n" 5959 "int * a;", 5960 getGoogleStyle())); 5961 EXPECT_EQ("auto x = [] {\n" 5962 " int *a;\n" 5963 " int *a;\n" 5964 " int *a;\n" 5965 "};", 5966 format("auto x=[]{int *a;\n" 5967 "int * a;\n" 5968 "int * a;};", 5969 getGoogleStyle())); 5970 } 5971 5972 TEST_F(FormatTest, UnderstandsRvalueReferences) { 5973 verifyFormat("int f(int &&a) {}"); 5974 verifyFormat("int f(int a, char &&b) {}"); 5975 verifyFormat("void f() { int &&a = b; }"); 5976 verifyGoogleFormat("int f(int a, char&& b) {}"); 5977 verifyGoogleFormat("void f() { int&& a = b; }"); 5978 5979 verifyIndependentOfContext("A<int &&> a;"); 5980 verifyIndependentOfContext("A<int &&, int &&> a;"); 5981 verifyGoogleFormat("A<int&&> a;"); 5982 verifyGoogleFormat("A<int&&, int&&> a;"); 5983 5984 // Not rvalue references: 5985 verifyFormat("template <bool B, bool C> class A {\n" 5986 " static_assert(B && C, \"Something is wrong\");\n" 5987 "};"); 5988 verifyGoogleFormat("#define IF(a, b, c) if (a && (b == c))"); 5989 verifyGoogleFormat("#define WHILE(a, b, c) while (a && (b == c))"); 5990 verifyFormat("#define A(a, b) (a && b)"); 5991 } 5992 5993 TEST_F(FormatTest, FormatsBinaryOperatorsPrecedingEquals) { 5994 verifyFormat("void f() {\n" 5995 " x[aaaaaaaaa -\n" 5996 " b] = 23;\n" 5997 "}", 5998 getLLVMStyleWithColumns(15)); 5999 } 6000 6001 TEST_F(FormatTest, FormatsCasts) { 6002 verifyFormat("Type *A = static_cast<Type *>(P);"); 6003 verifyFormat("Type *A = (Type *)P;"); 6004 verifyFormat("Type *A = (vector<Type *, int *>)P;"); 6005 verifyFormat("int a = (int)(2.0f);"); 6006 verifyFormat("int a = (int)2.0f;"); 6007 verifyFormat("x[(int32)y];"); 6008 verifyFormat("x = (int32)y;"); 6009 verifyFormat("#define AA(X) sizeof(((X *)NULL)->a)"); 6010 verifyFormat("int a = (int)*b;"); 6011 verifyFormat("int a = (int)2.0f;"); 6012 verifyFormat("int a = (int)~0;"); 6013 verifyFormat("int a = (int)++a;"); 6014 verifyFormat("int a = (int)sizeof(int);"); 6015 verifyFormat("int a = (int)+2;"); 6016 verifyFormat("my_int a = (my_int)2.0f;"); 6017 verifyFormat("my_int a = (my_int)sizeof(int);"); 6018 verifyFormat("return (my_int)aaa;"); 6019 verifyFormat("#define x ((int)-1)"); 6020 verifyFormat("#define LENGTH(x, y) (x) - (y) + 1"); 6021 verifyFormat("#define p(q) ((int *)&q)"); 6022 verifyFormat("fn(a)(b) + 1;"); 6023 6024 verifyFormat("void f() { my_int a = (my_int)*b; }"); 6025 verifyFormat("void f() { return P ? (my_int)*P : (my_int)0; }"); 6026 verifyFormat("my_int a = (my_int)~0;"); 6027 verifyFormat("my_int a = (my_int)++a;"); 6028 verifyFormat("my_int a = (my_int)-2;"); 6029 verifyFormat("my_int a = (my_int)1;"); 6030 verifyFormat("my_int a = (my_int *)1;"); 6031 verifyFormat("my_int a = (const my_int)-1;"); 6032 verifyFormat("my_int a = (const my_int *)-1;"); 6033 verifyFormat("my_int a = (my_int)(my_int)-1;"); 6034 verifyFormat("my_int a = (ns::my_int)-2;"); 6035 verifyFormat("case (my_int)ONE:"); 6036 verifyFormat("auto x = (X)this;"); 6037 6038 // FIXME: single value wrapped with paren will be treated as cast. 6039 verifyFormat("void f(int i = (kValue)*kMask) {}"); 6040 6041 verifyFormat("{ (void)F; }"); 6042 6043 // Don't break after a cast's 6044 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 6045 " (aaaaaaaaaaaaaaaaaaaaaaaaaa *)(aaaaaaaaaaaaaaaaaaaaaa +\n" 6046 " bbbbbbbbbbbbbbbbbbbbbb);"); 6047 6048 // These are not casts. 6049 verifyFormat("void f(int *) {}"); 6050 verifyFormat("f(foo)->b;"); 6051 verifyFormat("f(foo).b;"); 6052 verifyFormat("f(foo)(b);"); 6053 verifyFormat("f(foo)[b];"); 6054 verifyFormat("[](foo) { return 4; }(bar);"); 6055 verifyFormat("(*funptr)(foo)[4];"); 6056 verifyFormat("funptrs[4](foo)[4];"); 6057 verifyFormat("void f(int *);"); 6058 verifyFormat("void f(int *) = 0;"); 6059 verifyFormat("void f(SmallVector<int>) {}"); 6060 verifyFormat("void f(SmallVector<int>);"); 6061 verifyFormat("void f(SmallVector<int>) = 0;"); 6062 verifyFormat("void f(int i = (kA * kB) & kMask) {}"); 6063 verifyFormat("int a = sizeof(int) * b;"); 6064 verifyFormat("int a = alignof(int) * b;", getGoogleStyle()); 6065 verifyFormat("template <> void f<int>(int i) SOME_ANNOTATION;"); 6066 verifyFormat("f(\"%\" SOME_MACRO(ll) \"d\");"); 6067 verifyFormat("aaaaa &operator=(const aaaaa &) LLVM_DELETED_FUNCTION;"); 6068 6069 // These are not casts, but at some point were confused with casts. 6070 verifyFormat("virtual void foo(int *) override;"); 6071 verifyFormat("virtual void foo(char &) const;"); 6072 verifyFormat("virtual void foo(int *a, char *) const;"); 6073 verifyFormat("int a = sizeof(int *) + b;"); 6074 verifyFormat("int a = alignof(int *) + b;", getGoogleStyle()); 6075 verifyFormat("bool b = f(g<int>) && c;"); 6076 verifyFormat("typedef void (*f)(int i) func;"); 6077 6078 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *foo = (aaaaaaaaaaaaaaaaa *)\n" 6079 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 6080 // FIXME: The indentation here is not ideal. 6081 verifyFormat( 6082 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6083 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = (*cccccccccccccccc)\n" 6084 " [dddddddddddddddddddddddddddddddddddddddddddddddddddddddd];"); 6085 } 6086 6087 TEST_F(FormatTest, FormatsFunctionTypes) { 6088 verifyFormat("A<bool()> a;"); 6089 verifyFormat("A<SomeType()> a;"); 6090 verifyFormat("A<void (*)(int, std::string)> a;"); 6091 verifyFormat("A<void *(int)>;"); 6092 verifyFormat("void *(*a)(int *, SomeType *);"); 6093 verifyFormat("int (*func)(void *);"); 6094 verifyFormat("void f() { int (*func)(void *); }"); 6095 verifyFormat("template <class CallbackClass>\n" 6096 "using MyCallback = void (CallbackClass::*)(SomeObject *Data);"); 6097 6098 verifyGoogleFormat("A<void*(int*, SomeType*)>;"); 6099 verifyGoogleFormat("void* (*a)(int);"); 6100 verifyGoogleFormat( 6101 "template <class CallbackClass>\n" 6102 "using MyCallback = void (CallbackClass::*)(SomeObject* Data);"); 6103 6104 // Other constructs can look somewhat like function types: 6105 verifyFormat("A<sizeof(*x)> a;"); 6106 verifyFormat("#define DEREF_AND_CALL_F(x) f(*x)"); 6107 verifyFormat("some_var = function(*some_pointer_var)[0];"); 6108 verifyFormat("void f() { function(*some_pointer_var)[0] = 10; }"); 6109 verifyFormat("int x = f(&h)();"); 6110 verifyFormat("returnsFunction(¶m1, ¶m2)(param);"); 6111 verifyFormat("std::function<\n" 6112 " LooooooooooongTemplatedType<\n" 6113 " SomeType>*(\n" 6114 " LooooooooooooooooongType type)>\n" 6115 " function;", 6116 getGoogleStyleWithColumns(40)); 6117 } 6118 6119 TEST_F(FormatTest, FormatsPointersToArrayTypes) { 6120 verifyFormat("A (*foo_)[6];"); 6121 verifyFormat("vector<int> (*foo_)[6];"); 6122 } 6123 6124 TEST_F(FormatTest, BreaksLongVariableDeclarations) { 6125 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 6126 " LoooooooooooooooooooooooooooooooooooooooongVariable;"); 6127 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType const\n" 6128 " LoooooooooooooooooooooooooooooooooooooooongVariable;"); 6129 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 6130 " *LoooooooooooooooooooooooooooooooooooooooongVariable;"); 6131 6132 // Different ways of ()-initializiation. 6133 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 6134 " LoooooooooooooooooooooooooooooooooooooooongVariable(1);"); 6135 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 6136 " LoooooooooooooooooooooooooooooooooooooooongVariable(a);"); 6137 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 6138 " LoooooooooooooooooooooooooooooooooooooooongVariable({});"); 6139 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 6140 " LoooooooooooooooooooooooooooooooooooooongVariable([A a]);"); 6141 6142 // Lambdas should not confuse the variable declaration heuristic. 6143 verifyFormat("LooooooooooooooooongType\n" 6144 " variable(nullptr, [](A *a) {});", 6145 getLLVMStyleWithColumns(40)); 6146 } 6147 6148 TEST_F(FormatTest, BreaksLongDeclarations) { 6149 verifyFormat("typedef LoooooooooooooooooooooooooooooooooooooooongType\n" 6150 " AnotherNameForTheLongType;"); 6151 verifyFormat("typedef LongTemplateType<aaaaaaaaaaaaaaaaaaa()>\n" 6152 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6153 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 6154 "LoooooooooooooooooooooooooooooooongFunctionDeclaration();"); 6155 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType *\n" 6156 "LoooooooooooooooooooooooooooooooongFunctionDeclaration();"); 6157 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 6158 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 6159 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType MACRO\n" 6160 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 6161 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType const\n" 6162 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 6163 verifyFormat("decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n" 6164 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 6165 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 6166 "LooooooooooooooooooooooooooongFunctionDeclaration(T... t);"); 6167 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 6168 "LooooooooooooooooooooooooooongFunctionDeclaration(T /*t*/) {}"); 6169 FormatStyle Indented = getLLVMStyle(); 6170 Indented.IndentWrappedFunctionNames = true; 6171 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 6172 " LoooooooooooooooooooooooooooooooongFunctionDeclaration();", 6173 Indented); 6174 verifyFormat( 6175 "LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 6176 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}", 6177 Indented); 6178 verifyFormat( 6179 "LoooooooooooooooooooooooooooooooooooooooongReturnType const\n" 6180 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}", 6181 Indented); 6182 verifyFormat( 6183 "decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n" 6184 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}", 6185 Indented); 6186 6187 // FIXME: Without the comment, this breaks after "(". 6188 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType // break\n" 6189 " (*LoooooooooooooooooooooooooooongFunctionTypeVarialbe)();", 6190 getGoogleStyle()); 6191 6192 verifyFormat("int *someFunction(int LoooooooooooooooooooongParam1,\n" 6193 " int LoooooooooooooooooooongParam2) {}"); 6194 verifyFormat( 6195 "TypeSpecDecl *TypeSpecDecl::Create(ASTContext &C, DeclContext *DC,\n" 6196 " SourceLocation L, IdentifierIn *II,\n" 6197 " Type *T) {}"); 6198 verifyFormat("ReallyLongReturnType<TemplateParam1, TemplateParam2>\n" 6199 "ReallyReaaallyLongFunctionName(\n" 6200 " const std::string &SomeParameter,\n" 6201 " const SomeType<string, SomeOtherTemplateParameter>\n" 6202 " &ReallyReallyLongParameterName,\n" 6203 " const SomeType<string, SomeOtherTemplateParameter>\n" 6204 " &AnotherLongParameterName) {}"); 6205 verifyFormat("template <typename A>\n" 6206 "SomeLoooooooooooooooooooooongType<\n" 6207 " typename some_namespace::SomeOtherType<A>::Type>\n" 6208 "Function() {}"); 6209 6210 verifyGoogleFormat( 6211 "aaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaa<aaaaaaaaaaaaa, aaaaaaaaaaaa>\n" 6212 " aaaaaaaaaaaaaaaaaaaaaaa;"); 6213 verifyGoogleFormat( 6214 "TypeSpecDecl* TypeSpecDecl::Create(ASTContext& C, DeclContext* DC,\n" 6215 " SourceLocation L) {}"); 6216 verifyGoogleFormat( 6217 "some_namespace::LongReturnType\n" 6218 "long_namespace::SomeVeryLongClass::SomeVeryLongFunction(\n" 6219 " int first_long_parameter, int second_parameter) {}"); 6220 6221 verifyGoogleFormat("template <typename T>\n" 6222 "aaaaaaaa::aaaaa::aaaaaa<T, aaaaaaaaaaaaaaaaaaaaaaaaa>\n" 6223 "aaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaa() {}"); 6224 verifyGoogleFormat("A<A<A>> aaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6225 " int aaaaaaaaaaaaaaaaaaaaaaa);"); 6226 6227 verifyFormat("typedef size_t (*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n" 6228 " const aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6229 " *aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6230 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6231 " vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n" 6232 " aaaaaaaaaaaaaaaaaaaaaaaa);"); 6233 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6234 " vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n" 6235 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>>\n" 6236 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6237 6238 verifyFormat("template <typename T> // Templates on own line.\n" 6239 "static int // Some comment.\n" 6240 "MyFunction(int a);", 6241 getLLVMStyle()); 6242 } 6243 6244 TEST_F(FormatTest, FormatsArrays) { 6245 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaaaaaaaaaa]\n" 6246 " [bbbbbbbbbbbbbbbbbbbbbbbbb] = c;"); 6247 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaa(aaaaaaaaaaaa)]\n" 6248 " [bbbbbbbbbbb(bbbbbbbbbbbb)] = c;"); 6249 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaa &&\n" 6250 " aaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaa][aaaaaaaaaaaaa]) {\n}"); 6251 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6252 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;"); 6253 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6254 " [a][bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = cccccccc;"); 6255 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6256 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n" 6257 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;"); 6258 verifyFormat( 6259 "llvm::outs() << \"aaaaaaaaaaaa: \"\n" 6260 " << (*aaaaaaaiaaaaaaa)[aaaaaaaaaaaaaaaaaaaaaaaaa]\n" 6261 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa];"); 6262 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaa][a]\n" 6263 " .aaaaaaaaaaaaaaaaaaaaaa();"); 6264 6265 verifyGoogleFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<int>\n" 6266 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaa];"); 6267 verifyFormat( 6268 "aaaaaaaaaaa aaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaa->aaaaaaaaa[0]\n" 6269 " .aaaaaaa[0]\n" 6270 " .aaaaaaaaaaaaaaaaaaaaaa();"); 6271 verifyFormat("a[::b::c];"); 6272 6273 verifyNoCrash("a[,Y?)]", getLLVMStyleWithColumns(10)); 6274 6275 FormatStyle NoColumnLimit = getLLVMStyleWithColumns(0); 6276 verifyFormat("aaaaa[bbbbbb].cccccc()", NoColumnLimit); 6277 } 6278 6279 TEST_F(FormatTest, LineStartsWithSpecialCharacter) { 6280 verifyFormat("(a)->b();"); 6281 verifyFormat("--a;"); 6282 } 6283 6284 TEST_F(FormatTest, HandlesIncludeDirectives) { 6285 verifyFormat("#include <string>\n" 6286 "#include <a/b/c.h>\n" 6287 "#include \"a/b/string\"\n" 6288 "#include \"string.h\"\n" 6289 "#include \"string.h\"\n" 6290 "#include <a-a>\n" 6291 "#include < path with space >\n" 6292 "#include_next <test.h>" 6293 "#include \"abc.h\" // this is included for ABC\n" 6294 "#include \"some long include\" // with a comment\n" 6295 "#include \"some very long include paaaaaaaaaaaaaaaaaaaaaaath\"", 6296 getLLVMStyleWithColumns(35)); 6297 EXPECT_EQ("#include \"a.h\"", format("#include \"a.h\"")); 6298 EXPECT_EQ("#include <a>", format("#include<a>")); 6299 6300 verifyFormat("#import <string>"); 6301 verifyFormat("#import <a/b/c.h>"); 6302 verifyFormat("#import \"a/b/string\""); 6303 verifyFormat("#import \"string.h\""); 6304 verifyFormat("#import \"string.h\""); 6305 verifyFormat("#if __has_include(<strstream>)\n" 6306 "#include <strstream>\n" 6307 "#endif"); 6308 6309 verifyFormat("#define MY_IMPORT <a/b>"); 6310 6311 verifyFormat("#if __has_include(<a/b>)"); 6312 verifyFormat("#if __has_include_next(<a/b>)"); 6313 verifyFormat("#define F __has_include(<a/b>)"); 6314 verifyFormat("#define F __has_include_next(<a/b>)"); 6315 6316 // Protocol buffer definition or missing "#". 6317 verifyFormat("import \"aaaaaaaaaaaaaaaaa/aaaaaaaaaaaaaaa\";", 6318 getLLVMStyleWithColumns(30)); 6319 6320 FormatStyle Style = getLLVMStyle(); 6321 Style.AlwaysBreakBeforeMultilineStrings = true; 6322 Style.ColumnLimit = 0; 6323 verifyFormat("#import \"abc.h\"", Style); 6324 6325 // But 'import' might also be a regular C++ namespace. 6326 verifyFormat("import::SomeFunction(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6327 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6328 } 6329 6330 //===----------------------------------------------------------------------===// 6331 // Error recovery tests. 6332 //===----------------------------------------------------------------------===// 6333 6334 TEST_F(FormatTest, IncompleteParameterLists) { 6335 FormatStyle NoBinPacking = getLLVMStyle(); 6336 NoBinPacking.BinPackParameters = false; 6337 verifyFormat("void aaaaaaaaaaaaaaaaaa(int level,\n" 6338 " double *min_x,\n" 6339 " double *max_x,\n" 6340 " double *min_y,\n" 6341 " double *max_y,\n" 6342 " double *min_z,\n" 6343 " double *max_z, ) {}", 6344 NoBinPacking); 6345 } 6346 6347 TEST_F(FormatTest, IncorrectCodeTrailingStuff) { 6348 verifyFormat("void f() { return; }\n42"); 6349 verifyFormat("void f() {\n" 6350 " if (0)\n" 6351 " return;\n" 6352 "}\n" 6353 "42"); 6354 verifyFormat("void f() { return }\n42"); 6355 verifyFormat("void f() {\n" 6356 " if (0)\n" 6357 " return\n" 6358 "}\n" 6359 "42"); 6360 } 6361 6362 TEST_F(FormatTest, IncorrectCodeMissingSemicolon) { 6363 EXPECT_EQ("void f() { return }", format("void f ( ) { return }")); 6364 EXPECT_EQ("void f() {\n" 6365 " if (a)\n" 6366 " return\n" 6367 "}", 6368 format("void f ( ) { if ( a ) return }")); 6369 EXPECT_EQ("namespace N {\n" 6370 "void f()\n" 6371 "}", 6372 format("namespace N { void f() }")); 6373 EXPECT_EQ("namespace N {\n" 6374 "void f() {}\n" 6375 "void g()\n" 6376 "} // namespace N", 6377 format("namespace N { void f( ) { } void g( ) }")); 6378 } 6379 6380 TEST_F(FormatTest, IndentationWithinColumnLimitNotPossible) { 6381 verifyFormat("int aaaaaaaa =\n" 6382 " // Overlylongcomment\n" 6383 " b;", 6384 getLLVMStyleWithColumns(20)); 6385 verifyFormat("function(\n" 6386 " ShortArgument,\n" 6387 " LoooooooooooongArgument);\n", 6388 getLLVMStyleWithColumns(20)); 6389 } 6390 6391 TEST_F(FormatTest, IncorrectAccessSpecifier) { 6392 verifyFormat("public:"); 6393 verifyFormat("class A {\n" 6394 "public\n" 6395 " void f() {}\n" 6396 "};"); 6397 verifyFormat("public\n" 6398 "int qwerty;"); 6399 verifyFormat("public\n" 6400 "B {}"); 6401 verifyFormat("public\n" 6402 "{}"); 6403 verifyFormat("public\n" 6404 "B { int x; }"); 6405 } 6406 6407 TEST_F(FormatTest, IncorrectCodeUnbalancedBraces) { 6408 verifyFormat("{"); 6409 verifyFormat("#})"); 6410 verifyNoCrash("(/**/[:!] ?[)."); 6411 } 6412 6413 TEST_F(FormatTest, IncorrectCodeDoNoWhile) { 6414 verifyFormat("do {\n}"); 6415 verifyFormat("do {\n}\n" 6416 "f();"); 6417 verifyFormat("do {\n}\n" 6418 "wheeee(fun);"); 6419 verifyFormat("do {\n" 6420 " f();\n" 6421 "}"); 6422 } 6423 6424 TEST_F(FormatTest, IncorrectCodeMissingParens) { 6425 verifyFormat("if {\n foo;\n foo();\n}"); 6426 verifyFormat("switch {\n foo;\n foo();\n}"); 6427 verifyIncompleteFormat("for {\n foo;\n foo();\n}"); 6428 verifyFormat("while {\n foo;\n foo();\n}"); 6429 verifyFormat("do {\n foo;\n foo();\n} while;"); 6430 } 6431 6432 TEST_F(FormatTest, DoesNotTouchUnwrappedLinesWithErrors) { 6433 verifyIncompleteFormat("namespace {\n" 6434 "class Foo { Foo (\n" 6435 "};\n" 6436 "} // namespace"); 6437 } 6438 6439 TEST_F(FormatTest, IncorrectCodeErrorDetection) { 6440 EXPECT_EQ("{\n {}\n", format("{\n{\n}\n")); 6441 EXPECT_EQ("{\n {}\n", format("{\n {\n}\n")); 6442 EXPECT_EQ("{\n {}\n", format("{\n {\n }\n")); 6443 EXPECT_EQ("{\n {}\n}\n}\n", format("{\n {\n }\n }\n}\n")); 6444 6445 EXPECT_EQ("{\n" 6446 " {\n" 6447 " breakme(\n" 6448 " qwe);\n" 6449 " }\n", 6450 format("{\n" 6451 " {\n" 6452 " breakme(qwe);\n" 6453 "}\n", 6454 getLLVMStyleWithColumns(10))); 6455 } 6456 6457 TEST_F(FormatTest, LayoutCallsInsideBraceInitializers) { 6458 verifyFormat("int x = {\n" 6459 " avariable,\n" 6460 " b(alongervariable)};", 6461 getLLVMStyleWithColumns(25)); 6462 } 6463 6464 TEST_F(FormatTest, LayoutBraceInitializersInReturnStatement) { 6465 verifyFormat("return (a)(b){1, 2, 3};"); 6466 } 6467 6468 TEST_F(FormatTest, LayoutCxx11BraceInitializers) { 6469 verifyFormat("vector<int> x{1, 2, 3, 4};"); 6470 verifyFormat("vector<int> x{\n" 6471 " 1,\n" 6472 " 2,\n" 6473 " 3,\n" 6474 " 4,\n" 6475 "};"); 6476 verifyFormat("vector<T> x{{}, {}, {}, {}};"); 6477 verifyFormat("f({1, 2});"); 6478 verifyFormat("auto v = Foo{-1};"); 6479 verifyFormat("f({1, 2}, {{2, 3}, {4, 5}}, c, {d});"); 6480 verifyFormat("Class::Class : member{1, 2, 3} {}"); 6481 verifyFormat("new vector<int>{1, 2, 3};"); 6482 verifyFormat("new int[3]{1, 2, 3};"); 6483 verifyFormat("new int{1};"); 6484 verifyFormat("return {arg1, arg2};"); 6485 verifyFormat("return {arg1, SomeType{parameter}};"); 6486 verifyFormat("int count = set<int>{f(), g(), h()}.size();"); 6487 verifyFormat("new T{arg1, arg2};"); 6488 verifyFormat("f(MyMap[{composite, key}]);"); 6489 verifyFormat("class Class {\n" 6490 " T member = {arg1, arg2};\n" 6491 "};"); 6492 verifyFormat("vector<int> foo = {::SomeGlobalFunction()};"); 6493 verifyFormat("const struct A a = {.a = 1, .b = 2};"); 6494 verifyFormat("const struct A a = {[0] = 1, [1] = 2};"); 6495 verifyFormat("static_assert(std::is_integral<int>{} + 0, \"\");"); 6496 verifyFormat("int a = std::is_integral<int>{} + 0;"); 6497 6498 verifyFormat("int foo(int i) { return fo1{}(i); }"); 6499 verifyFormat("int foo(int i) { return fo1{}(i); }"); 6500 verifyFormat("auto i = decltype(x){};"); 6501 verifyFormat("std::vector<int> v = {1, 0 /* comment */};"); 6502 verifyFormat("Node n{1, Node{1000}, //\n" 6503 " 2};"); 6504 verifyFormat("Aaaa aaaaaaa{\n" 6505 " {\n" 6506 " aaaa,\n" 6507 " },\n" 6508 "};"); 6509 verifyFormat("class C : public D {\n" 6510 " SomeClass SC{2};\n" 6511 "};"); 6512 verifyFormat("class C : public A {\n" 6513 " class D : public B {\n" 6514 " void f() { int i{2}; }\n" 6515 " };\n" 6516 "};"); 6517 verifyFormat("#define A {a, a},"); 6518 6519 // Binpacking only if there is no trailing comma 6520 verifyFormat("const Aaaaaa aaaaa = {aaaaaaaaaa, bbbbbbbbbb,\n" 6521 " cccccccccc, dddddddddd};", 6522 getLLVMStyleWithColumns(50)); 6523 verifyFormat("const Aaaaaa aaaaa = {\n" 6524 " aaaaaaaaaaa,\n" 6525 " bbbbbbbbbbb,\n" 6526 " ccccccccccc,\n" 6527 " ddddddddddd,\n" 6528 "};", getLLVMStyleWithColumns(50)); 6529 6530 // Cases where distinguising braced lists and blocks is hard. 6531 verifyFormat("vector<int> v{12} GUARDED_BY(mutex);"); 6532 verifyFormat("void f() {\n" 6533 " return; // comment\n" 6534 "}\n" 6535 "SomeType t;"); 6536 verifyFormat("void f() {\n" 6537 " if (a) {\n" 6538 " f();\n" 6539 " }\n" 6540 "}\n" 6541 "SomeType t;"); 6542 6543 // In combination with BinPackArguments = false. 6544 FormatStyle NoBinPacking = getLLVMStyle(); 6545 NoBinPacking.BinPackArguments = false; 6546 verifyFormat("const Aaaaaa aaaaa = {aaaaa,\n" 6547 " bbbbb,\n" 6548 " ccccc,\n" 6549 " ddddd,\n" 6550 " eeeee,\n" 6551 " ffffff,\n" 6552 " ggggg,\n" 6553 " hhhhhh,\n" 6554 " iiiiii,\n" 6555 " jjjjjj,\n" 6556 " kkkkkk};", 6557 NoBinPacking); 6558 verifyFormat("const Aaaaaa aaaaa = {\n" 6559 " aaaaa,\n" 6560 " bbbbb,\n" 6561 " ccccc,\n" 6562 " ddddd,\n" 6563 " eeeee,\n" 6564 " ffffff,\n" 6565 " ggggg,\n" 6566 " hhhhhh,\n" 6567 " iiiiii,\n" 6568 " jjjjjj,\n" 6569 " kkkkkk,\n" 6570 "};", 6571 NoBinPacking); 6572 verifyFormat( 6573 "const Aaaaaa aaaaa = {\n" 6574 " aaaaa, bbbbb, ccccc, ddddd, eeeee, ffffff, ggggg, hhhhhh,\n" 6575 " iiiiii, jjjjjj, kkkkkk, aaaaa, bbbbb, ccccc, ddddd, eeeee,\n" 6576 " ffffff, ggggg, hhhhhh, iiiiii, jjjjjj, kkkkkk,\n" 6577 "};", 6578 NoBinPacking); 6579 6580 // FIXME: The alignment of these trailing comments might be bad. Then again, 6581 // this might be utterly useless in real code. 6582 verifyFormat("Constructor::Constructor()\n" 6583 " : some_value{ //\n" 6584 " aaaaaaa, //\n" 6585 " bbbbbbb} {}"); 6586 6587 // In braced lists, the first comment is always assumed to belong to the 6588 // first element. Thus, it can be moved to the next or previous line as 6589 // appropriate. 6590 EXPECT_EQ("function({// First element:\n" 6591 " 1,\n" 6592 " // Second element:\n" 6593 " 2});", 6594 format("function({\n" 6595 " // First element:\n" 6596 " 1,\n" 6597 " // Second element:\n" 6598 " 2});")); 6599 EXPECT_EQ("std::vector<int> MyNumbers{\n" 6600 " // First element:\n" 6601 " 1,\n" 6602 " // Second element:\n" 6603 " 2};", 6604 format("std::vector<int> MyNumbers{// First element:\n" 6605 " 1,\n" 6606 " // Second element:\n" 6607 " 2};", 6608 getLLVMStyleWithColumns(30))); 6609 // A trailing comma should still lead to an enforced line break and no 6610 // binpacking. 6611 EXPECT_EQ("vector<int> SomeVector = {\n" 6612 " // aaa\n" 6613 " 1,\n" 6614 " 2,\n" 6615 "};", 6616 format("vector<int> SomeVector = { // aaa\n" 6617 " 1, 2, };")); 6618 6619 FormatStyle ExtraSpaces = getLLVMStyle(); 6620 ExtraSpaces.Cpp11BracedListStyle = false; 6621 ExtraSpaces.ColumnLimit = 75; 6622 verifyFormat("vector<int> x{ 1, 2, 3, 4 };", ExtraSpaces); 6623 verifyFormat("vector<T> x{ {}, {}, {}, {} };", ExtraSpaces); 6624 verifyFormat("f({ 1, 2 });", ExtraSpaces); 6625 verifyFormat("auto v = Foo{ 1 };", ExtraSpaces); 6626 verifyFormat("f({ 1, 2 }, { { 2, 3 }, { 4, 5 } }, c, { d });", ExtraSpaces); 6627 verifyFormat("Class::Class : member{ 1, 2, 3 } {}", ExtraSpaces); 6628 verifyFormat("new vector<int>{ 1, 2, 3 };", ExtraSpaces); 6629 verifyFormat("new int[3]{ 1, 2, 3 };", ExtraSpaces); 6630 verifyFormat("return { arg1, arg2 };", ExtraSpaces); 6631 verifyFormat("return { arg1, SomeType{ parameter } };", ExtraSpaces); 6632 verifyFormat("int count = set<int>{ f(), g(), h() }.size();", ExtraSpaces); 6633 verifyFormat("new T{ arg1, arg2 };", ExtraSpaces); 6634 verifyFormat("f(MyMap[{ composite, key }]);", ExtraSpaces); 6635 verifyFormat("class Class {\n" 6636 " T member = { arg1, arg2 };\n" 6637 "};", 6638 ExtraSpaces); 6639 verifyFormat( 6640 "foo = aaaaaaaaaaa ? vector<int>{ aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6641 " aaaaaaaaaaaaaaaaaaaa, aaaaa }\n" 6642 " : vector<int>{ bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" 6643 " bbbbbbbbbbbbbbbbbbbb, bbbbb };", 6644 ExtraSpaces); 6645 verifyFormat("DoSomethingWithVector({} /* No data */);", ExtraSpaces); 6646 verifyFormat("DoSomethingWithVector({ {} /* No data */ }, { { 1, 2 } });", 6647 ExtraSpaces); 6648 verifyFormat( 6649 "someFunction(OtherParam,\n" 6650 " BracedList{ // comment 1 (Forcing interesting break)\n" 6651 " param1, param2,\n" 6652 " // comment 2\n" 6653 " param3, param4 });", 6654 ExtraSpaces); 6655 verifyFormat( 6656 "std::this_thread::sleep_for(\n" 6657 " std::chrono::nanoseconds{ std::chrono::seconds{ 1 } } / 5);", 6658 ExtraSpaces); 6659 verifyFormat("std::vector<MyValues> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa{\n" 6660 " aaaaaaa,\n" 6661 " aaaaaaaaaa,\n" 6662 " aaaaa,\n" 6663 " aaaaaaaaaaaaaaa,\n" 6664 " aaa,\n" 6665 " aaaaaaaaaa,\n" 6666 " a,\n" 6667 " aaaaaaaaaaaaaaaaaaaaa,\n" 6668 " aaaaaaaaaaaa,\n" 6669 " aaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaa,\n" 6670 " aaaaaaa,\n" 6671 " a};"); 6672 verifyFormat("vector<int> foo = { ::SomeGlobalFunction() };", ExtraSpaces); 6673 verifyFormat("const struct A a = { .a = 1, .b = 2 };", ExtraSpaces); 6674 verifyFormat("const struct A a = { [0] = 1, [1] = 2 };", ExtraSpaces); 6675 } 6676 6677 TEST_F(FormatTest, FormatsBracedListsInColumnLayout) { 6678 verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n" 6679 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 6680 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 6681 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 6682 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 6683 " 1, 22, 333, 4444, 55555, 666666, 7777777};"); 6684 verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777, //\n" 6685 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 6686 " 1, 22, 333, 4444, 55555, //\n" 6687 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 6688 " 1, 22, 333, 4444, 55555, 666666, 7777777};"); 6689 verifyFormat( 6690 "vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n" 6691 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 6692 " 1, 22, 333, 4444, 55555, 666666, // comment\n" 6693 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 6694 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 6695 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 6696 " 7777777};"); 6697 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n" 6698 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n" 6699 " X86::R8, X86::R9, X86::R10, X86::R11, 0};"); 6700 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n" 6701 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n" 6702 " // Separating comment.\n" 6703 " X86::R8, X86::R9, X86::R10, X86::R11, 0};"); 6704 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n" 6705 " // Leading comment\n" 6706 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n" 6707 " X86::R8, X86::R9, X86::R10, X86::R11, 0};"); 6708 verifyFormat("vector<int> x = {1, 1, 1, 1,\n" 6709 " 1, 1, 1, 1};", 6710 getLLVMStyleWithColumns(39)); 6711 verifyFormat("vector<int> x = {1, 1, 1, 1,\n" 6712 " 1, 1, 1, 1};", 6713 getLLVMStyleWithColumns(38)); 6714 verifyFormat("vector<int> aaaaaaaaaaaaaaaaaaaaaa = {\n" 6715 " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};", 6716 getLLVMStyleWithColumns(43)); 6717 verifyFormat( 6718 "static unsigned SomeValues[10][3] = {\n" 6719 " {1, 4, 0}, {4, 9, 0}, {4, 5, 9}, {8, 5, 4}, {1, 8, 4},\n" 6720 " {10, 1, 6}, {11, 0, 9}, {2, 11, 9}, {5, 2, 9}, {11, 2, 7}};"); 6721 verifyFormat("static auto fields = new vector<string>{\n" 6722 " \"aaaaaaaaaaaaa\",\n" 6723 " \"aaaaaaaaaaaaa\",\n" 6724 " \"aaaaaaaaaaaa\",\n" 6725 " \"aaaaaaaaaaaaaa\",\n" 6726 " \"aaaaaaaaaaaaaaaaaaaaaaaaa\",\n" 6727 " \"aaaaaaaaaaaa\",\n" 6728 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",\n" 6729 "};"); 6730 verifyFormat("vector<int> x = {1, 2, 3, 4, aaaaaaaaaaaaaaaaa, 6};"); 6731 verifyFormat("vector<int> x = {1, aaaaaaaaaaaaaaaaaaaaaa,\n" 6732 " 2, bbbbbbbbbbbbbbbbbbbbbb,\n" 6733 " 3, cccccccccccccccccccccc};", 6734 getLLVMStyleWithColumns(60)); 6735 6736 // Trailing commas. 6737 verifyFormat("vector<int> x = {\n" 6738 " 1, 1, 1, 1, 1, 1, 1, 1,\n" 6739 "};", 6740 getLLVMStyleWithColumns(39)); 6741 verifyFormat("vector<int> x = {\n" 6742 " 1, 1, 1, 1, 1, 1, 1, 1, //\n" 6743 "};", 6744 getLLVMStyleWithColumns(39)); 6745 verifyFormat("vector<int> x = {1, 1, 1, 1,\n" 6746 " 1, 1, 1, 1,\n" 6747 " /**/ /**/};", 6748 getLLVMStyleWithColumns(39)); 6749 6750 // Trailing comment in the first line. 6751 verifyFormat("vector<int> iiiiiiiiiiiiiii = { //\n" 6752 " 1111111111, 2222222222, 33333333333, 4444444444, //\n" 6753 " 111111111, 222222222, 3333333333, 444444444, //\n" 6754 " 11111111, 22222222, 333333333, 44444444};"); 6755 // Trailing comment in the last line. 6756 verifyFormat("int aaaaa[] = {\n" 6757 " 1, 2, 3, // comment\n" 6758 " 4, 5, 6 // comment\n" 6759 "};"); 6760 6761 // With nested lists, we should either format one item per line or all nested 6762 // lists one on line. 6763 // FIXME: For some nested lists, we can do better. 6764 verifyFormat("return {{aaaaaaaaaaaaaaaaaaaaa},\n" 6765 " {aaaaaaaaaaaaaaaaaaa},\n" 6766 " {aaaaaaaaaaaaaaaaaaaaa},\n" 6767 " {aaaaaaaaaaaaaaaaa}};", 6768 getLLVMStyleWithColumns(60)); 6769 verifyFormat( 6770 "SomeStruct my_struct_array = {\n" 6771 " {aaaaaa, aaaaaaaa, aaaaaaaaaa, aaaaaaaaa, aaaaaaaaa, aaaaaaaaaa,\n" 6772 " aaaaaaaaaaaaa, aaaaaaa, aaa},\n" 6773 " {aaa, aaa},\n" 6774 " {aaa, aaa},\n" 6775 " {aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaa},\n" 6776 " {aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaa,\n" 6777 " aaaaaaaaaaaa, a, aaaaaaaaaa, aaaaaaaaa, aaa}};"); 6778 6779 // No column layout should be used here. 6780 verifyFormat("aaaaaaaaaaaaaaa = {aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0, 0,\n" 6781 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb};"); 6782 6783 verifyNoCrash("a<,"); 6784 6785 // No braced initializer here. 6786 verifyFormat("void f() {\n" 6787 " struct Dummy {};\n" 6788 " f(v);\n" 6789 "}"); 6790 6791 // Long lists should be formatted in columns even if they are nested. 6792 verifyFormat( 6793 "vector<int> x = function({1, 22, 333, 4444, 55555, 666666, 7777777,\n" 6794 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 6795 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 6796 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 6797 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 6798 " 1, 22, 333, 4444, 55555, 666666, 7777777});"); 6799 6800 // Allow "single-column" layout even if that violates the column limit. There 6801 // isn't going to be a better way. 6802 verifyFormat("std::vector<int> a = {\n" 6803 " aaaaaaaa,\n" 6804 " aaaaaaaa,\n" 6805 " aaaaaaaa,\n" 6806 " aaaaaaaa,\n" 6807 " aaaaaaaaaa,\n" 6808 " aaaaaaaa,\n" 6809 " aaaaaaaaaaaaaaaaaaaaaaaaaaa};", 6810 getLLVMStyleWithColumns(30)); 6811 verifyFormat("vector<int> aaaa = {\n" 6812 " aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6813 " aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6814 " aaaaaa.aaaaaaa,\n" 6815 " aaaaaa.aaaaaaa,\n" 6816 " aaaaaa.aaaaaaa,\n" 6817 " aaaaaa.aaaaaaa,\n" 6818 "};"); 6819 6820 // Don't create hanging lists. 6821 verifyFormat("someFunction(Param, {List1, List2,\n" 6822 " List3});", 6823 getLLVMStyleWithColumns(35)); 6824 verifyFormat("someFunction(Param, Param,\n" 6825 " {List1, List2,\n" 6826 " List3});", 6827 getLLVMStyleWithColumns(35)); 6828 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa, {},\n" 6829 " aaaaaaaaaaaaaaaaaaaaaaa);"); 6830 } 6831 6832 TEST_F(FormatTest, PullTrivialFunctionDefinitionsIntoSingleLine) { 6833 FormatStyle DoNotMerge = getLLVMStyle(); 6834 DoNotMerge.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 6835 6836 verifyFormat("void f() { return 42; }"); 6837 verifyFormat("void f() {\n" 6838 " return 42;\n" 6839 "}", 6840 DoNotMerge); 6841 verifyFormat("void f() {\n" 6842 " // Comment\n" 6843 "}"); 6844 verifyFormat("{\n" 6845 "#error {\n" 6846 " int a;\n" 6847 "}"); 6848 verifyFormat("{\n" 6849 " int a;\n" 6850 "#error {\n" 6851 "}"); 6852 verifyFormat("void f() {} // comment"); 6853 verifyFormat("void f() { int a; } // comment"); 6854 verifyFormat("void f() {\n" 6855 "} // comment", 6856 DoNotMerge); 6857 verifyFormat("void f() {\n" 6858 " int a;\n" 6859 "} // comment", 6860 DoNotMerge); 6861 verifyFormat("void f() {\n" 6862 "} // comment", 6863 getLLVMStyleWithColumns(15)); 6864 6865 verifyFormat("void f() { return 42; }", getLLVMStyleWithColumns(23)); 6866 verifyFormat("void f() {\n return 42;\n}", getLLVMStyleWithColumns(22)); 6867 6868 verifyFormat("void f() {}", getLLVMStyleWithColumns(11)); 6869 verifyFormat("void f() {\n}", getLLVMStyleWithColumns(10)); 6870 verifyFormat("class C {\n" 6871 " C()\n" 6872 " : iiiiiiii(nullptr),\n" 6873 " kkkkkkk(nullptr),\n" 6874 " mmmmmmm(nullptr),\n" 6875 " nnnnnnn(nullptr) {}\n" 6876 "};", 6877 getGoogleStyle()); 6878 6879 FormatStyle NoColumnLimit = getLLVMStyle(); 6880 NoColumnLimit.ColumnLimit = 0; 6881 EXPECT_EQ("A() : b(0) {}", format("A():b(0){}", NoColumnLimit)); 6882 EXPECT_EQ("class C {\n" 6883 " A() : b(0) {}\n" 6884 "};", 6885 format("class C{A():b(0){}};", NoColumnLimit)); 6886 EXPECT_EQ("A()\n" 6887 " : b(0) {\n" 6888 "}", 6889 format("A()\n:b(0)\n{\n}", NoColumnLimit)); 6890 6891 FormatStyle DoNotMergeNoColumnLimit = NoColumnLimit; 6892 DoNotMergeNoColumnLimit.AllowShortFunctionsOnASingleLine = 6893 FormatStyle::SFS_None; 6894 EXPECT_EQ("A()\n" 6895 " : b(0) {\n" 6896 "}", 6897 format("A():b(0){}", DoNotMergeNoColumnLimit)); 6898 EXPECT_EQ("A()\n" 6899 " : b(0) {\n" 6900 "}", 6901 format("A()\n:b(0)\n{\n}", DoNotMergeNoColumnLimit)); 6902 6903 verifyFormat("#define A \\\n" 6904 " void f() { \\\n" 6905 " int i; \\\n" 6906 " }", 6907 getLLVMStyleWithColumns(20)); 6908 verifyFormat("#define A \\\n" 6909 " void f() { int i; }", 6910 getLLVMStyleWithColumns(21)); 6911 verifyFormat("#define A \\\n" 6912 " void f() { \\\n" 6913 " int i; \\\n" 6914 " } \\\n" 6915 " int j;", 6916 getLLVMStyleWithColumns(22)); 6917 verifyFormat("#define A \\\n" 6918 " void f() { int i; } \\\n" 6919 " int j;", 6920 getLLVMStyleWithColumns(23)); 6921 } 6922 6923 TEST_F(FormatTest, PullEmptyFunctionDefinitionsIntoSingleLine) { 6924 FormatStyle MergeEmptyOnly = getLLVMStyle(); 6925 MergeEmptyOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty; 6926 verifyFormat("class C {\n" 6927 " int f() {}\n" 6928 "};", 6929 MergeEmptyOnly); 6930 verifyFormat("class C {\n" 6931 " int f() {\n" 6932 " return 42;\n" 6933 " }\n" 6934 "};", 6935 MergeEmptyOnly); 6936 verifyFormat("int f() {}", MergeEmptyOnly); 6937 verifyFormat("int f() {\n" 6938 " return 42;\n" 6939 "}", 6940 MergeEmptyOnly); 6941 6942 // Also verify behavior when BraceWrapping.AfterFunction = true 6943 MergeEmptyOnly.BreakBeforeBraces = FormatStyle::BS_Custom; 6944 MergeEmptyOnly.BraceWrapping.AfterFunction = true; 6945 verifyFormat("int f() {}", MergeEmptyOnly); 6946 verifyFormat("class C {\n" 6947 " int f() {}\n" 6948 "};", 6949 MergeEmptyOnly); 6950 } 6951 6952 TEST_F(FormatTest, PullInlineFunctionDefinitionsIntoSingleLine) { 6953 FormatStyle MergeInlineOnly = getLLVMStyle(); 6954 MergeInlineOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; 6955 verifyFormat("class C {\n" 6956 " int f() { return 42; }\n" 6957 "};", 6958 MergeInlineOnly); 6959 verifyFormat("int f() {\n" 6960 " return 42;\n" 6961 "}", 6962 MergeInlineOnly); 6963 6964 // SFS_Inline implies SFS_Empty 6965 verifyFormat("class C {\n" 6966 " int f() {}\n" 6967 "};", 6968 MergeInlineOnly); 6969 verifyFormat("int f() {}", MergeInlineOnly); 6970 6971 // Also verify behavior when BraceWrapping.AfterFunction = true 6972 MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom; 6973 MergeInlineOnly.BraceWrapping.AfterFunction = true; 6974 verifyFormat("class C {\n" 6975 " int f() { return 42; }\n" 6976 "};", 6977 MergeInlineOnly); 6978 verifyFormat("int f()\n" 6979 "{\n" 6980 " return 42;\n" 6981 "}", 6982 MergeInlineOnly); 6983 6984 // SFS_Inline implies SFS_Empty 6985 verifyFormat("int f() {}", MergeInlineOnly); 6986 verifyFormat("class C {\n" 6987 " int f() {}\n" 6988 "};", 6989 MergeInlineOnly); 6990 } 6991 6992 TEST_F(FormatTest, PullInlineOnlyFunctionDefinitionsIntoSingleLine) { 6993 FormatStyle MergeInlineOnly = getLLVMStyle(); 6994 MergeInlineOnly.AllowShortFunctionsOnASingleLine = 6995 FormatStyle::SFS_InlineOnly; 6996 verifyFormat("class C {\n" 6997 " int f() { return 42; }\n" 6998 "};", 6999 MergeInlineOnly); 7000 verifyFormat("int f() {\n" 7001 " return 42;\n" 7002 "}", 7003 MergeInlineOnly); 7004 7005 // SFS_InlineOnly does not imply SFS_Empty 7006 verifyFormat("class C {\n" 7007 " int f() {}\n" 7008 "};", 7009 MergeInlineOnly); 7010 verifyFormat("int f() {\n" 7011 "}", 7012 MergeInlineOnly); 7013 7014 // Also verify behavior when BraceWrapping.AfterFunction = true 7015 MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom; 7016 MergeInlineOnly.BraceWrapping.AfterFunction = true; 7017 verifyFormat("class C {\n" 7018 " int f() { return 42; }\n" 7019 "};", 7020 MergeInlineOnly); 7021 verifyFormat("int f()\n" 7022 "{\n" 7023 " return 42;\n" 7024 "}", 7025 MergeInlineOnly); 7026 7027 // SFS_InlineOnly does not imply SFS_Empty 7028 verifyFormat("int f()\n" 7029 "{\n" 7030 "}", 7031 MergeInlineOnly); 7032 verifyFormat("class C {\n" 7033 " int f() {}\n" 7034 "};", 7035 MergeInlineOnly); 7036 } 7037 7038 TEST_F(FormatTest, SplitEmptyFunction) { 7039 FormatStyle Style = getLLVMStyle(); 7040 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 7041 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 7042 Style.BraceWrapping.AfterFunction = true; 7043 Style.BraceWrapping.SplitEmptyFunction = false; 7044 Style.ColumnLimit = 40; 7045 7046 verifyFormat("int f()\n" 7047 "{}", 7048 Style); 7049 verifyFormat("int f()\n" 7050 "{\n" 7051 " return 42;\n" 7052 "}", 7053 Style); 7054 verifyFormat("int f()\n" 7055 "{\n" 7056 " // some comment\n" 7057 "}", 7058 Style); 7059 7060 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty; 7061 verifyFormat("int f() {}", Style); 7062 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 7063 "{}", 7064 Style); 7065 verifyFormat("int f()\n" 7066 "{\n" 7067 " return 0;\n" 7068 "}", 7069 Style); 7070 7071 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; 7072 verifyFormat("class Foo {\n" 7073 " int f() {}\n" 7074 "};\n", 7075 Style); 7076 verifyFormat("class Foo {\n" 7077 " int f() { return 0; }\n" 7078 "};\n", 7079 Style); 7080 verifyFormat("class Foo {\n" 7081 " int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 7082 " {}\n" 7083 "};\n", 7084 Style); 7085 verifyFormat("class Foo {\n" 7086 " int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 7087 " {\n" 7088 " return 0;\n" 7089 " }\n" 7090 "};\n", 7091 Style); 7092 7093 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 7094 verifyFormat("int f() {}", Style); 7095 verifyFormat("int f() { return 0; }", Style); 7096 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 7097 "{}", 7098 Style); 7099 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 7100 "{\n" 7101 " return 0;\n" 7102 "}", 7103 Style); 7104 } 7105 7106 TEST_F(FormatTest, SplitEmptyClass) { 7107 FormatStyle Style = getLLVMStyle(); 7108 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 7109 Style.BraceWrapping.AfterClass = true; 7110 Style.BraceWrapping.SplitEmptyRecord = false; 7111 7112 verifyFormat("class Foo\n" 7113 "{};", 7114 Style); 7115 verifyFormat("/* something */ class Foo\n" 7116 "{};", 7117 Style); 7118 verifyFormat("template <typename X> class Foo\n" 7119 "{};", 7120 Style); 7121 verifyFormat("class Foo\n" 7122 "{\n" 7123 " Foo();\n" 7124 "};", 7125 Style); 7126 verifyFormat("typedef class Foo\n" 7127 "{\n" 7128 "} Foo_t;", 7129 Style); 7130 } 7131 7132 TEST_F(FormatTest, SplitEmptyStruct) { 7133 FormatStyle Style = getLLVMStyle(); 7134 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 7135 Style.BraceWrapping.AfterStruct = true; 7136 Style.BraceWrapping.SplitEmptyRecord = false; 7137 7138 verifyFormat("struct Foo\n" 7139 "{};", 7140 Style); 7141 verifyFormat("/* something */ struct Foo\n" 7142 "{};", 7143 Style); 7144 verifyFormat("template <typename X> struct Foo\n" 7145 "{};", 7146 Style); 7147 verifyFormat("struct Foo\n" 7148 "{\n" 7149 " Foo();\n" 7150 "};", 7151 Style); 7152 verifyFormat("typedef struct Foo\n" 7153 "{\n" 7154 "} Foo_t;", 7155 Style); 7156 //typedef struct Bar {} Bar_t; 7157 } 7158 7159 TEST_F(FormatTest, SplitEmptyUnion) { 7160 FormatStyle Style = getLLVMStyle(); 7161 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 7162 Style.BraceWrapping.AfterUnion = true; 7163 Style.BraceWrapping.SplitEmptyRecord = false; 7164 7165 verifyFormat("union Foo\n" 7166 "{};", 7167 Style); 7168 verifyFormat("/* something */ union Foo\n" 7169 "{};", 7170 Style); 7171 verifyFormat("union Foo\n" 7172 "{\n" 7173 " A,\n" 7174 "};", 7175 Style); 7176 verifyFormat("typedef union Foo\n" 7177 "{\n" 7178 "} Foo_t;", 7179 Style); 7180 } 7181 7182 TEST_F(FormatTest, SplitEmptyNamespace) { 7183 FormatStyle Style = getLLVMStyle(); 7184 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 7185 Style.BraceWrapping.AfterNamespace = true; 7186 Style.BraceWrapping.SplitEmptyNamespace = false; 7187 7188 verifyFormat("namespace Foo\n" 7189 "{};", 7190 Style); 7191 verifyFormat("/* something */ namespace Foo\n" 7192 "{};", 7193 Style); 7194 verifyFormat("inline namespace Foo\n" 7195 "{};", 7196 Style); 7197 verifyFormat("namespace Foo\n" 7198 "{\n" 7199 "void Bar();\n" 7200 "};", 7201 Style); 7202 } 7203 7204 TEST_F(FormatTest, NeverMergeShortRecords) { 7205 FormatStyle Style = getLLVMStyle(); 7206 7207 verifyFormat("class Foo {\n" 7208 " Foo();\n" 7209 "};", 7210 Style); 7211 verifyFormat("typedef class Foo {\n" 7212 " Foo();\n" 7213 "} Foo_t;", 7214 Style); 7215 verifyFormat("struct Foo {\n" 7216 " Foo();\n" 7217 "};", 7218 Style); 7219 verifyFormat("typedef struct Foo {\n" 7220 " Foo();\n" 7221 "} Foo_t;", 7222 Style); 7223 verifyFormat("union Foo {\n" 7224 " A,\n" 7225 "};", 7226 Style); 7227 verifyFormat("typedef union Foo {\n" 7228 " A,\n" 7229 "} Foo_t;", 7230 Style); 7231 verifyFormat("namespace Foo {\n" 7232 "void Bar();\n" 7233 "};", 7234 Style); 7235 7236 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 7237 Style.BraceWrapping.AfterClass = true; 7238 Style.BraceWrapping.AfterStruct = true; 7239 Style.BraceWrapping.AfterUnion = true; 7240 Style.BraceWrapping.AfterNamespace = true; 7241 verifyFormat("class Foo\n" 7242 "{\n" 7243 " Foo();\n" 7244 "};", 7245 Style); 7246 verifyFormat("typedef class Foo\n" 7247 "{\n" 7248 " Foo();\n" 7249 "} Foo_t;", 7250 Style); 7251 verifyFormat("struct Foo\n" 7252 "{\n" 7253 " Foo();\n" 7254 "};", 7255 Style); 7256 verifyFormat("typedef struct Foo\n" 7257 "{\n" 7258 " Foo();\n" 7259 "} Foo_t;", 7260 Style); 7261 verifyFormat("union Foo\n" 7262 "{\n" 7263 " A,\n" 7264 "};", 7265 Style); 7266 verifyFormat("typedef union Foo\n" 7267 "{\n" 7268 " A,\n" 7269 "} Foo_t;", 7270 Style); 7271 verifyFormat("namespace Foo\n" 7272 "{\n" 7273 "void Bar();\n" 7274 "};", 7275 Style); 7276 } 7277 7278 TEST_F(FormatTest, UnderstandContextOfRecordTypeKeywords) { 7279 // Elaborate type variable declarations. 7280 verifyFormat("struct foo a = {bar};\nint n;"); 7281 verifyFormat("class foo a = {bar};\nint n;"); 7282 verifyFormat("union foo a = {bar};\nint n;"); 7283 7284 // Elaborate types inside function definitions. 7285 verifyFormat("struct foo f() {}\nint n;"); 7286 verifyFormat("class foo f() {}\nint n;"); 7287 verifyFormat("union foo f() {}\nint n;"); 7288 7289 // Templates. 7290 verifyFormat("template <class X> void f() {}\nint n;"); 7291 verifyFormat("template <struct X> void f() {}\nint n;"); 7292 verifyFormat("template <union X> void f() {}\nint n;"); 7293 7294 // Actual definitions... 7295 verifyFormat("struct {\n} n;"); 7296 verifyFormat( 7297 "template <template <class T, class Y>, class Z> class X {\n} n;"); 7298 verifyFormat("union Z {\n int n;\n} x;"); 7299 verifyFormat("class MACRO Z {\n} n;"); 7300 verifyFormat("class MACRO(X) Z {\n} n;"); 7301 verifyFormat("class __attribute__(X) Z {\n} n;"); 7302 verifyFormat("class __declspec(X) Z {\n} n;"); 7303 verifyFormat("class A##B##C {\n} n;"); 7304 verifyFormat("class alignas(16) Z {\n} n;"); 7305 verifyFormat("class MACRO(X) alignas(16) Z {\n} n;"); 7306 verifyFormat("class MACROA MACRO(X) Z {\n} n;"); 7307 7308 // Redefinition from nested context: 7309 verifyFormat("class A::B::C {\n} n;"); 7310 7311 // Template definitions. 7312 verifyFormat( 7313 "template <typename F>\n" 7314 "Matcher(const Matcher<F> &Other,\n" 7315 " typename enable_if_c<is_base_of<F, T>::value &&\n" 7316 " !is_same<F, T>::value>::type * = 0)\n" 7317 " : Implementation(new ImplicitCastMatcher<F>(Other)) {}"); 7318 7319 // FIXME: This is still incorrectly handled at the formatter side. 7320 verifyFormat("template <> struct X < 15, i<3 && 42 < 50 && 33 < 28> {};"); 7321 verifyFormat("int i = SomeFunction(a<b, a> b);"); 7322 7323 // FIXME: 7324 // This now gets parsed incorrectly as class definition. 7325 // verifyFormat("class A<int> f() {\n}\nint n;"); 7326 7327 // Elaborate types where incorrectly parsing the structural element would 7328 // break the indent. 7329 verifyFormat("if (true)\n" 7330 " class X x;\n" 7331 "else\n" 7332 " f();\n"); 7333 7334 // This is simply incomplete. Formatting is not important, but must not crash. 7335 verifyFormat("class A:"); 7336 } 7337 7338 TEST_F(FormatTest, DoNotInterfereWithErrorAndWarning) { 7339 EXPECT_EQ("#error Leave all white!!!!! space* alone!\n", 7340 format("#error Leave all white!!!!! space* alone!\n")); 7341 EXPECT_EQ( 7342 "#warning Leave all white!!!!! space* alone!\n", 7343 format("#warning Leave all white!!!!! space* alone!\n")); 7344 EXPECT_EQ("#error 1", format(" # error 1")); 7345 EXPECT_EQ("#warning 1", format(" # warning 1")); 7346 } 7347 7348 TEST_F(FormatTest, FormatHashIfExpressions) { 7349 verifyFormat("#if AAAA && BBBB"); 7350 verifyFormat("#if (AAAA && BBBB)"); 7351 verifyFormat("#elif (AAAA && BBBB)"); 7352 // FIXME: Come up with a better indentation for #elif. 7353 verifyFormat( 7354 "#if !defined(AAAAAAA) && (defined CCCCCC || defined DDDDDD) && \\\n" 7355 " defined(BBBBBBBB)\n" 7356 "#elif !defined(AAAAAA) && (defined CCCCC || defined DDDDDD) && \\\n" 7357 " defined(BBBBBBBB)\n" 7358 "#endif", 7359 getLLVMStyleWithColumns(65)); 7360 } 7361 7362 TEST_F(FormatTest, MergeHandlingInTheFaceOfPreprocessorDirectives) { 7363 FormatStyle AllowsMergedIf = getGoogleStyle(); 7364 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = true; 7365 verifyFormat("void f() { f(); }\n#error E", AllowsMergedIf); 7366 verifyFormat("if (true) return 42;\n#error E", AllowsMergedIf); 7367 verifyFormat("if (true)\n#error E\n return 42;", AllowsMergedIf); 7368 EXPECT_EQ("if (true) return 42;", 7369 format("if (true)\nreturn 42;", AllowsMergedIf)); 7370 FormatStyle ShortMergedIf = AllowsMergedIf; 7371 ShortMergedIf.ColumnLimit = 25; 7372 verifyFormat("#define A \\\n" 7373 " if (true) return 42;", 7374 ShortMergedIf); 7375 verifyFormat("#define A \\\n" 7376 " f(); \\\n" 7377 " if (true)\n" 7378 "#define B", 7379 ShortMergedIf); 7380 verifyFormat("#define A \\\n" 7381 " f(); \\\n" 7382 " if (true)\n" 7383 "g();", 7384 ShortMergedIf); 7385 verifyFormat("{\n" 7386 "#ifdef A\n" 7387 " // Comment\n" 7388 " if (true) continue;\n" 7389 "#endif\n" 7390 " // Comment\n" 7391 " if (true) continue;\n" 7392 "}", 7393 ShortMergedIf); 7394 ShortMergedIf.ColumnLimit = 33; 7395 verifyFormat("#define A \\\n" 7396 " if constexpr (true) return 42;", 7397 ShortMergedIf); 7398 ShortMergedIf.ColumnLimit = 29; 7399 verifyFormat("#define A \\\n" 7400 " if (aaaaaaaaaa) return 1; \\\n" 7401 " return 2;", 7402 ShortMergedIf); 7403 ShortMergedIf.ColumnLimit = 28; 7404 verifyFormat("#define A \\\n" 7405 " if (aaaaaaaaaa) \\\n" 7406 " return 1; \\\n" 7407 " return 2;", 7408 ShortMergedIf); 7409 verifyFormat("#define A \\\n" 7410 " if constexpr (aaaaaaa) \\\n" 7411 " return 1; \\\n" 7412 " return 2;", 7413 ShortMergedIf); 7414 } 7415 7416 TEST_F(FormatTest, FormatStarDependingOnContext) { 7417 verifyFormat("void f(int *a);"); 7418 verifyFormat("void f() { f(fint * b); }"); 7419 verifyFormat("class A {\n void f(int *a);\n};"); 7420 verifyFormat("class A {\n int *a;\n};"); 7421 verifyFormat("namespace a {\n" 7422 "namespace b {\n" 7423 "class A {\n" 7424 " void f() {}\n" 7425 " int *a;\n" 7426 "};\n" 7427 "} // namespace b\n" 7428 "} // namespace a"); 7429 } 7430 7431 TEST_F(FormatTest, SpecialTokensAtEndOfLine) { 7432 verifyFormat("while"); 7433 verifyFormat("operator"); 7434 } 7435 7436 TEST_F(FormatTest, SkipsDeeplyNestedLines) { 7437 // This code would be painfully slow to format if we didn't skip it. 7438 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 7439 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 7440 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 7441 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 7442 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 7443 "A(1, 1)\n" 7444 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" // 10x 7445 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 7446 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 7447 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 7448 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 7449 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 7450 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 7451 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 7452 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 7453 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1);\n"); 7454 // Deeply nested part is untouched, rest is formatted. 7455 EXPECT_EQ(std::string("int i;\n") + Code + "int j;\n", 7456 format(std::string("int i;\n") + Code + "int j;\n", 7457 getLLVMStyle(), SC_ExpectIncomplete)); 7458 } 7459 7460 //===----------------------------------------------------------------------===// 7461 // Objective-C tests. 7462 //===----------------------------------------------------------------------===// 7463 7464 TEST_F(FormatTest, FormatForObjectiveCMethodDecls) { 7465 verifyFormat("- (void)sendAction:(SEL)aSelector to:(BOOL)anObject;"); 7466 EXPECT_EQ("- (NSUInteger)indexOfObject:(id)anObject;", 7467 format("-(NSUInteger)indexOfObject:(id)anObject;")); 7468 EXPECT_EQ("- (NSInteger)Mthod1;", format("-(NSInteger)Mthod1;")); 7469 EXPECT_EQ("+ (id)Mthod2;", format("+(id)Mthod2;")); 7470 EXPECT_EQ("- (NSInteger)Method3:(id)anObject;", 7471 format("-(NSInteger)Method3:(id)anObject;")); 7472 EXPECT_EQ("- (NSInteger)Method4:(id)anObject;", 7473 format("-(NSInteger)Method4:(id)anObject;")); 7474 EXPECT_EQ("- (NSInteger)Method5:(id)anObject:(id)AnotherObject;", 7475 format("-(NSInteger)Method5:(id)anObject:(id)AnotherObject;")); 7476 EXPECT_EQ("- (id)Method6:(id)A:(id)B:(id)C:(id)D;", 7477 format("- (id)Method6:(id)A:(id)B:(id)C:(id)D;")); 7478 EXPECT_EQ("- (void)sendAction:(SEL)aSelector to:(id)anObject " 7479 "forAllCells:(BOOL)flag;", 7480 format("- (void)sendAction:(SEL)aSelector to:(id)anObject " 7481 "forAllCells:(BOOL)flag;")); 7482 7483 // Very long objectiveC method declaration. 7484 verifyFormat("- (void)aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n" 7485 " (SoooooooooooooooooooooomeType *)bbbbbbbbbb;"); 7486 verifyFormat("- (NSUInteger)indexOfObject:(id)anObject\n" 7487 " inRange:(NSRange)range\n" 7488 " outRange:(NSRange)out_range\n" 7489 " outRange1:(NSRange)out_range1\n" 7490 " outRange2:(NSRange)out_range2\n" 7491 " outRange3:(NSRange)out_range3\n" 7492 " outRange4:(NSRange)out_range4\n" 7493 " outRange5:(NSRange)out_range5\n" 7494 " outRange6:(NSRange)out_range6\n" 7495 " outRange7:(NSRange)out_range7\n" 7496 " outRange8:(NSRange)out_range8\n" 7497 " outRange9:(NSRange)out_range9;"); 7498 7499 // When the function name has to be wrapped. 7500 FormatStyle Style = getLLVMStyle(); 7501 Style.IndentWrappedFunctionNames = false; 7502 verifyFormat("- (SomeLooooooooooooooooooooongType *)\n" 7503 "veryLooooooooooongName:(NSString)aaaaaaaaaaaaaa\n" 7504 " anotherName:(NSString)bbbbbbbbbbbbbb {\n" 7505 "}", 7506 Style); 7507 Style.IndentWrappedFunctionNames = true; 7508 verifyFormat("- (SomeLooooooooooooooooooooongType *)\n" 7509 " veryLooooooooooongName:(NSString)aaaaaaaaaaaaaa\n" 7510 " anotherName:(NSString)bbbbbbbbbbbbbb {\n" 7511 "}", 7512 Style); 7513 7514 verifyFormat("- (int)sum:(vector<int>)numbers;"); 7515 verifyGoogleFormat("- (void)setDelegate:(id<Protocol>)delegate;"); 7516 // FIXME: In LLVM style, there should be a space in front of a '<' for ObjC 7517 // protocol lists (but not for template classes): 7518 // verifyFormat("- (void)setDelegate:(id <Protocol>)delegate;"); 7519 7520 verifyFormat("- (int (*)())foo:(int (*)())f;"); 7521 verifyGoogleFormat("- (int (*)())foo:(int (*)())foo;"); 7522 7523 // If there's no return type (very rare in practice!), LLVM and Google style 7524 // agree. 7525 verifyFormat("- foo;"); 7526 verifyFormat("- foo:(int)f;"); 7527 verifyGoogleFormat("- foo:(int)foo;"); 7528 } 7529 7530 7531 TEST_F(FormatTest, BreaksStringLiterals) { 7532 EXPECT_EQ("\"some text \"\n" 7533 "\"other\";", 7534 format("\"some text other\";", getLLVMStyleWithColumns(12))); 7535 EXPECT_EQ("\"some text \"\n" 7536 "\"other\";", 7537 format("\\\n\"some text other\";", getLLVMStyleWithColumns(12))); 7538 EXPECT_EQ( 7539 "#define A \\\n" 7540 " \"some \" \\\n" 7541 " \"text \" \\\n" 7542 " \"other\";", 7543 format("#define A \"some text other\";", getLLVMStyleWithColumns(12))); 7544 EXPECT_EQ( 7545 "#define A \\\n" 7546 " \"so \" \\\n" 7547 " \"text \" \\\n" 7548 " \"other\";", 7549 format("#define A \"so text other\";", getLLVMStyleWithColumns(12))); 7550 7551 EXPECT_EQ("\"some text\"", 7552 format("\"some text\"", getLLVMStyleWithColumns(1))); 7553 EXPECT_EQ("\"some text\"", 7554 format("\"some text\"", getLLVMStyleWithColumns(11))); 7555 EXPECT_EQ("\"some \"\n" 7556 "\"text\"", 7557 format("\"some text\"", getLLVMStyleWithColumns(10))); 7558 EXPECT_EQ("\"some \"\n" 7559 "\"text\"", 7560 format("\"some text\"", getLLVMStyleWithColumns(7))); 7561 EXPECT_EQ("\"some\"\n" 7562 "\" tex\"\n" 7563 "\"t\"", 7564 format("\"some text\"", getLLVMStyleWithColumns(6))); 7565 EXPECT_EQ("\"some\"\n" 7566 "\" tex\"\n" 7567 "\" and\"", 7568 format("\"some tex and\"", getLLVMStyleWithColumns(6))); 7569 EXPECT_EQ("\"some\"\n" 7570 "\"/tex\"\n" 7571 "\"/and\"", 7572 format("\"some/tex/and\"", getLLVMStyleWithColumns(6))); 7573 7574 EXPECT_EQ("variable =\n" 7575 " \"long string \"\n" 7576 " \"literal\";", 7577 format("variable = \"long string literal\";", 7578 getLLVMStyleWithColumns(20))); 7579 7580 EXPECT_EQ("variable = f(\n" 7581 " \"long string \"\n" 7582 " \"literal\",\n" 7583 " short,\n" 7584 " loooooooooooooooooooong);", 7585 format("variable = f(\"long string literal\", short, " 7586 "loooooooooooooooooooong);", 7587 getLLVMStyleWithColumns(20))); 7588 7589 EXPECT_EQ( 7590 "f(g(\"long string \"\n" 7591 " \"literal\"),\n" 7592 " b);", 7593 format("f(g(\"long string literal\"), b);", getLLVMStyleWithColumns(20))); 7594 EXPECT_EQ("f(g(\"long string \"\n" 7595 " \"literal\",\n" 7596 " a),\n" 7597 " b);", 7598 format("f(g(\"long string literal\", a), b);", 7599 getLLVMStyleWithColumns(20))); 7600 EXPECT_EQ( 7601 "f(\"one two\".split(\n" 7602 " variable));", 7603 format("f(\"one two\".split(variable));", getLLVMStyleWithColumns(20))); 7604 EXPECT_EQ("f(\"one two three four five six \"\n" 7605 " \"seven\".split(\n" 7606 " really_looooong_variable));", 7607 format("f(\"one two three four five six seven\"." 7608 "split(really_looooong_variable));", 7609 getLLVMStyleWithColumns(33))); 7610 7611 EXPECT_EQ("f(\"some \"\n" 7612 " \"text\",\n" 7613 " other);", 7614 format("f(\"some text\", other);", getLLVMStyleWithColumns(10))); 7615 7616 // Only break as a last resort. 7617 verifyFormat( 7618 "aaaaaaaaaaaaaaaaaaaa(\n" 7619 " aaaaaaaaaaaaaaaaaaaa,\n" 7620 " aaaaaa(\"aaa aaaaa aaa aaa aaaaa aaa aaaaa aaa aaa aaaaaa\"));"); 7621 7622 EXPECT_EQ("\"splitmea\"\n" 7623 "\"trandomp\"\n" 7624 "\"oint\"", 7625 format("\"splitmeatrandompoint\"", getLLVMStyleWithColumns(10))); 7626 7627 EXPECT_EQ("\"split/\"\n" 7628 "\"pathat/\"\n" 7629 "\"slashes\"", 7630 format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10))); 7631 7632 EXPECT_EQ("\"split/\"\n" 7633 "\"pathat/\"\n" 7634 "\"slashes\"", 7635 format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10))); 7636 EXPECT_EQ("\"split at \"\n" 7637 "\"spaces/at/\"\n" 7638 "\"slashes.at.any$\"\n" 7639 "\"non-alphanumeric%\"\n" 7640 "\"1111111111characte\"\n" 7641 "\"rs\"", 7642 format("\"split at " 7643 "spaces/at/" 7644 "slashes.at." 7645 "any$non-" 7646 "alphanumeric%" 7647 "1111111111characte" 7648 "rs\"", 7649 getLLVMStyleWithColumns(20))); 7650 7651 // Verify that splitting the strings understands 7652 // Style::AlwaysBreakBeforeMultilineStrings. 7653 EXPECT_EQ( 7654 "aaaaaaaaaaaa(\n" 7655 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa \"\n" 7656 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\");", 7657 format("aaaaaaaaaaaa(\"aaaaaaaaaaaaaaaaaaaaaaaaaa " 7658 "aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa " 7659 "aaaaaaaaaaaaaaaaaaaaaa\");", 7660 getGoogleStyle())); 7661 EXPECT_EQ("return \"aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 7662 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\";", 7663 format("return \"aaaaaaaaaaaaaaaaaaaaaa " 7664 "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa " 7665 "aaaaaaaaaaaaaaaaaaaaaa\";", 7666 getGoogleStyle())); 7667 EXPECT_EQ("llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 7668 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";", 7669 format("llvm::outs() << " 7670 "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa" 7671 "aaaaaaaaaaaaaaaaaaa\";")); 7672 EXPECT_EQ("ffff(\n" 7673 " {\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 7674 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});", 7675 format("ffff({\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa " 7676 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});", 7677 getGoogleStyle())); 7678 7679 FormatStyle Style = getLLVMStyleWithColumns(12); 7680 Style.BreakStringLiterals = false; 7681 EXPECT_EQ("\"some text other\";", format("\"some text other\";", Style)); 7682 7683 FormatStyle AlignLeft = getLLVMStyleWithColumns(12); 7684 AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left; 7685 EXPECT_EQ("#define A \\\n" 7686 " \"some \" \\\n" 7687 " \"text \" \\\n" 7688 " \"other\";", 7689 format("#define A \"some text other\";", AlignLeft)); 7690 } 7691 7692 TEST_F(FormatTest, FullyRemoveEmptyLines) { 7693 FormatStyle NoEmptyLines = getLLVMStyleWithColumns(80); 7694 NoEmptyLines.MaxEmptyLinesToKeep = 0; 7695 EXPECT_EQ("int i = a(b());", 7696 format("int i=a(\n\n b(\n\n\n )\n\n);", NoEmptyLines)); 7697 } 7698 7699 TEST_F(FormatTest, BreaksStringLiteralsWithTabs) { 7700 EXPECT_EQ( 7701 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 7702 "(\n" 7703 " \"x\t\");", 7704 format("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 7705 "aaaaaaa(" 7706 "\"x\t\");")); 7707 } 7708 7709 TEST_F(FormatTest, BreaksWideAndNSStringLiterals) { 7710 EXPECT_EQ( 7711 "u8\"utf8 string \"\n" 7712 "u8\"literal\";", 7713 format("u8\"utf8 string literal\";", getGoogleStyleWithColumns(16))); 7714 EXPECT_EQ( 7715 "u\"utf16 string \"\n" 7716 "u\"literal\";", 7717 format("u\"utf16 string literal\";", getGoogleStyleWithColumns(16))); 7718 EXPECT_EQ( 7719 "U\"utf32 string \"\n" 7720 "U\"literal\";", 7721 format("U\"utf32 string literal\";", getGoogleStyleWithColumns(16))); 7722 EXPECT_EQ("L\"wide string \"\n" 7723 "L\"literal\";", 7724 format("L\"wide string literal\";", getGoogleStyleWithColumns(16))); 7725 EXPECT_EQ("@\"NSString \"\n" 7726 "@\"literal\";", 7727 format("@\"NSString literal\";", getGoogleStyleWithColumns(19))); 7728 verifyFormat(R"(NSString *s = @"那那那那";)", getLLVMStyleWithColumns(26)); 7729 7730 // This input makes clang-format try to split the incomplete unicode escape 7731 // sequence, which used to lead to a crasher. 7732 verifyNoCrash( 7733 "aaaaaaaaaaaaaaaaaaaa = L\"\\udff\"'; // aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 7734 getLLVMStyleWithColumns(60)); 7735 } 7736 7737 TEST_F(FormatTest, DoesNotBreakRawStringLiterals) { 7738 FormatStyle Style = getGoogleStyleWithColumns(15); 7739 EXPECT_EQ("R\"x(raw literal)x\";", format("R\"x(raw literal)x\";", Style)); 7740 EXPECT_EQ("uR\"x(raw literal)x\";", format("uR\"x(raw literal)x\";", Style)); 7741 EXPECT_EQ("LR\"x(raw literal)x\";", format("LR\"x(raw literal)x\";", Style)); 7742 EXPECT_EQ("UR\"x(raw literal)x\";", format("UR\"x(raw literal)x\";", Style)); 7743 EXPECT_EQ("u8R\"x(raw literal)x\";", 7744 format("u8R\"x(raw literal)x\";", Style)); 7745 } 7746 7747 TEST_F(FormatTest, BreaksStringLiteralsWithin_TMacro) { 7748 FormatStyle Style = getLLVMStyleWithColumns(20); 7749 EXPECT_EQ( 7750 "_T(\"aaaaaaaaaaaaaa\")\n" 7751 "_T(\"aaaaaaaaaaaaaa\")\n" 7752 "_T(\"aaaaaaaaaaaa\")", 7753 format(" _T(\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\")", Style)); 7754 EXPECT_EQ("f(x,\n" 7755 " _T(\"aaaaaaaaaaaa\")\n" 7756 " _T(\"aaa\"),\n" 7757 " z);", 7758 format("f(x, _T(\"aaaaaaaaaaaaaaa\"), z);", Style)); 7759 7760 // FIXME: Handle embedded spaces in one iteration. 7761 // EXPECT_EQ("_T(\"aaaaaaaaaaaaa\")\n" 7762 // "_T(\"aaaaaaaaaaaaa\")\n" 7763 // "_T(\"aaaaaaaaaaaaa\")\n" 7764 // "_T(\"a\")", 7765 // format(" _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", 7766 // getLLVMStyleWithColumns(20))); 7767 EXPECT_EQ( 7768 "_T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", 7769 format(" _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", Style)); 7770 EXPECT_EQ("f(\n" 7771 "#if !TEST\n" 7772 " _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n" 7773 "#endif\n" 7774 ");", 7775 format("f(\n" 7776 "#if !TEST\n" 7777 "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n" 7778 "#endif\n" 7779 ");")); 7780 EXPECT_EQ("f(\n" 7781 "\n" 7782 " _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));", 7783 format("f(\n" 7784 "\n" 7785 "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));")); 7786 } 7787 7788 TEST_F(FormatTest, BreaksStringLiteralOperands) { 7789 // In a function call with two operands, the second can be broken with no line 7790 // break before it. 7791 EXPECT_EQ("func(a, \"long long \"\n" 7792 " \"long long\");", 7793 format("func(a, \"long long long long\");", 7794 getLLVMStyleWithColumns(24))); 7795 // In a function call with three operands, the second must be broken with a 7796 // line break before it. 7797 EXPECT_EQ("func(a,\n" 7798 " \"long long long \"\n" 7799 " \"long\",\n" 7800 " c);", 7801 format("func(a, \"long long long long\", c);", 7802 getLLVMStyleWithColumns(24))); 7803 // In a function call with three operands, the third must be broken with a 7804 // line break before it. 7805 EXPECT_EQ("func(a, b,\n" 7806 " \"long long long \"\n" 7807 " \"long\");", 7808 format("func(a, b, \"long long long long\");", 7809 getLLVMStyleWithColumns(24))); 7810 // In a function call with three operands, both the second and the third must 7811 // be broken with a line break before them. 7812 EXPECT_EQ("func(a,\n" 7813 " \"long long long \"\n" 7814 " \"long\",\n" 7815 " \"long long long \"\n" 7816 " \"long\");", 7817 format("func(a, \"long long long long\", \"long long long long\");", 7818 getLLVMStyleWithColumns(24))); 7819 // In a chain of << with two operands, the second can be broken with no line 7820 // break before it. 7821 EXPECT_EQ("a << \"line line \"\n" 7822 " \"line\";", 7823 format("a << \"line line line\";", 7824 getLLVMStyleWithColumns(20))); 7825 // In a chain of << with three operands, the second can be broken with no line 7826 // break before it. 7827 EXPECT_EQ("abcde << \"line \"\n" 7828 " \"line line\"\n" 7829 " << c;", 7830 format("abcde << \"line line line\" << c;", 7831 getLLVMStyleWithColumns(20))); 7832 // In a chain of << with three operands, the third must be broken with a line 7833 // break before it. 7834 EXPECT_EQ("a << b\n" 7835 " << \"line line \"\n" 7836 " \"line\";", 7837 format("a << b << \"line line line\";", 7838 getLLVMStyleWithColumns(20))); 7839 // In a chain of << with three operands, the second can be broken with no line 7840 // break before it and the third must be broken with a line break before it. 7841 EXPECT_EQ("abcd << \"line line \"\n" 7842 " \"line\"\n" 7843 " << \"line line \"\n" 7844 " \"line\";", 7845 format("abcd << \"line line line\" << \"line line line\";", 7846 getLLVMStyleWithColumns(20))); 7847 // In a chain of binary operators with two operands, the second can be broken 7848 // with no line break before it. 7849 EXPECT_EQ("abcd + \"line line \"\n" 7850 " \"line line\";", 7851 format("abcd + \"line line line line\";", 7852 getLLVMStyleWithColumns(20))); 7853 // In a chain of binary operators with three operands, the second must be 7854 // broken with a line break before it. 7855 EXPECT_EQ("abcd +\n" 7856 " \"line line \"\n" 7857 " \"line line\" +\n" 7858 " e;", 7859 format("abcd + \"line line line line\" + e;", 7860 getLLVMStyleWithColumns(20))); 7861 // In a function call with two operands, with AlignAfterOpenBracket enabled, 7862 // the first must be broken with a line break before it. 7863 FormatStyle Style = getLLVMStyleWithColumns(25); 7864 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 7865 EXPECT_EQ("someFunction(\n" 7866 " \"long long long \"\n" 7867 " \"long\",\n" 7868 " a);", 7869 format("someFunction(\"long long long long\", a);", Style)); 7870 } 7871 7872 TEST_F(FormatTest, DontSplitStringLiteralsWithEscapedNewlines) { 7873 EXPECT_EQ( 7874 "aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 7875 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 7876 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";", 7877 format("aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 7878 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 7879 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";")); 7880 } 7881 7882 TEST_F(FormatTest, CountsCharactersInMultilineRawStringLiterals) { 7883 EXPECT_EQ("f(g(R\"x(raw literal)x\", a), b);", 7884 format("f(g(R\"x(raw literal)x\", a), b);", getGoogleStyle())); 7885 EXPECT_EQ("fffffffffff(g(R\"x(\n" 7886 "multiline raw string literal xxxxxxxxxxxxxx\n" 7887 ")x\",\n" 7888 " a),\n" 7889 " b);", 7890 format("fffffffffff(g(R\"x(\n" 7891 "multiline raw string literal xxxxxxxxxxxxxx\n" 7892 ")x\", a), b);", 7893 getGoogleStyleWithColumns(20))); 7894 EXPECT_EQ("fffffffffff(\n" 7895 " g(R\"x(qqq\n" 7896 "multiline raw string literal xxxxxxxxxxxxxx\n" 7897 ")x\",\n" 7898 " a),\n" 7899 " b);", 7900 format("fffffffffff(g(R\"x(qqq\n" 7901 "multiline raw string literal xxxxxxxxxxxxxx\n" 7902 ")x\", a), b);", 7903 getGoogleStyleWithColumns(20))); 7904 7905 EXPECT_EQ("fffffffffff(R\"x(\n" 7906 "multiline raw string literal xxxxxxxxxxxxxx\n" 7907 ")x\");", 7908 format("fffffffffff(R\"x(\n" 7909 "multiline raw string literal xxxxxxxxxxxxxx\n" 7910 ")x\");", 7911 getGoogleStyleWithColumns(20))); 7912 EXPECT_EQ("fffffffffff(R\"x(\n" 7913 "multiline raw string literal xxxxxxxxxxxxxx\n" 7914 ")x\" + bbbbbb);", 7915 format("fffffffffff(R\"x(\n" 7916 "multiline raw string literal xxxxxxxxxxxxxx\n" 7917 ")x\" + bbbbbb);", 7918 getGoogleStyleWithColumns(20))); 7919 EXPECT_EQ("fffffffffff(\n" 7920 " R\"x(\n" 7921 "multiline raw string literal xxxxxxxxxxxxxx\n" 7922 ")x\" +\n" 7923 " bbbbbb);", 7924 format("fffffffffff(\n" 7925 " R\"x(\n" 7926 "multiline raw string literal xxxxxxxxxxxxxx\n" 7927 ")x\" + bbbbbb);", 7928 getGoogleStyleWithColumns(20))); 7929 } 7930 7931 TEST_F(FormatTest, SkipsUnknownStringLiterals) { 7932 verifyFormat("string a = \"unterminated;"); 7933 EXPECT_EQ("function(\"unterminated,\n" 7934 " OtherParameter);", 7935 format("function( \"unterminated,\n" 7936 " OtherParameter);")); 7937 } 7938 7939 TEST_F(FormatTest, DoesNotTryToParseUDLiteralsInPreCpp11Code) { 7940 FormatStyle Style = getLLVMStyle(); 7941 Style.Standard = FormatStyle::LS_Cpp03; 7942 EXPECT_EQ("#define x(_a) printf(\"foo\" _a);", 7943 format("#define x(_a) printf(\"foo\"_a);", Style)); 7944 } 7945 7946 TEST_F(FormatTest, UnderstandsCpp1y) { verifyFormat("int bi{1'000'000};"); } 7947 7948 TEST_F(FormatTest, BreakStringLiteralsBeforeUnbreakableTokenSequence) { 7949 EXPECT_EQ("someFunction(\"aaabbbcccd\"\n" 7950 " \"ddeeefff\");", 7951 format("someFunction(\"aaabbbcccdddeeefff\");", 7952 getLLVMStyleWithColumns(25))); 7953 EXPECT_EQ("someFunction1234567890(\n" 7954 " \"aaabbbcccdddeeefff\");", 7955 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 7956 getLLVMStyleWithColumns(26))); 7957 EXPECT_EQ("someFunction1234567890(\n" 7958 " \"aaabbbcccdddeeeff\"\n" 7959 " \"f\");", 7960 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 7961 getLLVMStyleWithColumns(25))); 7962 EXPECT_EQ("someFunction1234567890(\n" 7963 " \"aaabbbcccdddeeeff\"\n" 7964 " \"f\");", 7965 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 7966 getLLVMStyleWithColumns(24))); 7967 EXPECT_EQ("someFunction(\"aaabbbcc \"\n" 7968 " \"ddde \"\n" 7969 " \"efff\");", 7970 format("someFunction(\"aaabbbcc ddde efff\");", 7971 getLLVMStyleWithColumns(25))); 7972 EXPECT_EQ("someFunction(\"aaabbbccc \"\n" 7973 " \"ddeeefff\");", 7974 format("someFunction(\"aaabbbccc ddeeefff\");", 7975 getLLVMStyleWithColumns(25))); 7976 EXPECT_EQ("someFunction1234567890(\n" 7977 " \"aaabb \"\n" 7978 " \"cccdddeeefff\");", 7979 format("someFunction1234567890(\"aaabb cccdddeeefff\");", 7980 getLLVMStyleWithColumns(25))); 7981 EXPECT_EQ("#define A \\\n" 7982 " string s = \\\n" 7983 " \"123456789\" \\\n" 7984 " \"0\"; \\\n" 7985 " int i;", 7986 format("#define A string s = \"1234567890\"; int i;", 7987 getLLVMStyleWithColumns(20))); 7988 // FIXME: Put additional penalties on breaking at non-whitespace locations. 7989 EXPECT_EQ("someFunction(\"aaabbbcc \"\n" 7990 " \"dddeeeff\"\n" 7991 " \"f\");", 7992 format("someFunction(\"aaabbbcc dddeeefff\");", 7993 getLLVMStyleWithColumns(25))); 7994 } 7995 7996 TEST_F(FormatTest, DoNotBreakStringLiteralsInEscapeSequence) { 7997 EXPECT_EQ("\"\\a\"", format("\"\\a\"", getLLVMStyleWithColumns(3))); 7998 EXPECT_EQ("\"\\\"", format("\"\\\"", getLLVMStyleWithColumns(2))); 7999 EXPECT_EQ("\"test\"\n" 8000 "\"\\n\"", 8001 format("\"test\\n\"", getLLVMStyleWithColumns(7))); 8002 EXPECT_EQ("\"tes\\\\\"\n" 8003 "\"n\"", 8004 format("\"tes\\\\n\"", getLLVMStyleWithColumns(7))); 8005 EXPECT_EQ("\"\\\\\\\\\"\n" 8006 "\"\\n\"", 8007 format("\"\\\\\\\\\\n\"", getLLVMStyleWithColumns(7))); 8008 EXPECT_EQ("\"\\uff01\"", format("\"\\uff01\"", getLLVMStyleWithColumns(7))); 8009 EXPECT_EQ("\"\\uff01\"\n" 8010 "\"test\"", 8011 format("\"\\uff01test\"", getLLVMStyleWithColumns(8))); 8012 EXPECT_EQ("\"\\Uff01ff02\"", 8013 format("\"\\Uff01ff02\"", getLLVMStyleWithColumns(11))); 8014 EXPECT_EQ("\"\\x000000000001\"\n" 8015 "\"next\"", 8016 format("\"\\x000000000001next\"", getLLVMStyleWithColumns(16))); 8017 EXPECT_EQ("\"\\x000000000001next\"", 8018 format("\"\\x000000000001next\"", getLLVMStyleWithColumns(15))); 8019 EXPECT_EQ("\"\\x000000000001\"", 8020 format("\"\\x000000000001\"", getLLVMStyleWithColumns(7))); 8021 EXPECT_EQ("\"test\"\n" 8022 "\"\\000000\"\n" 8023 "\"000001\"", 8024 format("\"test\\000000000001\"", getLLVMStyleWithColumns(9))); 8025 EXPECT_EQ("\"test\\000\"\n" 8026 "\"00000000\"\n" 8027 "\"1\"", 8028 format("\"test\\000000000001\"", getLLVMStyleWithColumns(10))); 8029 } 8030 8031 TEST_F(FormatTest, DoNotCreateUnreasonableUnwrappedLines) { 8032 verifyFormat("void f() {\n" 8033 " return g() {}\n" 8034 " void h() {}"); 8035 verifyFormat("int a[] = {void forgot_closing_brace(){f();\n" 8036 "g();\n" 8037 "}"); 8038 } 8039 8040 TEST_F(FormatTest, DoNotPrematurelyEndUnwrappedLineForReturnStatements) { 8041 verifyFormat( 8042 "void f() { return C{param1, param2}.SomeCall(param1, param2); }"); 8043 } 8044 8045 TEST_F(FormatTest, FormatsClosingBracesInEmptyNestedBlocks) { 8046 verifyFormat("class X {\n" 8047 " void f() {\n" 8048 " }\n" 8049 "};", 8050 getLLVMStyleWithColumns(12)); 8051 } 8052 8053 TEST_F(FormatTest, ConfigurableIndentWidth) { 8054 FormatStyle EightIndent = getLLVMStyleWithColumns(18); 8055 EightIndent.IndentWidth = 8; 8056 EightIndent.ContinuationIndentWidth = 8; 8057 verifyFormat("void f() {\n" 8058 " someFunction();\n" 8059 " if (true) {\n" 8060 " f();\n" 8061 " }\n" 8062 "}", 8063 EightIndent); 8064 verifyFormat("class X {\n" 8065 " void f() {\n" 8066 " }\n" 8067 "};", 8068 EightIndent); 8069 verifyFormat("int x[] = {\n" 8070 " call(),\n" 8071 " call()};", 8072 EightIndent); 8073 } 8074 8075 TEST_F(FormatTest, ConfigurableFunctionDeclarationIndentAfterType) { 8076 verifyFormat("double\n" 8077 "f();", 8078 getLLVMStyleWithColumns(8)); 8079 } 8080 8081 TEST_F(FormatTest, ConfigurableUseOfTab) { 8082 FormatStyle Tab = getLLVMStyleWithColumns(42); 8083 Tab.IndentWidth = 8; 8084 Tab.UseTab = FormatStyle::UT_Always; 8085 Tab.AlignEscapedNewlines = FormatStyle::ENAS_Left; 8086 8087 EXPECT_EQ("if (aaaaaaaa && // q\n" 8088 " bb)\t\t// w\n" 8089 "\t;", 8090 format("if (aaaaaaaa &&// q\n" 8091 "bb)// w\n" 8092 ";", 8093 Tab)); 8094 EXPECT_EQ("if (aaa && bbb) // w\n" 8095 "\t;", 8096 format("if(aaa&&bbb)// w\n" 8097 ";", 8098 Tab)); 8099 8100 verifyFormat("class X {\n" 8101 "\tvoid f() {\n" 8102 "\t\tsomeFunction(parameter1,\n" 8103 "\t\t\t parameter2);\n" 8104 "\t}\n" 8105 "};", 8106 Tab); 8107 verifyFormat("#define A \\\n" 8108 "\tvoid f() { \\\n" 8109 "\t\tsomeFunction( \\\n" 8110 "\t\t parameter1, \\\n" 8111 "\t\t parameter2); \\\n" 8112 "\t}", 8113 Tab); 8114 8115 Tab.TabWidth = 4; 8116 Tab.IndentWidth = 8; 8117 verifyFormat("class TabWidth4Indent8 {\n" 8118 "\t\tvoid f() {\n" 8119 "\t\t\t\tsomeFunction(parameter1,\n" 8120 "\t\t\t\t\t\t\t parameter2);\n" 8121 "\t\t}\n" 8122 "};", 8123 Tab); 8124 8125 Tab.TabWidth = 4; 8126 Tab.IndentWidth = 4; 8127 verifyFormat("class TabWidth4Indent4 {\n" 8128 "\tvoid f() {\n" 8129 "\t\tsomeFunction(parameter1,\n" 8130 "\t\t\t\t\t parameter2);\n" 8131 "\t}\n" 8132 "};", 8133 Tab); 8134 8135 Tab.TabWidth = 8; 8136 Tab.IndentWidth = 4; 8137 verifyFormat("class TabWidth8Indent4 {\n" 8138 " void f() {\n" 8139 "\tsomeFunction(parameter1,\n" 8140 "\t\t parameter2);\n" 8141 " }\n" 8142 "};", 8143 Tab); 8144 8145 Tab.TabWidth = 8; 8146 Tab.IndentWidth = 8; 8147 EXPECT_EQ("/*\n" 8148 "\t a\t\tcomment\n" 8149 "\t in multiple lines\n" 8150 " */", 8151 format(" /*\t \t \n" 8152 " \t \t a\t\tcomment\t \t\n" 8153 " \t \t in multiple lines\t\n" 8154 " \t */", 8155 Tab)); 8156 8157 Tab.UseTab = FormatStyle::UT_ForIndentation; 8158 verifyFormat("{\n" 8159 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 8160 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 8161 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 8162 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 8163 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 8164 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 8165 "};", 8166 Tab); 8167 verifyFormat("enum AA {\n" 8168 "\ta1, // Force multiple lines\n" 8169 "\ta2,\n" 8170 "\ta3\n" 8171 "};", 8172 Tab); 8173 EXPECT_EQ("if (aaaaaaaa && // q\n" 8174 " bb) // w\n" 8175 "\t;", 8176 format("if (aaaaaaaa &&// q\n" 8177 "bb)// w\n" 8178 ";", 8179 Tab)); 8180 verifyFormat("class X {\n" 8181 "\tvoid f() {\n" 8182 "\t\tsomeFunction(parameter1,\n" 8183 "\t\t parameter2);\n" 8184 "\t}\n" 8185 "};", 8186 Tab); 8187 verifyFormat("{\n" 8188 "\tQ(\n" 8189 "\t {\n" 8190 "\t\t int a;\n" 8191 "\t\t someFunction(aaaaaaaa,\n" 8192 "\t\t bbbbbbb);\n" 8193 "\t },\n" 8194 "\t p);\n" 8195 "}", 8196 Tab); 8197 EXPECT_EQ("{\n" 8198 "\t/* aaaa\n" 8199 "\t bbbb */\n" 8200 "}", 8201 format("{\n" 8202 "/* aaaa\n" 8203 " bbbb */\n" 8204 "}", 8205 Tab)); 8206 EXPECT_EQ("{\n" 8207 "\t/*\n" 8208 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 8209 "\t bbbbbbbbbbbbb\n" 8210 "\t*/\n" 8211 "}", 8212 format("{\n" 8213 "/*\n" 8214 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 8215 "*/\n" 8216 "}", 8217 Tab)); 8218 EXPECT_EQ("{\n" 8219 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 8220 "\t// bbbbbbbbbbbbb\n" 8221 "}", 8222 format("{\n" 8223 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 8224 "}", 8225 Tab)); 8226 EXPECT_EQ("{\n" 8227 "\t/*\n" 8228 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 8229 "\t bbbbbbbbbbbbb\n" 8230 "\t*/\n" 8231 "}", 8232 format("{\n" 8233 "\t/*\n" 8234 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 8235 "\t*/\n" 8236 "}", 8237 Tab)); 8238 EXPECT_EQ("{\n" 8239 "\t/*\n" 8240 "\n" 8241 "\t*/\n" 8242 "}", 8243 format("{\n" 8244 "\t/*\n" 8245 "\n" 8246 "\t*/\n" 8247 "}", 8248 Tab)); 8249 EXPECT_EQ("{\n" 8250 "\t/*\n" 8251 " asdf\n" 8252 "\t*/\n" 8253 "}", 8254 format("{\n" 8255 "\t/*\n" 8256 " asdf\n" 8257 "\t*/\n" 8258 "}", 8259 Tab)); 8260 8261 Tab.UseTab = FormatStyle::UT_Never; 8262 EXPECT_EQ("/*\n" 8263 " a\t\tcomment\n" 8264 " in multiple lines\n" 8265 " */", 8266 format(" /*\t \t \n" 8267 " \t \t a\t\tcomment\t \t\n" 8268 " \t \t in multiple lines\t\n" 8269 " \t */", 8270 Tab)); 8271 EXPECT_EQ("/* some\n" 8272 " comment */", 8273 format(" \t \t /* some\n" 8274 " \t \t comment */", 8275 Tab)); 8276 EXPECT_EQ("int a; /* some\n" 8277 " comment */", 8278 format(" \t \t int a; /* some\n" 8279 " \t \t comment */", 8280 Tab)); 8281 8282 EXPECT_EQ("int a; /* some\n" 8283 "comment */", 8284 format(" \t \t int\ta; /* some\n" 8285 " \t \t comment */", 8286 Tab)); 8287 EXPECT_EQ("f(\"\t\t\"); /* some\n" 8288 " comment */", 8289 format(" \t \t f(\"\t\t\"); /* some\n" 8290 " \t \t comment */", 8291 Tab)); 8292 EXPECT_EQ("{\n" 8293 " /*\n" 8294 " * Comment\n" 8295 " */\n" 8296 " int i;\n" 8297 "}", 8298 format("{\n" 8299 "\t/*\n" 8300 "\t * Comment\n" 8301 "\t */\n" 8302 "\t int i;\n" 8303 "}")); 8304 8305 Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation; 8306 Tab.TabWidth = 8; 8307 Tab.IndentWidth = 8; 8308 EXPECT_EQ("if (aaaaaaaa && // q\n" 8309 " bb) // w\n" 8310 "\t;", 8311 format("if (aaaaaaaa &&// q\n" 8312 "bb)// w\n" 8313 ";", 8314 Tab)); 8315 EXPECT_EQ("if (aaa && bbb) // w\n" 8316 "\t;", 8317 format("if(aaa&&bbb)// w\n" 8318 ";", 8319 Tab)); 8320 verifyFormat("class X {\n" 8321 "\tvoid f() {\n" 8322 "\t\tsomeFunction(parameter1,\n" 8323 "\t\t\t parameter2);\n" 8324 "\t}\n" 8325 "};", 8326 Tab); 8327 verifyFormat("#define A \\\n" 8328 "\tvoid f() { \\\n" 8329 "\t\tsomeFunction( \\\n" 8330 "\t\t parameter1, \\\n" 8331 "\t\t parameter2); \\\n" 8332 "\t}", 8333 Tab); 8334 Tab.TabWidth = 4; 8335 Tab.IndentWidth = 8; 8336 verifyFormat("class TabWidth4Indent8 {\n" 8337 "\t\tvoid f() {\n" 8338 "\t\t\t\tsomeFunction(parameter1,\n" 8339 "\t\t\t\t\t\t\t parameter2);\n" 8340 "\t\t}\n" 8341 "};", 8342 Tab); 8343 Tab.TabWidth = 4; 8344 Tab.IndentWidth = 4; 8345 verifyFormat("class TabWidth4Indent4 {\n" 8346 "\tvoid f() {\n" 8347 "\t\tsomeFunction(parameter1,\n" 8348 "\t\t\t\t\t parameter2);\n" 8349 "\t}\n" 8350 "};", 8351 Tab); 8352 Tab.TabWidth = 8; 8353 Tab.IndentWidth = 4; 8354 verifyFormat("class TabWidth8Indent4 {\n" 8355 " void f() {\n" 8356 "\tsomeFunction(parameter1,\n" 8357 "\t\t parameter2);\n" 8358 " }\n" 8359 "};", 8360 Tab); 8361 Tab.TabWidth = 8; 8362 Tab.IndentWidth = 8; 8363 EXPECT_EQ("/*\n" 8364 "\t a\t\tcomment\n" 8365 "\t in multiple lines\n" 8366 " */", 8367 format(" /*\t \t \n" 8368 " \t \t a\t\tcomment\t \t\n" 8369 " \t \t in multiple lines\t\n" 8370 " \t */", 8371 Tab)); 8372 verifyFormat("{\n" 8373 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 8374 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 8375 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 8376 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 8377 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 8378 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 8379 "};", 8380 Tab); 8381 verifyFormat("enum AA {\n" 8382 "\ta1, // Force multiple lines\n" 8383 "\ta2,\n" 8384 "\ta3\n" 8385 "};", 8386 Tab); 8387 EXPECT_EQ("if (aaaaaaaa && // q\n" 8388 " bb) // w\n" 8389 "\t;", 8390 format("if (aaaaaaaa &&// q\n" 8391 "bb)// w\n" 8392 ";", 8393 Tab)); 8394 verifyFormat("class X {\n" 8395 "\tvoid f() {\n" 8396 "\t\tsomeFunction(parameter1,\n" 8397 "\t\t\t parameter2);\n" 8398 "\t}\n" 8399 "};", 8400 Tab); 8401 verifyFormat("{\n" 8402 "\tQ(\n" 8403 "\t {\n" 8404 "\t\t int a;\n" 8405 "\t\t someFunction(aaaaaaaa,\n" 8406 "\t\t\t\t bbbbbbb);\n" 8407 "\t },\n" 8408 "\t p);\n" 8409 "}", 8410 Tab); 8411 EXPECT_EQ("{\n" 8412 "\t/* aaaa\n" 8413 "\t bbbb */\n" 8414 "}", 8415 format("{\n" 8416 "/* aaaa\n" 8417 " bbbb */\n" 8418 "}", 8419 Tab)); 8420 EXPECT_EQ("{\n" 8421 "\t/*\n" 8422 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 8423 "\t bbbbbbbbbbbbb\n" 8424 "\t*/\n" 8425 "}", 8426 format("{\n" 8427 "/*\n" 8428 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 8429 "*/\n" 8430 "}", 8431 Tab)); 8432 EXPECT_EQ("{\n" 8433 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 8434 "\t// bbbbbbbbbbbbb\n" 8435 "}", 8436 format("{\n" 8437 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 8438 "}", 8439 Tab)); 8440 EXPECT_EQ("{\n" 8441 "\t/*\n" 8442 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 8443 "\t bbbbbbbbbbbbb\n" 8444 "\t*/\n" 8445 "}", 8446 format("{\n" 8447 "\t/*\n" 8448 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 8449 "\t*/\n" 8450 "}", 8451 Tab)); 8452 EXPECT_EQ("{\n" 8453 "\t/*\n" 8454 "\n" 8455 "\t*/\n" 8456 "}", 8457 format("{\n" 8458 "\t/*\n" 8459 "\n" 8460 "\t*/\n" 8461 "}", 8462 Tab)); 8463 EXPECT_EQ("{\n" 8464 "\t/*\n" 8465 " asdf\n" 8466 "\t*/\n" 8467 "}", 8468 format("{\n" 8469 "\t/*\n" 8470 " asdf\n" 8471 "\t*/\n" 8472 "}", 8473 Tab)); 8474 EXPECT_EQ("/*\n" 8475 "\t a\t\tcomment\n" 8476 "\t in multiple lines\n" 8477 " */", 8478 format(" /*\t \t \n" 8479 " \t \t a\t\tcomment\t \t\n" 8480 " \t \t in multiple lines\t\n" 8481 " \t */", 8482 Tab)); 8483 EXPECT_EQ("/* some\n" 8484 " comment */", 8485 format(" \t \t /* some\n" 8486 " \t \t comment */", 8487 Tab)); 8488 EXPECT_EQ("int a; /* some\n" 8489 " comment */", 8490 format(" \t \t int a; /* some\n" 8491 " \t \t comment */", 8492 Tab)); 8493 EXPECT_EQ("int a; /* some\n" 8494 "comment */", 8495 format(" \t \t int\ta; /* some\n" 8496 " \t \t comment */", 8497 Tab)); 8498 EXPECT_EQ("f(\"\t\t\"); /* some\n" 8499 " comment */", 8500 format(" \t \t f(\"\t\t\"); /* some\n" 8501 " \t \t comment */", 8502 Tab)); 8503 EXPECT_EQ("{\n" 8504 " /*\n" 8505 " * Comment\n" 8506 " */\n" 8507 " int i;\n" 8508 "}", 8509 format("{\n" 8510 "\t/*\n" 8511 "\t * Comment\n" 8512 "\t */\n" 8513 "\t int i;\n" 8514 "}")); 8515 Tab.AlignConsecutiveAssignments = true; 8516 Tab.AlignConsecutiveDeclarations = true; 8517 Tab.TabWidth = 4; 8518 Tab.IndentWidth = 4; 8519 verifyFormat("class Assign {\n" 8520 "\tvoid f() {\n" 8521 "\t\tint x = 123;\n" 8522 "\t\tint random = 4;\n" 8523 "\t\tstd::string alphabet =\n" 8524 "\t\t\t\"abcdefghijklmnopqrstuvwxyz\";\n" 8525 "\t}\n" 8526 "};", 8527 Tab); 8528 } 8529 8530 TEST_F(FormatTest, CalculatesOriginalColumn) { 8531 EXPECT_EQ("\"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 8532 "q\"; /* some\n" 8533 " comment */", 8534 format(" \"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 8535 "q\"; /* some\n" 8536 " comment */", 8537 getLLVMStyle())); 8538 EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n" 8539 "/* some\n" 8540 " comment */", 8541 format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n" 8542 " /* some\n" 8543 " comment */", 8544 getLLVMStyle())); 8545 EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 8546 "qqq\n" 8547 "/* some\n" 8548 " comment */", 8549 format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 8550 "qqq\n" 8551 " /* some\n" 8552 " comment */", 8553 getLLVMStyle())); 8554 EXPECT_EQ("inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 8555 "wwww; /* some\n" 8556 " comment */", 8557 format(" inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 8558 "wwww; /* some\n" 8559 " comment */", 8560 getLLVMStyle())); 8561 } 8562 8563 TEST_F(FormatTest, ConfigurableSpaceBeforeParens) { 8564 FormatStyle NoSpace = getLLVMStyle(); 8565 NoSpace.SpaceBeforeParens = FormatStyle::SBPO_Never; 8566 8567 verifyFormat("while(true)\n" 8568 " continue;", 8569 NoSpace); 8570 verifyFormat("for(;;)\n" 8571 " continue;", 8572 NoSpace); 8573 verifyFormat("if(true)\n" 8574 " f();\n" 8575 "else if(true)\n" 8576 " f();", 8577 NoSpace); 8578 verifyFormat("do {\n" 8579 " do_something();\n" 8580 "} while(something());", 8581 NoSpace); 8582 verifyFormat("switch(x) {\n" 8583 "default:\n" 8584 " break;\n" 8585 "}", 8586 NoSpace); 8587 verifyFormat("auto i = std::make_unique<int>(5);", NoSpace); 8588 verifyFormat("size_t x = sizeof(x);", NoSpace); 8589 verifyFormat("auto f(int x) -> decltype(x);", NoSpace); 8590 verifyFormat("int f(T x) noexcept(x.create());", NoSpace); 8591 verifyFormat("alignas(128) char a[128];", NoSpace); 8592 verifyFormat("size_t x = alignof(MyType);", NoSpace); 8593 verifyFormat("static_assert(sizeof(char) == 1, \"Impossible!\");", NoSpace); 8594 verifyFormat("int f() throw(Deprecated);", NoSpace); 8595 verifyFormat("typedef void (*cb)(int);", NoSpace); 8596 verifyFormat("T A::operator()();", NoSpace); 8597 verifyFormat("X A::operator++(T);", NoSpace); 8598 8599 FormatStyle Space = getLLVMStyle(); 8600 Space.SpaceBeforeParens = FormatStyle::SBPO_Always; 8601 8602 verifyFormat("int f ();", Space); 8603 verifyFormat("void f (int a, T b) {\n" 8604 " while (true)\n" 8605 " continue;\n" 8606 "}", 8607 Space); 8608 verifyFormat("if (true)\n" 8609 " f ();\n" 8610 "else if (true)\n" 8611 " f ();", 8612 Space); 8613 verifyFormat("do {\n" 8614 " do_something ();\n" 8615 "} while (something ());", 8616 Space); 8617 verifyFormat("switch (x) {\n" 8618 "default:\n" 8619 " break;\n" 8620 "}", 8621 Space); 8622 verifyFormat("A::A () : a (1) {}", Space); 8623 verifyFormat("void f () __attribute__ ((asdf));", Space); 8624 verifyFormat("*(&a + 1);\n" 8625 "&((&a)[1]);\n" 8626 "a[(b + c) * d];\n" 8627 "(((a + 1) * 2) + 3) * 4;", 8628 Space); 8629 verifyFormat("#define A(x) x", Space); 8630 verifyFormat("#define A (x) x", Space); 8631 verifyFormat("#if defined(x)\n" 8632 "#endif", 8633 Space); 8634 verifyFormat("auto i = std::make_unique<int> (5);", Space); 8635 verifyFormat("size_t x = sizeof (x);", Space); 8636 verifyFormat("auto f (int x) -> decltype (x);", Space); 8637 verifyFormat("int f (T x) noexcept (x.create ());", Space); 8638 verifyFormat("alignas (128) char a[128];", Space); 8639 verifyFormat("size_t x = alignof (MyType);", Space); 8640 verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");", Space); 8641 verifyFormat("int f () throw (Deprecated);", Space); 8642 verifyFormat("typedef void (*cb) (int);", Space); 8643 verifyFormat("T A::operator() ();", Space); 8644 verifyFormat("X A::operator++ (T);", Space); 8645 } 8646 8647 TEST_F(FormatTest, ConfigurableSpacesInParentheses) { 8648 FormatStyle Spaces = getLLVMStyle(); 8649 8650 Spaces.SpacesInParentheses = true; 8651 verifyFormat("call( x, y, z );", Spaces); 8652 verifyFormat("call();", Spaces); 8653 verifyFormat("std::function<void( int, int )> callback;", Spaces); 8654 verifyFormat("void inFunction() { std::function<void( int, int )> fct; }", 8655 Spaces); 8656 verifyFormat("while ( (bool)1 )\n" 8657 " continue;", 8658 Spaces); 8659 verifyFormat("for ( ;; )\n" 8660 " continue;", 8661 Spaces); 8662 verifyFormat("if ( true )\n" 8663 " f();\n" 8664 "else if ( true )\n" 8665 " f();", 8666 Spaces); 8667 verifyFormat("do {\n" 8668 " do_something( (int)i );\n" 8669 "} while ( something() );", 8670 Spaces); 8671 verifyFormat("switch ( x ) {\n" 8672 "default:\n" 8673 " break;\n" 8674 "}", 8675 Spaces); 8676 8677 Spaces.SpacesInParentheses = false; 8678 Spaces.SpacesInCStyleCastParentheses = true; 8679 verifyFormat("Type *A = ( Type * )P;", Spaces); 8680 verifyFormat("Type *A = ( vector<Type *, int *> )P;", Spaces); 8681 verifyFormat("x = ( int32 )y;", Spaces); 8682 verifyFormat("int a = ( int )(2.0f);", Spaces); 8683 verifyFormat("#define AA(X) sizeof((( X * )NULL)->a)", Spaces); 8684 verifyFormat("my_int a = ( my_int )sizeof(int);", Spaces); 8685 verifyFormat("#define x (( int )-1)", Spaces); 8686 8687 // Run the first set of tests again with: 8688 Spaces.SpacesInParentheses = false; 8689 Spaces.SpaceInEmptyParentheses = true; 8690 Spaces.SpacesInCStyleCastParentheses = true; 8691 verifyFormat("call(x, y, z);", Spaces); 8692 verifyFormat("call( );", Spaces); 8693 verifyFormat("std::function<void(int, int)> callback;", Spaces); 8694 verifyFormat("while (( bool )1)\n" 8695 " continue;", 8696 Spaces); 8697 verifyFormat("for (;;)\n" 8698 " continue;", 8699 Spaces); 8700 verifyFormat("if (true)\n" 8701 " f( );\n" 8702 "else if (true)\n" 8703 " f( );", 8704 Spaces); 8705 verifyFormat("do {\n" 8706 " do_something(( int )i);\n" 8707 "} while (something( ));", 8708 Spaces); 8709 verifyFormat("switch (x) {\n" 8710 "default:\n" 8711 " break;\n" 8712 "}", 8713 Spaces); 8714 8715 // Run the first set of tests again with: 8716 Spaces.SpaceAfterCStyleCast = true; 8717 verifyFormat("call(x, y, z);", Spaces); 8718 verifyFormat("call( );", Spaces); 8719 verifyFormat("std::function<void(int, int)> callback;", Spaces); 8720 verifyFormat("while (( bool ) 1)\n" 8721 " continue;", 8722 Spaces); 8723 verifyFormat("for (;;)\n" 8724 " continue;", 8725 Spaces); 8726 verifyFormat("if (true)\n" 8727 " f( );\n" 8728 "else if (true)\n" 8729 " f( );", 8730 Spaces); 8731 verifyFormat("do {\n" 8732 " do_something(( int ) i);\n" 8733 "} while (something( ));", 8734 Spaces); 8735 verifyFormat("switch (x) {\n" 8736 "default:\n" 8737 " break;\n" 8738 "}", 8739 Spaces); 8740 8741 // Run subset of tests again with: 8742 Spaces.SpacesInCStyleCastParentheses = false; 8743 Spaces.SpaceAfterCStyleCast = true; 8744 verifyFormat("while ((bool) 1)\n" 8745 " continue;", 8746 Spaces); 8747 verifyFormat("do {\n" 8748 " do_something((int) i);\n" 8749 "} while (something( ));", 8750 Spaces); 8751 } 8752 8753 TEST_F(FormatTest, ConfigurableSpacesInSquareBrackets) { 8754 verifyFormat("int a[5];"); 8755 verifyFormat("a[3] += 42;"); 8756 8757 FormatStyle Spaces = getLLVMStyle(); 8758 Spaces.SpacesInSquareBrackets = true; 8759 // Lambdas unchanged. 8760 verifyFormat("int c = []() -> int { return 2; }();\n", Spaces); 8761 verifyFormat("return [i, args...] {};", Spaces); 8762 8763 // Not lambdas. 8764 verifyFormat("int a[ 5 ];", Spaces); 8765 verifyFormat("a[ 3 ] += 42;", Spaces); 8766 verifyFormat("constexpr char hello[]{\"hello\"};", Spaces); 8767 verifyFormat("double &operator[](int i) { return 0; }\n" 8768 "int i;", 8769 Spaces); 8770 verifyFormat("std::unique_ptr<int[]> foo() {}", Spaces); 8771 verifyFormat("int i = a[ a ][ a ]->f();", Spaces); 8772 verifyFormat("int i = (*b)[ a ]->f();", Spaces); 8773 } 8774 8775 TEST_F(FormatTest, ConfigurableSpaceBeforeAssignmentOperators) { 8776 verifyFormat("int a = 5;"); 8777 verifyFormat("a += 42;"); 8778 verifyFormat("a or_eq 8;"); 8779 8780 FormatStyle Spaces = getLLVMStyle(); 8781 Spaces.SpaceBeforeAssignmentOperators = false; 8782 verifyFormat("int a= 5;", Spaces); 8783 verifyFormat("a+= 42;", Spaces); 8784 verifyFormat("a or_eq 8;", Spaces); 8785 } 8786 8787 TEST_F(FormatTest, AlignConsecutiveAssignments) { 8788 FormatStyle Alignment = getLLVMStyle(); 8789 Alignment.AlignConsecutiveAssignments = false; 8790 verifyFormat("int a = 5;\n" 8791 "int oneTwoThree = 123;", 8792 Alignment); 8793 verifyFormat("int a = 5;\n" 8794 "int oneTwoThree = 123;", 8795 Alignment); 8796 8797 Alignment.AlignConsecutiveAssignments = true; 8798 verifyFormat("int a = 5;\n" 8799 "int oneTwoThree = 123;", 8800 Alignment); 8801 verifyFormat("int a = method();\n" 8802 "int oneTwoThree = 133;", 8803 Alignment); 8804 verifyFormat("a &= 5;\n" 8805 "bcd *= 5;\n" 8806 "ghtyf += 5;\n" 8807 "dvfvdb -= 5;\n" 8808 "a /= 5;\n" 8809 "vdsvsv %= 5;\n" 8810 "sfdbddfbdfbb ^= 5;\n" 8811 "dvsdsv |= 5;\n" 8812 "int dsvvdvsdvvv = 123;", 8813 Alignment); 8814 verifyFormat("int i = 1, j = 10;\n" 8815 "something = 2000;", 8816 Alignment); 8817 verifyFormat("something = 2000;\n" 8818 "int i = 1, j = 10;\n", 8819 Alignment); 8820 verifyFormat("something = 2000;\n" 8821 "another = 911;\n" 8822 "int i = 1, j = 10;\n" 8823 "oneMore = 1;\n" 8824 "i = 2;", 8825 Alignment); 8826 verifyFormat("int a = 5;\n" 8827 "int one = 1;\n" 8828 "method();\n" 8829 "int oneTwoThree = 123;\n" 8830 "int oneTwo = 12;", 8831 Alignment); 8832 verifyFormat("int oneTwoThree = 123;\n" 8833 "int oneTwo = 12;\n" 8834 "method();\n", 8835 Alignment); 8836 verifyFormat("int oneTwoThree = 123; // comment\n" 8837 "int oneTwo = 12; // comment", 8838 Alignment); 8839 EXPECT_EQ("int a = 5;\n" 8840 "\n" 8841 "int oneTwoThree = 123;", 8842 format("int a = 5;\n" 8843 "\n" 8844 "int oneTwoThree= 123;", 8845 Alignment)); 8846 EXPECT_EQ("int a = 5;\n" 8847 "int one = 1;\n" 8848 "\n" 8849 "int oneTwoThree = 123;", 8850 format("int a = 5;\n" 8851 "int one = 1;\n" 8852 "\n" 8853 "int oneTwoThree = 123;", 8854 Alignment)); 8855 EXPECT_EQ("int a = 5;\n" 8856 "int one = 1;\n" 8857 "\n" 8858 "int oneTwoThree = 123;\n" 8859 "int oneTwo = 12;", 8860 format("int a = 5;\n" 8861 "int one = 1;\n" 8862 "\n" 8863 "int oneTwoThree = 123;\n" 8864 "int oneTwo = 12;", 8865 Alignment)); 8866 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign; 8867 verifyFormat("#define A \\\n" 8868 " int aaaa = 12; \\\n" 8869 " int b = 23; \\\n" 8870 " int ccc = 234; \\\n" 8871 " int dddddddddd = 2345;", 8872 Alignment); 8873 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left; 8874 verifyFormat("#define A \\\n" 8875 " int aaaa = 12; \\\n" 8876 " int b = 23; \\\n" 8877 " int ccc = 234; \\\n" 8878 " int dddddddddd = 2345;", 8879 Alignment); 8880 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right; 8881 verifyFormat("#define A " 8882 " \\\n" 8883 " int aaaa = 12; " 8884 " \\\n" 8885 " int b = 23; " 8886 " \\\n" 8887 " int ccc = 234; " 8888 " \\\n" 8889 " int dddddddddd = 2345;", 8890 Alignment); 8891 verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int " 8892 "k = 4, int l = 5,\n" 8893 " int m = 6) {\n" 8894 " int j = 10;\n" 8895 " otherThing = 1;\n" 8896 "}", 8897 Alignment); 8898 verifyFormat("void SomeFunction(int parameter = 0) {\n" 8899 " int i = 1;\n" 8900 " int j = 2;\n" 8901 " int big = 10000;\n" 8902 "}", 8903 Alignment); 8904 verifyFormat("class C {\n" 8905 "public:\n" 8906 " int i = 1;\n" 8907 " virtual void f() = 0;\n" 8908 "};", 8909 Alignment); 8910 verifyFormat("int i = 1;\n" 8911 "if (SomeType t = getSomething()) {\n" 8912 "}\n" 8913 "int j = 2;\n" 8914 "int big = 10000;", 8915 Alignment); 8916 verifyFormat("int j = 7;\n" 8917 "for (int k = 0; k < N; ++k) {\n" 8918 "}\n" 8919 "int j = 2;\n" 8920 "int big = 10000;\n" 8921 "}", 8922 Alignment); 8923 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 8924 verifyFormat("int i = 1;\n" 8925 "LooooooooooongType loooooooooooooooooooooongVariable\n" 8926 " = someLooooooooooooooooongFunction();\n" 8927 "int j = 2;", 8928 Alignment); 8929 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 8930 verifyFormat("int i = 1;\n" 8931 "LooooooooooongType loooooooooooooooooooooongVariable =\n" 8932 " someLooooooooooooooooongFunction();\n" 8933 "int j = 2;", 8934 Alignment); 8935 8936 verifyFormat("auto lambda = []() {\n" 8937 " auto i = 0;\n" 8938 " return 0;\n" 8939 "};\n" 8940 "int i = 0;\n" 8941 "auto v = type{\n" 8942 " i = 1, //\n" 8943 " (i = 2), //\n" 8944 " i = 3 //\n" 8945 "};", 8946 Alignment); 8947 8948 verifyFormat( 8949 "int i = 1;\n" 8950 "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n" 8951 " loooooooooooooooooooooongParameterB);\n" 8952 "int j = 2;", 8953 Alignment); 8954 8955 verifyFormat("template <typename T, typename T_0 = very_long_type_name_0,\n" 8956 " typename B = very_long_type_name_1,\n" 8957 " typename T_2 = very_long_type_name_2>\n" 8958 "auto foo() {}\n", 8959 Alignment); 8960 verifyFormat("int a, b = 1;\n" 8961 "int c = 2;\n" 8962 "int dd = 3;\n", 8963 Alignment); 8964 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n" 8965 "float b[1][] = {{3.f}};\n", 8966 Alignment); 8967 verifyFormat("for (int i = 0; i < 1; i++)\n" 8968 " int x = 1;\n", 8969 Alignment); 8970 verifyFormat("for (i = 0; i < 1; i++)\n" 8971 " x = 1;\n" 8972 "y = 1;\n", 8973 Alignment); 8974 } 8975 8976 TEST_F(FormatTest, AlignConsecutiveDeclarations) { 8977 FormatStyle Alignment = getLLVMStyle(); 8978 Alignment.AlignConsecutiveDeclarations = false; 8979 verifyFormat("float const a = 5;\n" 8980 "int oneTwoThree = 123;", 8981 Alignment); 8982 verifyFormat("int a = 5;\n" 8983 "float const oneTwoThree = 123;", 8984 Alignment); 8985 8986 Alignment.AlignConsecutiveDeclarations = true; 8987 verifyFormat("float const a = 5;\n" 8988 "int oneTwoThree = 123;", 8989 Alignment); 8990 verifyFormat("int a = method();\n" 8991 "float const oneTwoThree = 133;", 8992 Alignment); 8993 verifyFormat("int i = 1, j = 10;\n" 8994 "something = 2000;", 8995 Alignment); 8996 verifyFormat("something = 2000;\n" 8997 "int i = 1, j = 10;\n", 8998 Alignment); 8999 verifyFormat("float something = 2000;\n" 9000 "double another = 911;\n" 9001 "int i = 1, j = 10;\n" 9002 "const int *oneMore = 1;\n" 9003 "unsigned i = 2;", 9004 Alignment); 9005 verifyFormat("float a = 5;\n" 9006 "int one = 1;\n" 9007 "method();\n" 9008 "const double oneTwoThree = 123;\n" 9009 "const unsigned int oneTwo = 12;", 9010 Alignment); 9011 verifyFormat("int oneTwoThree{0}; // comment\n" 9012 "unsigned oneTwo; // comment", 9013 Alignment); 9014 EXPECT_EQ("float const a = 5;\n" 9015 "\n" 9016 "int oneTwoThree = 123;", 9017 format("float const a = 5;\n" 9018 "\n" 9019 "int oneTwoThree= 123;", 9020 Alignment)); 9021 EXPECT_EQ("float a = 5;\n" 9022 "int one = 1;\n" 9023 "\n" 9024 "unsigned oneTwoThree = 123;", 9025 format("float a = 5;\n" 9026 "int one = 1;\n" 9027 "\n" 9028 "unsigned oneTwoThree = 123;", 9029 Alignment)); 9030 EXPECT_EQ("float a = 5;\n" 9031 "int one = 1;\n" 9032 "\n" 9033 "unsigned oneTwoThree = 123;\n" 9034 "int oneTwo = 12;", 9035 format("float a = 5;\n" 9036 "int one = 1;\n" 9037 "\n" 9038 "unsigned oneTwoThree = 123;\n" 9039 "int oneTwo = 12;", 9040 Alignment)); 9041 // Function prototype alignment 9042 verifyFormat("int a();\n" 9043 "double b();", 9044 Alignment); 9045 verifyFormat("int a(int x);\n" 9046 "double b();", 9047 Alignment); 9048 unsigned OldColumnLimit = Alignment.ColumnLimit; 9049 // We need to set ColumnLimit to zero, in order to stress nested alignments, 9050 // otherwise the function parameters will be re-flowed onto a single line. 9051 Alignment.ColumnLimit = 0; 9052 EXPECT_EQ("int a(int x,\n" 9053 " float y);\n" 9054 "double b(int x,\n" 9055 " double y);", 9056 format("int a(int x,\n" 9057 " float y);\n" 9058 "double b(int x,\n" 9059 " double y);", 9060 Alignment)); 9061 // This ensures that function parameters of function declarations are 9062 // correctly indented when their owning functions are indented. 9063 // The failure case here is for 'double y' to not be indented enough. 9064 EXPECT_EQ("double a(int x);\n" 9065 "int b(int y,\n" 9066 " double z);", 9067 format("double a(int x);\n" 9068 "int b(int y,\n" 9069 " double z);", 9070 Alignment)); 9071 // Set ColumnLimit low so that we induce wrapping immediately after 9072 // the function name and opening paren. 9073 Alignment.ColumnLimit = 13; 9074 verifyFormat("int function(\n" 9075 " int x,\n" 9076 " bool y);", 9077 Alignment); 9078 Alignment.ColumnLimit = OldColumnLimit; 9079 // Ensure function pointers don't screw up recursive alignment 9080 verifyFormat("int a(int x, void (*fp)(int y));\n" 9081 "double b();", 9082 Alignment); 9083 Alignment.AlignConsecutiveAssignments = true; 9084 // Ensure recursive alignment is broken by function braces, so that the 9085 // "a = 1" does not align with subsequent assignments inside the function 9086 // body. 9087 verifyFormat("int func(int a = 1) {\n" 9088 " int b = 2;\n" 9089 " int cc = 3;\n" 9090 "}", 9091 Alignment); 9092 verifyFormat("float something = 2000;\n" 9093 "double another = 911;\n" 9094 "int i = 1, j = 10;\n" 9095 "const int *oneMore = 1;\n" 9096 "unsigned i = 2;", 9097 Alignment); 9098 verifyFormat("int oneTwoThree = {0}; // comment\n" 9099 "unsigned oneTwo = 0; // comment", 9100 Alignment); 9101 // Make sure that scope is correctly tracked, in the absence of braces 9102 verifyFormat("for (int i = 0; i < n; i++)\n" 9103 " j = i;\n" 9104 "double x = 1;\n", 9105 Alignment); 9106 verifyFormat("if (int i = 0)\n" 9107 " j = i;\n" 9108 "double x = 1;\n", 9109 Alignment); 9110 // Ensure operator[] and operator() are comprehended 9111 verifyFormat("struct test {\n" 9112 " long long int foo();\n" 9113 " int operator[](int a);\n" 9114 " double bar();\n" 9115 "};\n", 9116 Alignment); 9117 verifyFormat("struct test {\n" 9118 " long long int foo();\n" 9119 " int operator()(int a);\n" 9120 " double bar();\n" 9121 "};\n", 9122 Alignment); 9123 EXPECT_EQ("void SomeFunction(int parameter = 0) {\n" 9124 " int const i = 1;\n" 9125 " int * j = 2;\n" 9126 " int big = 10000;\n" 9127 "\n" 9128 " unsigned oneTwoThree = 123;\n" 9129 " int oneTwo = 12;\n" 9130 " method();\n" 9131 " float k = 2;\n" 9132 " int ll = 10000;\n" 9133 "}", 9134 format("void SomeFunction(int parameter= 0) {\n" 9135 " int const i= 1;\n" 9136 " int *j=2;\n" 9137 " int big = 10000;\n" 9138 "\n" 9139 "unsigned oneTwoThree =123;\n" 9140 "int oneTwo = 12;\n" 9141 " method();\n" 9142 "float k= 2;\n" 9143 "int ll=10000;\n" 9144 "}", 9145 Alignment)); 9146 Alignment.AlignConsecutiveAssignments = false; 9147 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign; 9148 verifyFormat("#define A \\\n" 9149 " int aaaa = 12; \\\n" 9150 " float b = 23; \\\n" 9151 " const int ccc = 234; \\\n" 9152 " unsigned dddddddddd = 2345;", 9153 Alignment); 9154 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left; 9155 verifyFormat("#define A \\\n" 9156 " int aaaa = 12; \\\n" 9157 " float b = 23; \\\n" 9158 " const int ccc = 234; \\\n" 9159 " unsigned dddddddddd = 2345;", 9160 Alignment); 9161 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right; 9162 Alignment.ColumnLimit = 30; 9163 verifyFormat("#define A \\\n" 9164 " int aaaa = 12; \\\n" 9165 " float b = 23; \\\n" 9166 " const int ccc = 234; \\\n" 9167 " int dddddddddd = 2345;", 9168 Alignment); 9169 Alignment.ColumnLimit = 80; 9170 verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int " 9171 "k = 4, int l = 5,\n" 9172 " int m = 6) {\n" 9173 " const int j = 10;\n" 9174 " otherThing = 1;\n" 9175 "}", 9176 Alignment); 9177 verifyFormat("void SomeFunction(int parameter = 0) {\n" 9178 " int const i = 1;\n" 9179 " int * j = 2;\n" 9180 " int big = 10000;\n" 9181 "}", 9182 Alignment); 9183 verifyFormat("class C {\n" 9184 "public:\n" 9185 " int i = 1;\n" 9186 " virtual void f() = 0;\n" 9187 "};", 9188 Alignment); 9189 verifyFormat("float i = 1;\n" 9190 "if (SomeType t = getSomething()) {\n" 9191 "}\n" 9192 "const unsigned j = 2;\n" 9193 "int big = 10000;", 9194 Alignment); 9195 verifyFormat("float j = 7;\n" 9196 "for (int k = 0; k < N; ++k) {\n" 9197 "}\n" 9198 "unsigned j = 2;\n" 9199 "int big = 10000;\n" 9200 "}", 9201 Alignment); 9202 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 9203 verifyFormat("float i = 1;\n" 9204 "LooooooooooongType loooooooooooooooooooooongVariable\n" 9205 " = someLooooooooooooooooongFunction();\n" 9206 "int j = 2;", 9207 Alignment); 9208 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 9209 verifyFormat("int i = 1;\n" 9210 "LooooooooooongType loooooooooooooooooooooongVariable =\n" 9211 " someLooooooooooooooooongFunction();\n" 9212 "int j = 2;", 9213 Alignment); 9214 9215 Alignment.AlignConsecutiveAssignments = true; 9216 verifyFormat("auto lambda = []() {\n" 9217 " auto ii = 0;\n" 9218 " float j = 0;\n" 9219 " return 0;\n" 9220 "};\n" 9221 "int i = 0;\n" 9222 "float i2 = 0;\n" 9223 "auto v = type{\n" 9224 " i = 1, //\n" 9225 " (i = 2), //\n" 9226 " i = 3 //\n" 9227 "};", 9228 Alignment); 9229 Alignment.AlignConsecutiveAssignments = false; 9230 9231 verifyFormat( 9232 "int i = 1;\n" 9233 "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n" 9234 " loooooooooooooooooooooongParameterB);\n" 9235 "int j = 2;", 9236 Alignment); 9237 9238 // Test interactions with ColumnLimit and AlignConsecutiveAssignments: 9239 // We expect declarations and assignments to align, as long as it doesn't 9240 // exceed the column limit, starting a new alignment sequence whenever it 9241 // happens. 9242 Alignment.AlignConsecutiveAssignments = true; 9243 Alignment.ColumnLimit = 30; 9244 verifyFormat("float ii = 1;\n" 9245 "unsigned j = 2;\n" 9246 "int someVerylongVariable = 1;\n" 9247 "AnotherLongType ll = 123456;\n" 9248 "VeryVeryLongType k = 2;\n" 9249 "int myvar = 1;", 9250 Alignment); 9251 Alignment.ColumnLimit = 80; 9252 Alignment.AlignConsecutiveAssignments = false; 9253 9254 verifyFormat( 9255 "template <typename LongTemplate, typename VeryLongTemplateTypeName,\n" 9256 " typename LongType, typename B>\n" 9257 "auto foo() {}\n", 9258 Alignment); 9259 verifyFormat("float a, b = 1;\n" 9260 "int c = 2;\n" 9261 "int dd = 3;\n", 9262 Alignment); 9263 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n" 9264 "float b[1][] = {{3.f}};\n", 9265 Alignment); 9266 Alignment.AlignConsecutiveAssignments = true; 9267 verifyFormat("float a, b = 1;\n" 9268 "int c = 2;\n" 9269 "int dd = 3;\n", 9270 Alignment); 9271 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n" 9272 "float b[1][] = {{3.f}};\n", 9273 Alignment); 9274 Alignment.AlignConsecutiveAssignments = false; 9275 9276 Alignment.ColumnLimit = 30; 9277 Alignment.BinPackParameters = false; 9278 verifyFormat("void foo(float a,\n" 9279 " float b,\n" 9280 " int c,\n" 9281 " uint32_t *d) {\n" 9282 " int * e = 0;\n" 9283 " float f = 0;\n" 9284 " double g = 0;\n" 9285 "}\n" 9286 "void bar(ino_t a,\n" 9287 " int b,\n" 9288 " uint32_t *c,\n" 9289 " bool d) {}\n", 9290 Alignment); 9291 Alignment.BinPackParameters = true; 9292 Alignment.ColumnLimit = 80; 9293 9294 // Bug 33507 9295 Alignment.PointerAlignment = FormatStyle::PAS_Middle; 9296 verifyFormat( 9297 "auto found = range::find_if(vsProducts, [&](auto * aProduct) {\n" 9298 " static const Version verVs2017;\n" 9299 " return true;\n" 9300 "});\n", 9301 Alignment); 9302 Alignment.PointerAlignment = FormatStyle::PAS_Right; 9303 } 9304 9305 TEST_F(FormatTest, LinuxBraceBreaking) { 9306 FormatStyle LinuxBraceStyle = getLLVMStyle(); 9307 LinuxBraceStyle.BreakBeforeBraces = FormatStyle::BS_Linux; 9308 verifyFormat("namespace a\n" 9309 "{\n" 9310 "class A\n" 9311 "{\n" 9312 " void f()\n" 9313 " {\n" 9314 " if (true) {\n" 9315 " a();\n" 9316 " b();\n" 9317 " } else {\n" 9318 " a();\n" 9319 " }\n" 9320 " }\n" 9321 " void g() { return; }\n" 9322 "};\n" 9323 "struct B {\n" 9324 " int x;\n" 9325 "};\n" 9326 "}\n", 9327 LinuxBraceStyle); 9328 verifyFormat("enum X {\n" 9329 " Y = 0,\n" 9330 "}\n", 9331 LinuxBraceStyle); 9332 verifyFormat("struct S {\n" 9333 " int Type;\n" 9334 " union {\n" 9335 " int x;\n" 9336 " double y;\n" 9337 " } Value;\n" 9338 " class C\n" 9339 " {\n" 9340 " MyFavoriteType Value;\n" 9341 " } Class;\n" 9342 "}\n", 9343 LinuxBraceStyle); 9344 } 9345 9346 TEST_F(FormatTest, MozillaBraceBreaking) { 9347 FormatStyle MozillaBraceStyle = getLLVMStyle(); 9348 MozillaBraceStyle.BreakBeforeBraces = FormatStyle::BS_Mozilla; 9349 MozillaBraceStyle.FixNamespaceComments = false; 9350 verifyFormat("namespace a {\n" 9351 "class A\n" 9352 "{\n" 9353 " void f()\n" 9354 " {\n" 9355 " if (true) {\n" 9356 " a();\n" 9357 " b();\n" 9358 " }\n" 9359 " }\n" 9360 " void g() { return; }\n" 9361 "};\n" 9362 "enum E\n" 9363 "{\n" 9364 " A,\n" 9365 " // foo\n" 9366 " B,\n" 9367 " C\n" 9368 "};\n" 9369 "struct B\n" 9370 "{\n" 9371 " int x;\n" 9372 "};\n" 9373 "}\n", 9374 MozillaBraceStyle); 9375 verifyFormat("struct S\n" 9376 "{\n" 9377 " int Type;\n" 9378 " union\n" 9379 " {\n" 9380 " int x;\n" 9381 " double y;\n" 9382 " } Value;\n" 9383 " class C\n" 9384 " {\n" 9385 " MyFavoriteType Value;\n" 9386 " } Class;\n" 9387 "}\n", 9388 MozillaBraceStyle); 9389 } 9390 9391 TEST_F(FormatTest, StroustrupBraceBreaking) { 9392 FormatStyle StroustrupBraceStyle = getLLVMStyle(); 9393 StroustrupBraceStyle.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 9394 verifyFormat("namespace a {\n" 9395 "class A {\n" 9396 " void f()\n" 9397 " {\n" 9398 " if (true) {\n" 9399 " a();\n" 9400 " b();\n" 9401 " }\n" 9402 " }\n" 9403 " void g() { return; }\n" 9404 "};\n" 9405 "struct B {\n" 9406 " int x;\n" 9407 "};\n" 9408 "} // namespace a\n", 9409 StroustrupBraceStyle); 9410 9411 verifyFormat("void foo()\n" 9412 "{\n" 9413 " if (a) {\n" 9414 " a();\n" 9415 " }\n" 9416 " else {\n" 9417 " b();\n" 9418 " }\n" 9419 "}\n", 9420 StroustrupBraceStyle); 9421 9422 verifyFormat("#ifdef _DEBUG\n" 9423 "int foo(int i = 0)\n" 9424 "#else\n" 9425 "int foo(int i = 5)\n" 9426 "#endif\n" 9427 "{\n" 9428 " return i;\n" 9429 "}", 9430 StroustrupBraceStyle); 9431 9432 verifyFormat("void foo() {}\n" 9433 "void bar()\n" 9434 "#ifdef _DEBUG\n" 9435 "{\n" 9436 " foo();\n" 9437 "}\n" 9438 "#else\n" 9439 "{\n" 9440 "}\n" 9441 "#endif", 9442 StroustrupBraceStyle); 9443 9444 verifyFormat("void foobar() { int i = 5; }\n" 9445 "#ifdef _DEBUG\n" 9446 "void bar() {}\n" 9447 "#else\n" 9448 "void bar() { foobar(); }\n" 9449 "#endif", 9450 StroustrupBraceStyle); 9451 } 9452 9453 TEST_F(FormatTest, AllmanBraceBreaking) { 9454 FormatStyle AllmanBraceStyle = getLLVMStyle(); 9455 AllmanBraceStyle.BreakBeforeBraces = FormatStyle::BS_Allman; 9456 verifyFormat("namespace a\n" 9457 "{\n" 9458 "class A\n" 9459 "{\n" 9460 " void f()\n" 9461 " {\n" 9462 " if (true)\n" 9463 " {\n" 9464 " a();\n" 9465 " b();\n" 9466 " }\n" 9467 " }\n" 9468 " void g() { return; }\n" 9469 "};\n" 9470 "struct B\n" 9471 "{\n" 9472 " int x;\n" 9473 "};\n" 9474 "}", 9475 AllmanBraceStyle); 9476 9477 verifyFormat("void f()\n" 9478 "{\n" 9479 " if (true)\n" 9480 " {\n" 9481 " a();\n" 9482 " }\n" 9483 " else if (false)\n" 9484 " {\n" 9485 " b();\n" 9486 " }\n" 9487 " else\n" 9488 " {\n" 9489 " c();\n" 9490 " }\n" 9491 "}\n", 9492 AllmanBraceStyle); 9493 9494 verifyFormat("void f()\n" 9495 "{\n" 9496 " for (int i = 0; i < 10; ++i)\n" 9497 " {\n" 9498 " a();\n" 9499 " }\n" 9500 " while (false)\n" 9501 " {\n" 9502 " b();\n" 9503 " }\n" 9504 " do\n" 9505 " {\n" 9506 " c();\n" 9507 " } while (false)\n" 9508 "}\n", 9509 AllmanBraceStyle); 9510 9511 verifyFormat("void f(int a)\n" 9512 "{\n" 9513 " switch (a)\n" 9514 " {\n" 9515 " case 0:\n" 9516 " break;\n" 9517 " case 1:\n" 9518 " {\n" 9519 " break;\n" 9520 " }\n" 9521 " case 2:\n" 9522 " {\n" 9523 " }\n" 9524 " break;\n" 9525 " default:\n" 9526 " break;\n" 9527 " }\n" 9528 "}\n", 9529 AllmanBraceStyle); 9530 9531 verifyFormat("enum X\n" 9532 "{\n" 9533 " Y = 0,\n" 9534 "}\n", 9535 AllmanBraceStyle); 9536 verifyFormat("enum X\n" 9537 "{\n" 9538 " Y = 0\n" 9539 "}\n", 9540 AllmanBraceStyle); 9541 9542 verifyFormat("@interface BSApplicationController ()\n" 9543 "{\n" 9544 "@private\n" 9545 " id _extraIvar;\n" 9546 "}\n" 9547 "@end\n", 9548 AllmanBraceStyle); 9549 9550 verifyFormat("#ifdef _DEBUG\n" 9551 "int foo(int i = 0)\n" 9552 "#else\n" 9553 "int foo(int i = 5)\n" 9554 "#endif\n" 9555 "{\n" 9556 " return i;\n" 9557 "}", 9558 AllmanBraceStyle); 9559 9560 verifyFormat("void foo() {}\n" 9561 "void bar()\n" 9562 "#ifdef _DEBUG\n" 9563 "{\n" 9564 " foo();\n" 9565 "}\n" 9566 "#else\n" 9567 "{\n" 9568 "}\n" 9569 "#endif", 9570 AllmanBraceStyle); 9571 9572 verifyFormat("void foobar() { int i = 5; }\n" 9573 "#ifdef _DEBUG\n" 9574 "void bar() {}\n" 9575 "#else\n" 9576 "void bar() { foobar(); }\n" 9577 "#endif", 9578 AllmanBraceStyle); 9579 9580 // This shouldn't affect ObjC blocks.. 9581 verifyFormat("[self doSomeThingWithACompletionHandler:^{\n" 9582 " // ...\n" 9583 " int i;\n" 9584 "}];", 9585 AllmanBraceStyle); 9586 verifyFormat("void (^block)(void) = ^{\n" 9587 " // ...\n" 9588 " int i;\n" 9589 "};", 9590 AllmanBraceStyle); 9591 // .. or dict literals. 9592 verifyFormat("void f()\n" 9593 "{\n" 9594 " // ...\n" 9595 " [object someMethod:@{@\"a\" : @\"b\"}];\n" 9596 "}", 9597 AllmanBraceStyle); 9598 verifyFormat("void f()\n" 9599 "{\n" 9600 " // ...\n" 9601 " [object someMethod:@{a : @\"b\"}];\n" 9602 "}", 9603 AllmanBraceStyle); 9604 verifyFormat("int f()\n" 9605 "{ // comment\n" 9606 " return 42;\n" 9607 "}", 9608 AllmanBraceStyle); 9609 9610 AllmanBraceStyle.ColumnLimit = 19; 9611 verifyFormat("void f() { int i; }", AllmanBraceStyle); 9612 AllmanBraceStyle.ColumnLimit = 18; 9613 verifyFormat("void f()\n" 9614 "{\n" 9615 " int i;\n" 9616 "}", 9617 AllmanBraceStyle); 9618 AllmanBraceStyle.ColumnLimit = 80; 9619 9620 FormatStyle BreakBeforeBraceShortIfs = AllmanBraceStyle; 9621 BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine = true; 9622 BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true; 9623 verifyFormat("void f(bool b)\n" 9624 "{\n" 9625 " if (b)\n" 9626 " {\n" 9627 " return;\n" 9628 " }\n" 9629 "}\n", 9630 BreakBeforeBraceShortIfs); 9631 verifyFormat("void f(bool b)\n" 9632 "{\n" 9633 " if constexpr (b)\n" 9634 " {\n" 9635 " return;\n" 9636 " }\n" 9637 "}\n", 9638 BreakBeforeBraceShortIfs); 9639 verifyFormat("void f(bool b)\n" 9640 "{\n" 9641 " if (b) return;\n" 9642 "}\n", 9643 BreakBeforeBraceShortIfs); 9644 verifyFormat("void f(bool b)\n" 9645 "{\n" 9646 " if constexpr (b) return;\n" 9647 "}\n", 9648 BreakBeforeBraceShortIfs); 9649 verifyFormat("void f(bool b)\n" 9650 "{\n" 9651 " while (b)\n" 9652 " {\n" 9653 " return;\n" 9654 " }\n" 9655 "}\n", 9656 BreakBeforeBraceShortIfs); 9657 } 9658 9659 TEST_F(FormatTest, GNUBraceBreaking) { 9660 FormatStyle GNUBraceStyle = getLLVMStyle(); 9661 GNUBraceStyle.BreakBeforeBraces = FormatStyle::BS_GNU; 9662 verifyFormat("namespace a\n" 9663 "{\n" 9664 "class A\n" 9665 "{\n" 9666 " void f()\n" 9667 " {\n" 9668 " int a;\n" 9669 " {\n" 9670 " int b;\n" 9671 " }\n" 9672 " if (true)\n" 9673 " {\n" 9674 " a();\n" 9675 " b();\n" 9676 " }\n" 9677 " }\n" 9678 " void g() { return; }\n" 9679 "}\n" 9680 "}", 9681 GNUBraceStyle); 9682 9683 verifyFormat("void f()\n" 9684 "{\n" 9685 " if (true)\n" 9686 " {\n" 9687 " a();\n" 9688 " }\n" 9689 " else if (false)\n" 9690 " {\n" 9691 " b();\n" 9692 " }\n" 9693 " else\n" 9694 " {\n" 9695 " c();\n" 9696 " }\n" 9697 "}\n", 9698 GNUBraceStyle); 9699 9700 verifyFormat("void f()\n" 9701 "{\n" 9702 " for (int i = 0; i < 10; ++i)\n" 9703 " {\n" 9704 " a();\n" 9705 " }\n" 9706 " while (false)\n" 9707 " {\n" 9708 " b();\n" 9709 " }\n" 9710 " do\n" 9711 " {\n" 9712 " c();\n" 9713 " }\n" 9714 " while (false);\n" 9715 "}\n", 9716 GNUBraceStyle); 9717 9718 verifyFormat("void f(int a)\n" 9719 "{\n" 9720 " switch (a)\n" 9721 " {\n" 9722 " case 0:\n" 9723 " break;\n" 9724 " case 1:\n" 9725 " {\n" 9726 " break;\n" 9727 " }\n" 9728 " case 2:\n" 9729 " {\n" 9730 " }\n" 9731 " break;\n" 9732 " default:\n" 9733 " break;\n" 9734 " }\n" 9735 "}\n", 9736 GNUBraceStyle); 9737 9738 verifyFormat("enum X\n" 9739 "{\n" 9740 " Y = 0,\n" 9741 "}\n", 9742 GNUBraceStyle); 9743 9744 verifyFormat("@interface BSApplicationController ()\n" 9745 "{\n" 9746 "@private\n" 9747 " id _extraIvar;\n" 9748 "}\n" 9749 "@end\n", 9750 GNUBraceStyle); 9751 9752 verifyFormat("#ifdef _DEBUG\n" 9753 "int foo(int i = 0)\n" 9754 "#else\n" 9755 "int foo(int i = 5)\n" 9756 "#endif\n" 9757 "{\n" 9758 " return i;\n" 9759 "}", 9760 GNUBraceStyle); 9761 9762 verifyFormat("void foo() {}\n" 9763 "void bar()\n" 9764 "#ifdef _DEBUG\n" 9765 "{\n" 9766 " foo();\n" 9767 "}\n" 9768 "#else\n" 9769 "{\n" 9770 "}\n" 9771 "#endif", 9772 GNUBraceStyle); 9773 9774 verifyFormat("void foobar() { int i = 5; }\n" 9775 "#ifdef _DEBUG\n" 9776 "void bar() {}\n" 9777 "#else\n" 9778 "void bar() { foobar(); }\n" 9779 "#endif", 9780 GNUBraceStyle); 9781 } 9782 9783 TEST_F(FormatTest, WebKitBraceBreaking) { 9784 FormatStyle WebKitBraceStyle = getLLVMStyle(); 9785 WebKitBraceStyle.BreakBeforeBraces = FormatStyle::BS_WebKit; 9786 WebKitBraceStyle.FixNamespaceComments = false; 9787 verifyFormat("namespace a {\n" 9788 "class A {\n" 9789 " void f()\n" 9790 " {\n" 9791 " if (true) {\n" 9792 " a();\n" 9793 " b();\n" 9794 " }\n" 9795 " }\n" 9796 " void g() { return; }\n" 9797 "};\n" 9798 "enum E {\n" 9799 " A,\n" 9800 " // foo\n" 9801 " B,\n" 9802 " C\n" 9803 "};\n" 9804 "struct B {\n" 9805 " int x;\n" 9806 "};\n" 9807 "}\n", 9808 WebKitBraceStyle); 9809 verifyFormat("struct S {\n" 9810 " int Type;\n" 9811 " union {\n" 9812 " int x;\n" 9813 " double y;\n" 9814 " } Value;\n" 9815 " class C {\n" 9816 " MyFavoriteType Value;\n" 9817 " } Class;\n" 9818 "};\n", 9819 WebKitBraceStyle); 9820 } 9821 9822 TEST_F(FormatTest, CatchExceptionReferenceBinding) { 9823 verifyFormat("void f() {\n" 9824 " try {\n" 9825 " } catch (const Exception &e) {\n" 9826 " }\n" 9827 "}\n", 9828 getLLVMStyle()); 9829 } 9830 9831 TEST_F(FormatTest, UnderstandsPragmas) { 9832 verifyFormat("#pragma omp reduction(| : var)"); 9833 verifyFormat("#pragma omp reduction(+ : var)"); 9834 9835 EXPECT_EQ("#pragma mark Any non-hyphenated or hyphenated string " 9836 "(including parentheses).", 9837 format("#pragma mark Any non-hyphenated or hyphenated string " 9838 "(including parentheses).")); 9839 } 9840 9841 TEST_F(FormatTest, UnderstandPragmaOption) { 9842 verifyFormat("#pragma option -C -A"); 9843 9844 EXPECT_EQ("#pragma option -C -A", format("#pragma option -C -A")); 9845 } 9846 9847 #define EXPECT_ALL_STYLES_EQUAL(Styles) \ 9848 for (size_t i = 1; i < Styles.size(); ++i) \ 9849 EXPECT_EQ(Styles[0], Styles[i]) << "Style #" << i << " of " << Styles.size() \ 9850 << " differs from Style #0" 9851 9852 TEST_F(FormatTest, GetsPredefinedStyleByName) { 9853 SmallVector<FormatStyle, 3> Styles; 9854 Styles.resize(3); 9855 9856 Styles[0] = getLLVMStyle(); 9857 EXPECT_TRUE(getPredefinedStyle("LLVM", FormatStyle::LK_Cpp, &Styles[1])); 9858 EXPECT_TRUE(getPredefinedStyle("lLvM", FormatStyle::LK_Cpp, &Styles[2])); 9859 EXPECT_ALL_STYLES_EQUAL(Styles); 9860 9861 Styles[0] = getGoogleStyle(); 9862 EXPECT_TRUE(getPredefinedStyle("Google", FormatStyle::LK_Cpp, &Styles[1])); 9863 EXPECT_TRUE(getPredefinedStyle("gOOgle", FormatStyle::LK_Cpp, &Styles[2])); 9864 EXPECT_ALL_STYLES_EQUAL(Styles); 9865 9866 Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript); 9867 EXPECT_TRUE( 9868 getPredefinedStyle("Google", FormatStyle::LK_JavaScript, &Styles[1])); 9869 EXPECT_TRUE( 9870 getPredefinedStyle("gOOgle", FormatStyle::LK_JavaScript, &Styles[2])); 9871 EXPECT_ALL_STYLES_EQUAL(Styles); 9872 9873 Styles[0] = getChromiumStyle(FormatStyle::LK_Cpp); 9874 EXPECT_TRUE(getPredefinedStyle("Chromium", FormatStyle::LK_Cpp, &Styles[1])); 9875 EXPECT_TRUE(getPredefinedStyle("cHRoMiUM", FormatStyle::LK_Cpp, &Styles[2])); 9876 EXPECT_ALL_STYLES_EQUAL(Styles); 9877 9878 Styles[0] = getMozillaStyle(); 9879 EXPECT_TRUE(getPredefinedStyle("Mozilla", FormatStyle::LK_Cpp, &Styles[1])); 9880 EXPECT_TRUE(getPredefinedStyle("moZILla", FormatStyle::LK_Cpp, &Styles[2])); 9881 EXPECT_ALL_STYLES_EQUAL(Styles); 9882 9883 Styles[0] = getWebKitStyle(); 9884 EXPECT_TRUE(getPredefinedStyle("WebKit", FormatStyle::LK_Cpp, &Styles[1])); 9885 EXPECT_TRUE(getPredefinedStyle("wEbKit", FormatStyle::LK_Cpp, &Styles[2])); 9886 EXPECT_ALL_STYLES_EQUAL(Styles); 9887 9888 Styles[0] = getGNUStyle(); 9889 EXPECT_TRUE(getPredefinedStyle("GNU", FormatStyle::LK_Cpp, &Styles[1])); 9890 EXPECT_TRUE(getPredefinedStyle("gnU", FormatStyle::LK_Cpp, &Styles[2])); 9891 EXPECT_ALL_STYLES_EQUAL(Styles); 9892 9893 EXPECT_FALSE(getPredefinedStyle("qwerty", FormatStyle::LK_Cpp, &Styles[0])); 9894 } 9895 9896 TEST_F(FormatTest, GetsCorrectBasedOnStyle) { 9897 SmallVector<FormatStyle, 8> Styles; 9898 Styles.resize(2); 9899 9900 Styles[0] = getGoogleStyle(); 9901 Styles[1] = getLLVMStyle(); 9902 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value()); 9903 EXPECT_ALL_STYLES_EQUAL(Styles); 9904 9905 Styles.resize(5); 9906 Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript); 9907 Styles[1] = getLLVMStyle(); 9908 Styles[1].Language = FormatStyle::LK_JavaScript; 9909 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value()); 9910 9911 Styles[2] = getLLVMStyle(); 9912 Styles[2].Language = FormatStyle::LK_JavaScript; 9913 EXPECT_EQ(0, parseConfiguration("Language: JavaScript\n" 9914 "BasedOnStyle: Google", 9915 &Styles[2]) 9916 .value()); 9917 9918 Styles[3] = getLLVMStyle(); 9919 Styles[3].Language = FormatStyle::LK_JavaScript; 9920 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google\n" 9921 "Language: JavaScript", 9922 &Styles[3]) 9923 .value()); 9924 9925 Styles[4] = getLLVMStyle(); 9926 Styles[4].Language = FormatStyle::LK_JavaScript; 9927 EXPECT_EQ(0, parseConfiguration("---\n" 9928 "BasedOnStyle: LLVM\n" 9929 "IndentWidth: 123\n" 9930 "---\n" 9931 "BasedOnStyle: Google\n" 9932 "Language: JavaScript", 9933 &Styles[4]) 9934 .value()); 9935 EXPECT_ALL_STYLES_EQUAL(Styles); 9936 } 9937 9938 #define CHECK_PARSE_BOOL_FIELD(FIELD, CONFIG_NAME) \ 9939 Style.FIELD = false; \ 9940 EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": true", &Style).value()); \ 9941 EXPECT_TRUE(Style.FIELD); \ 9942 EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": false", &Style).value()); \ 9943 EXPECT_FALSE(Style.FIELD); 9944 9945 #define CHECK_PARSE_BOOL(FIELD) CHECK_PARSE_BOOL_FIELD(FIELD, #FIELD) 9946 9947 #define CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, CONFIG_NAME) \ 9948 Style.STRUCT.FIELD = false; \ 9949 EXPECT_EQ(0, \ 9950 parseConfiguration(#STRUCT ":\n " CONFIG_NAME ": true", &Style) \ 9951 .value()); \ 9952 EXPECT_TRUE(Style.STRUCT.FIELD); \ 9953 EXPECT_EQ(0, \ 9954 parseConfiguration(#STRUCT ":\n " CONFIG_NAME ": false", &Style) \ 9955 .value()); \ 9956 EXPECT_FALSE(Style.STRUCT.FIELD); 9957 9958 #define CHECK_PARSE_NESTED_BOOL(STRUCT, FIELD) \ 9959 CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, #FIELD) 9960 9961 #define CHECK_PARSE(TEXT, FIELD, VALUE) \ 9962 EXPECT_NE(VALUE, Style.FIELD); \ 9963 EXPECT_EQ(0, parseConfiguration(TEXT, &Style).value()); \ 9964 EXPECT_EQ(VALUE, Style.FIELD) 9965 9966 TEST_F(FormatTest, ParsesConfigurationBools) { 9967 FormatStyle Style = {}; 9968 Style.Language = FormatStyle::LK_Cpp; 9969 CHECK_PARSE_BOOL(AlignOperands); 9970 CHECK_PARSE_BOOL(AlignTrailingComments); 9971 CHECK_PARSE_BOOL(AlignConsecutiveAssignments); 9972 CHECK_PARSE_BOOL(AlignConsecutiveDeclarations); 9973 CHECK_PARSE_BOOL(AllowAllParametersOfDeclarationOnNextLine); 9974 CHECK_PARSE_BOOL(AllowShortBlocksOnASingleLine); 9975 CHECK_PARSE_BOOL(AllowShortCaseLabelsOnASingleLine); 9976 CHECK_PARSE_BOOL(AllowShortIfStatementsOnASingleLine); 9977 CHECK_PARSE_BOOL(AllowShortLoopsOnASingleLine); 9978 CHECK_PARSE_BOOL(AlwaysBreakTemplateDeclarations); 9979 CHECK_PARSE_BOOL(BinPackArguments); 9980 CHECK_PARSE_BOOL(BinPackParameters); 9981 CHECK_PARSE_BOOL(BreakAfterJavaFieldAnnotations); 9982 CHECK_PARSE_BOOL(BreakBeforeTernaryOperators); 9983 CHECK_PARSE_BOOL(BreakStringLiterals); 9984 CHECK_PARSE_BOOL(BreakBeforeInheritanceComma) 9985 CHECK_PARSE_BOOL(CompactNamespaces); 9986 CHECK_PARSE_BOOL(ConstructorInitializerAllOnOneLineOrOnePerLine); 9987 CHECK_PARSE_BOOL(DerivePointerAlignment); 9988 CHECK_PARSE_BOOL_FIELD(DerivePointerAlignment, "DerivePointerBinding"); 9989 CHECK_PARSE_BOOL(DisableFormat); 9990 CHECK_PARSE_BOOL(IndentCaseLabels); 9991 CHECK_PARSE_BOOL(IndentWrappedFunctionNames); 9992 CHECK_PARSE_BOOL(KeepEmptyLinesAtTheStartOfBlocks); 9993 CHECK_PARSE_BOOL(ObjCSpaceAfterProperty); 9994 CHECK_PARSE_BOOL(ObjCSpaceBeforeProtocolList); 9995 CHECK_PARSE_BOOL(Cpp11BracedListStyle); 9996 CHECK_PARSE_BOOL(ReflowComments); 9997 CHECK_PARSE_BOOL(SortIncludes); 9998 CHECK_PARSE_BOOL(SortUsingDeclarations); 9999 CHECK_PARSE_BOOL(SpacesInParentheses); 10000 CHECK_PARSE_BOOL(SpacesInSquareBrackets); 10001 CHECK_PARSE_BOOL(SpacesInAngles); 10002 CHECK_PARSE_BOOL(SpaceInEmptyParentheses); 10003 CHECK_PARSE_BOOL(SpacesInContainerLiterals); 10004 CHECK_PARSE_BOOL(SpacesInCStyleCastParentheses); 10005 CHECK_PARSE_BOOL(SpaceAfterCStyleCast); 10006 CHECK_PARSE_BOOL(SpaceAfterTemplateKeyword); 10007 CHECK_PARSE_BOOL(SpaceBeforeAssignmentOperators); 10008 10009 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterClass); 10010 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterControlStatement); 10011 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterEnum); 10012 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterFunction); 10013 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterNamespace); 10014 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterObjCDeclaration); 10015 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterStruct); 10016 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterUnion); 10017 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterExternBlock); 10018 CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeCatch); 10019 CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeElse); 10020 CHECK_PARSE_NESTED_BOOL(BraceWrapping, IndentBraces); 10021 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyFunction); 10022 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyRecord); 10023 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyNamespace); 10024 } 10025 10026 #undef CHECK_PARSE_BOOL 10027 10028 TEST_F(FormatTest, ParsesConfiguration) { 10029 FormatStyle Style = {}; 10030 Style.Language = FormatStyle::LK_Cpp; 10031 CHECK_PARSE("AccessModifierOffset: -1234", AccessModifierOffset, -1234); 10032 CHECK_PARSE("ConstructorInitializerIndentWidth: 1234", 10033 ConstructorInitializerIndentWidth, 1234u); 10034 CHECK_PARSE("ObjCBlockIndentWidth: 1234", ObjCBlockIndentWidth, 1234u); 10035 CHECK_PARSE("ColumnLimit: 1234", ColumnLimit, 1234u); 10036 CHECK_PARSE("MaxEmptyLinesToKeep: 1234", MaxEmptyLinesToKeep, 1234u); 10037 CHECK_PARSE("PenaltyBreakAssignment: 1234", 10038 PenaltyBreakAssignment, 1234u); 10039 CHECK_PARSE("PenaltyBreakBeforeFirstCallParameter: 1234", 10040 PenaltyBreakBeforeFirstCallParameter, 1234u); 10041 CHECK_PARSE("PenaltyExcessCharacter: 1234", PenaltyExcessCharacter, 1234u); 10042 CHECK_PARSE("PenaltyReturnTypeOnItsOwnLine: 1234", 10043 PenaltyReturnTypeOnItsOwnLine, 1234u); 10044 CHECK_PARSE("SpacesBeforeTrailingComments: 1234", 10045 SpacesBeforeTrailingComments, 1234u); 10046 CHECK_PARSE("IndentWidth: 32", IndentWidth, 32u); 10047 CHECK_PARSE("ContinuationIndentWidth: 11", ContinuationIndentWidth, 11u); 10048 CHECK_PARSE("CommentPragmas: '// abc$'", CommentPragmas, "// abc$"); 10049 10050 Style.PointerAlignment = FormatStyle::PAS_Middle; 10051 CHECK_PARSE("PointerAlignment: Left", PointerAlignment, 10052 FormatStyle::PAS_Left); 10053 CHECK_PARSE("PointerAlignment: Right", PointerAlignment, 10054 FormatStyle::PAS_Right); 10055 CHECK_PARSE("PointerAlignment: Middle", PointerAlignment, 10056 FormatStyle::PAS_Middle); 10057 // For backward compatibility: 10058 CHECK_PARSE("PointerBindsToType: Left", PointerAlignment, 10059 FormatStyle::PAS_Left); 10060 CHECK_PARSE("PointerBindsToType: Right", PointerAlignment, 10061 FormatStyle::PAS_Right); 10062 CHECK_PARSE("PointerBindsToType: Middle", PointerAlignment, 10063 FormatStyle::PAS_Middle); 10064 10065 Style.Standard = FormatStyle::LS_Auto; 10066 CHECK_PARSE("Standard: Cpp03", Standard, FormatStyle::LS_Cpp03); 10067 CHECK_PARSE("Standard: Cpp11", Standard, FormatStyle::LS_Cpp11); 10068 CHECK_PARSE("Standard: C++03", Standard, FormatStyle::LS_Cpp03); 10069 CHECK_PARSE("Standard: C++11", Standard, FormatStyle::LS_Cpp11); 10070 CHECK_PARSE("Standard: Auto", Standard, FormatStyle::LS_Auto); 10071 10072 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 10073 CHECK_PARSE("BreakBeforeBinaryOperators: NonAssignment", 10074 BreakBeforeBinaryOperators, FormatStyle::BOS_NonAssignment); 10075 CHECK_PARSE("BreakBeforeBinaryOperators: None", BreakBeforeBinaryOperators, 10076 FormatStyle::BOS_None); 10077 CHECK_PARSE("BreakBeforeBinaryOperators: All", BreakBeforeBinaryOperators, 10078 FormatStyle::BOS_All); 10079 // For backward compatibility: 10080 CHECK_PARSE("BreakBeforeBinaryOperators: false", BreakBeforeBinaryOperators, 10081 FormatStyle::BOS_None); 10082 CHECK_PARSE("BreakBeforeBinaryOperators: true", BreakBeforeBinaryOperators, 10083 FormatStyle::BOS_All); 10084 10085 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon; 10086 CHECK_PARSE("BreakConstructorInitializers: BeforeComma", 10087 BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma); 10088 CHECK_PARSE("BreakConstructorInitializers: AfterColon", 10089 BreakConstructorInitializers, FormatStyle::BCIS_AfterColon); 10090 CHECK_PARSE("BreakConstructorInitializers: BeforeColon", 10091 BreakConstructorInitializers, FormatStyle::BCIS_BeforeColon); 10092 // For backward compatibility: 10093 CHECK_PARSE("BreakConstructorInitializersBeforeComma: true", 10094 BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma); 10095 10096 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 10097 CHECK_PARSE("AlignAfterOpenBracket: Align", AlignAfterOpenBracket, 10098 FormatStyle::BAS_Align); 10099 CHECK_PARSE("AlignAfterOpenBracket: DontAlign", AlignAfterOpenBracket, 10100 FormatStyle::BAS_DontAlign); 10101 CHECK_PARSE("AlignAfterOpenBracket: AlwaysBreak", AlignAfterOpenBracket, 10102 FormatStyle::BAS_AlwaysBreak); 10103 // For backward compatibility: 10104 CHECK_PARSE("AlignAfterOpenBracket: false", AlignAfterOpenBracket, 10105 FormatStyle::BAS_DontAlign); 10106 CHECK_PARSE("AlignAfterOpenBracket: true", AlignAfterOpenBracket, 10107 FormatStyle::BAS_Align); 10108 10109 Style.AlignEscapedNewlines = FormatStyle::ENAS_Left; 10110 CHECK_PARSE("AlignEscapedNewlines: DontAlign", AlignEscapedNewlines, 10111 FormatStyle::ENAS_DontAlign); 10112 CHECK_PARSE("AlignEscapedNewlines: Left", AlignEscapedNewlines, 10113 FormatStyle::ENAS_Left); 10114 CHECK_PARSE("AlignEscapedNewlines: Right", AlignEscapedNewlines, 10115 FormatStyle::ENAS_Right); 10116 // For backward compatibility: 10117 CHECK_PARSE("AlignEscapedNewlinesLeft: true", AlignEscapedNewlines, 10118 FormatStyle::ENAS_Left); 10119 CHECK_PARSE("AlignEscapedNewlinesLeft: false", AlignEscapedNewlines, 10120 FormatStyle::ENAS_Right); 10121 10122 Style.UseTab = FormatStyle::UT_ForIndentation; 10123 CHECK_PARSE("UseTab: Never", UseTab, FormatStyle::UT_Never); 10124 CHECK_PARSE("UseTab: ForIndentation", UseTab, FormatStyle::UT_ForIndentation); 10125 CHECK_PARSE("UseTab: Always", UseTab, FormatStyle::UT_Always); 10126 CHECK_PARSE("UseTab: ForContinuationAndIndentation", UseTab, 10127 FormatStyle::UT_ForContinuationAndIndentation); 10128 // For backward compatibility: 10129 CHECK_PARSE("UseTab: false", UseTab, FormatStyle::UT_Never); 10130 CHECK_PARSE("UseTab: true", UseTab, FormatStyle::UT_Always); 10131 10132 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; 10133 CHECK_PARSE("AllowShortFunctionsOnASingleLine: None", 10134 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None); 10135 CHECK_PARSE("AllowShortFunctionsOnASingleLine: Inline", 10136 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Inline); 10137 CHECK_PARSE("AllowShortFunctionsOnASingleLine: Empty", 10138 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Empty); 10139 CHECK_PARSE("AllowShortFunctionsOnASingleLine: All", 10140 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All); 10141 // For backward compatibility: 10142 CHECK_PARSE("AllowShortFunctionsOnASingleLine: false", 10143 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None); 10144 CHECK_PARSE("AllowShortFunctionsOnASingleLine: true", 10145 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All); 10146 10147 Style.SpaceBeforeParens = FormatStyle::SBPO_Always; 10148 CHECK_PARSE("SpaceBeforeParens: Never", SpaceBeforeParens, 10149 FormatStyle::SBPO_Never); 10150 CHECK_PARSE("SpaceBeforeParens: Always", SpaceBeforeParens, 10151 FormatStyle::SBPO_Always); 10152 CHECK_PARSE("SpaceBeforeParens: ControlStatements", SpaceBeforeParens, 10153 FormatStyle::SBPO_ControlStatements); 10154 // For backward compatibility: 10155 CHECK_PARSE("SpaceAfterControlStatementKeyword: false", SpaceBeforeParens, 10156 FormatStyle::SBPO_Never); 10157 CHECK_PARSE("SpaceAfterControlStatementKeyword: true", SpaceBeforeParens, 10158 FormatStyle::SBPO_ControlStatements); 10159 10160 Style.ColumnLimit = 123; 10161 FormatStyle BaseStyle = getLLVMStyle(); 10162 CHECK_PARSE("BasedOnStyle: LLVM", ColumnLimit, BaseStyle.ColumnLimit); 10163 CHECK_PARSE("BasedOnStyle: LLVM\nColumnLimit: 1234", ColumnLimit, 1234u); 10164 10165 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 10166 CHECK_PARSE("BreakBeforeBraces: Attach", BreakBeforeBraces, 10167 FormatStyle::BS_Attach); 10168 CHECK_PARSE("BreakBeforeBraces: Linux", BreakBeforeBraces, 10169 FormatStyle::BS_Linux); 10170 CHECK_PARSE("BreakBeforeBraces: Mozilla", BreakBeforeBraces, 10171 FormatStyle::BS_Mozilla); 10172 CHECK_PARSE("BreakBeforeBraces: Stroustrup", BreakBeforeBraces, 10173 FormatStyle::BS_Stroustrup); 10174 CHECK_PARSE("BreakBeforeBraces: Allman", BreakBeforeBraces, 10175 FormatStyle::BS_Allman); 10176 CHECK_PARSE("BreakBeforeBraces: GNU", BreakBeforeBraces, FormatStyle::BS_GNU); 10177 CHECK_PARSE("BreakBeforeBraces: WebKit", BreakBeforeBraces, 10178 FormatStyle::BS_WebKit); 10179 CHECK_PARSE("BreakBeforeBraces: Custom", BreakBeforeBraces, 10180 FormatStyle::BS_Custom); 10181 10182 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All; 10183 CHECK_PARSE("AlwaysBreakAfterReturnType: None", AlwaysBreakAfterReturnType, 10184 FormatStyle::RTBS_None); 10185 CHECK_PARSE("AlwaysBreakAfterReturnType: All", AlwaysBreakAfterReturnType, 10186 FormatStyle::RTBS_All); 10187 CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevel", 10188 AlwaysBreakAfterReturnType, FormatStyle::RTBS_TopLevel); 10189 CHECK_PARSE("AlwaysBreakAfterReturnType: AllDefinitions", 10190 AlwaysBreakAfterReturnType, FormatStyle::RTBS_AllDefinitions); 10191 CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevelDefinitions", 10192 AlwaysBreakAfterReturnType, 10193 FormatStyle::RTBS_TopLevelDefinitions); 10194 10195 Style.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_All; 10196 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: None", 10197 AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_None); 10198 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: All", 10199 AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_All); 10200 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: TopLevel", 10201 AlwaysBreakAfterDefinitionReturnType, 10202 FormatStyle::DRTBS_TopLevel); 10203 10204 Style.NamespaceIndentation = FormatStyle::NI_All; 10205 CHECK_PARSE("NamespaceIndentation: None", NamespaceIndentation, 10206 FormatStyle::NI_None); 10207 CHECK_PARSE("NamespaceIndentation: Inner", NamespaceIndentation, 10208 FormatStyle::NI_Inner); 10209 CHECK_PARSE("NamespaceIndentation: All", NamespaceIndentation, 10210 FormatStyle::NI_All); 10211 10212 // FIXME: This is required because parsing a configuration simply overwrites 10213 // the first N elements of the list instead of resetting it. 10214 Style.ForEachMacros.clear(); 10215 std::vector<std::string> BoostForeach; 10216 BoostForeach.push_back("BOOST_FOREACH"); 10217 CHECK_PARSE("ForEachMacros: [BOOST_FOREACH]", ForEachMacros, BoostForeach); 10218 std::vector<std::string> BoostAndQForeach; 10219 BoostAndQForeach.push_back("BOOST_FOREACH"); 10220 BoostAndQForeach.push_back("Q_FOREACH"); 10221 CHECK_PARSE("ForEachMacros: [BOOST_FOREACH, Q_FOREACH]", ForEachMacros, 10222 BoostAndQForeach); 10223 10224 Style.IncludeCategories.clear(); 10225 std::vector<FormatStyle::IncludeCategory> ExpectedCategories = {{"abc/.*", 2}, 10226 {".*", 1}}; 10227 CHECK_PARSE("IncludeCategories:\n" 10228 " - Regex: abc/.*\n" 10229 " Priority: 2\n" 10230 " - Regex: .*\n" 10231 " Priority: 1", 10232 IncludeCategories, ExpectedCategories); 10233 CHECK_PARSE("IncludeIsMainRegex: 'abc$'", IncludeIsMainRegex, "abc$"); 10234 } 10235 10236 TEST_F(FormatTest, ParsesConfigurationWithLanguages) { 10237 FormatStyle Style = {}; 10238 Style.Language = FormatStyle::LK_Cpp; 10239 CHECK_PARSE("Language: Cpp\n" 10240 "IndentWidth: 12", 10241 IndentWidth, 12u); 10242 EXPECT_EQ(parseConfiguration("Language: JavaScript\n" 10243 "IndentWidth: 34", 10244 &Style), 10245 ParseError::Unsuitable); 10246 EXPECT_EQ(12u, Style.IndentWidth); 10247 CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u); 10248 EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language); 10249 10250 Style.Language = FormatStyle::LK_JavaScript; 10251 CHECK_PARSE("Language: JavaScript\n" 10252 "IndentWidth: 12", 10253 IndentWidth, 12u); 10254 CHECK_PARSE("IndentWidth: 23", IndentWidth, 23u); 10255 EXPECT_EQ(parseConfiguration("Language: Cpp\n" 10256 "IndentWidth: 34", 10257 &Style), 10258 ParseError::Unsuitable); 10259 EXPECT_EQ(23u, Style.IndentWidth); 10260 CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u); 10261 EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language); 10262 10263 CHECK_PARSE("BasedOnStyle: LLVM\n" 10264 "IndentWidth: 67", 10265 IndentWidth, 67u); 10266 10267 CHECK_PARSE("---\n" 10268 "Language: JavaScript\n" 10269 "IndentWidth: 12\n" 10270 "---\n" 10271 "Language: Cpp\n" 10272 "IndentWidth: 34\n" 10273 "...\n", 10274 IndentWidth, 12u); 10275 10276 Style.Language = FormatStyle::LK_Cpp; 10277 CHECK_PARSE("---\n" 10278 "Language: JavaScript\n" 10279 "IndentWidth: 12\n" 10280 "---\n" 10281 "Language: Cpp\n" 10282 "IndentWidth: 34\n" 10283 "...\n", 10284 IndentWidth, 34u); 10285 CHECK_PARSE("---\n" 10286 "IndentWidth: 78\n" 10287 "---\n" 10288 "Language: JavaScript\n" 10289 "IndentWidth: 56\n" 10290 "...\n", 10291 IndentWidth, 78u); 10292 10293 Style.ColumnLimit = 123; 10294 Style.IndentWidth = 234; 10295 Style.BreakBeforeBraces = FormatStyle::BS_Linux; 10296 Style.TabWidth = 345; 10297 EXPECT_FALSE(parseConfiguration("---\n" 10298 "IndentWidth: 456\n" 10299 "BreakBeforeBraces: Allman\n" 10300 "---\n" 10301 "Language: JavaScript\n" 10302 "IndentWidth: 111\n" 10303 "TabWidth: 111\n" 10304 "---\n" 10305 "Language: Cpp\n" 10306 "BreakBeforeBraces: Stroustrup\n" 10307 "TabWidth: 789\n" 10308 "...\n", 10309 &Style)); 10310 EXPECT_EQ(123u, Style.ColumnLimit); 10311 EXPECT_EQ(456u, Style.IndentWidth); 10312 EXPECT_EQ(FormatStyle::BS_Stroustrup, Style.BreakBeforeBraces); 10313 EXPECT_EQ(789u, Style.TabWidth); 10314 10315 EXPECT_EQ(parseConfiguration("---\n" 10316 "Language: JavaScript\n" 10317 "IndentWidth: 56\n" 10318 "---\n" 10319 "IndentWidth: 78\n" 10320 "...\n", 10321 &Style), 10322 ParseError::Error); 10323 EXPECT_EQ(parseConfiguration("---\n" 10324 "Language: JavaScript\n" 10325 "IndentWidth: 56\n" 10326 "---\n" 10327 "Language: JavaScript\n" 10328 "IndentWidth: 78\n" 10329 "...\n", 10330 &Style), 10331 ParseError::Error); 10332 10333 EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language); 10334 } 10335 10336 #undef CHECK_PARSE 10337 10338 TEST_F(FormatTest, UsesLanguageForBasedOnStyle) { 10339 FormatStyle Style = {}; 10340 Style.Language = FormatStyle::LK_JavaScript; 10341 Style.BreakBeforeTernaryOperators = true; 10342 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Style).value()); 10343 EXPECT_FALSE(Style.BreakBeforeTernaryOperators); 10344 10345 Style.BreakBeforeTernaryOperators = true; 10346 EXPECT_EQ(0, parseConfiguration("---\n" 10347 "BasedOnStyle: Google\n" 10348 "---\n" 10349 "Language: JavaScript\n" 10350 "IndentWidth: 76\n" 10351 "...\n", 10352 &Style) 10353 .value()); 10354 EXPECT_FALSE(Style.BreakBeforeTernaryOperators); 10355 EXPECT_EQ(76u, Style.IndentWidth); 10356 EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language); 10357 } 10358 10359 TEST_F(FormatTest, ConfigurationRoundTripTest) { 10360 FormatStyle Style = getLLVMStyle(); 10361 std::string YAML = configurationAsText(Style); 10362 FormatStyle ParsedStyle = {}; 10363 ParsedStyle.Language = FormatStyle::LK_Cpp; 10364 EXPECT_EQ(0, parseConfiguration(YAML, &ParsedStyle).value()); 10365 EXPECT_EQ(Style, ParsedStyle); 10366 } 10367 10368 TEST_F(FormatTest, WorksFor8bitEncodings) { 10369 EXPECT_EQ("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 \"\n" 10370 "\"\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \"\n" 10371 "\"\xe7\xe8\xec\xed\xfe\xfe \"\n" 10372 "\"\xef\xee\xf0\xf3...\"", 10373 format("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 " 10374 "\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \xe7\xe8\xec\xed\xfe\xfe " 10375 "\xef\xee\xf0\xf3...\"", 10376 getLLVMStyleWithColumns(12))); 10377 } 10378 10379 TEST_F(FormatTest, HandlesUTF8BOM) { 10380 EXPECT_EQ("\xef\xbb\xbf", format("\xef\xbb\xbf")); 10381 EXPECT_EQ("\xef\xbb\xbf#include <iostream>", 10382 format("\xef\xbb\xbf#include <iostream>")); 10383 EXPECT_EQ("\xef\xbb\xbf\n#include <iostream>", 10384 format("\xef\xbb\xbf\n#include <iostream>")); 10385 } 10386 10387 // FIXME: Encode Cyrillic and CJK characters below to appease MS compilers. 10388 #if !defined(_MSC_VER) 10389 10390 TEST_F(FormatTest, CountsUTF8CharactersProperly) { 10391 verifyFormat("\"Однажды в студёную зимнюю пору...\"", 10392 getLLVMStyleWithColumns(35)); 10393 verifyFormat("\"一 二 三 四 五 六 七 八 九 十\"", 10394 getLLVMStyleWithColumns(31)); 10395 verifyFormat("// Однажды в студёную зимнюю пору...", 10396 getLLVMStyleWithColumns(36)); 10397 verifyFormat("// 一 二 三 四 五 六 七 八 九 十", getLLVMStyleWithColumns(32)); 10398 verifyFormat("/* Однажды в студёную зимнюю пору... */", 10399 getLLVMStyleWithColumns(39)); 10400 verifyFormat("/* 一 二 三 四 五 六 七 八 九 十 */", 10401 getLLVMStyleWithColumns(35)); 10402 } 10403 10404 TEST_F(FormatTest, SplitsUTF8Strings) { 10405 // Non-printable characters' width is currently considered to be the length in 10406 // bytes in UTF8. The characters can be displayed in very different manner 10407 // (zero-width, single width with a substitution glyph, expanded to their code 10408 // (e.g. "<8d>"), so there's no single correct way to handle them. 10409 EXPECT_EQ("\"aaaaÄ\"\n" 10410 "\"\xc2\x8d\";", 10411 format("\"aaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10))); 10412 EXPECT_EQ("\"aaaaaaaÄ\"\n" 10413 "\"\xc2\x8d\";", 10414 format("\"aaaaaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10))); 10415 EXPECT_EQ("\"Однажды, в \"\n" 10416 "\"студёную \"\n" 10417 "\"зимнюю \"\n" 10418 "\"пору,\"", 10419 format("\"Однажды, в студёную зимнюю пору,\"", 10420 getLLVMStyleWithColumns(13))); 10421 EXPECT_EQ( 10422 "\"一 二 三 \"\n" 10423 "\"四 五六 \"\n" 10424 "\"七 八 九 \"\n" 10425 "\"十\"", 10426 format("\"一 二 三 四 五六 七 八 九 十\"", getLLVMStyleWithColumns(11))); 10427 EXPECT_EQ("\"一\t二 \"\n" 10428 "\"\t三 \"\n" 10429 "\"四 五\t六 \"\n" 10430 "\"\t七 \"\n" 10431 "\"八九十\tqq\"", 10432 format("\"一\t二 \t三 四 五\t六 \t七 八九十\tqq\"", 10433 getLLVMStyleWithColumns(11))); 10434 10435 // UTF8 character in an escape sequence. 10436 EXPECT_EQ("\"aaaaaa\"\n" 10437 "\"\\\xC2\x8D\"", 10438 format("\"aaaaaa\\\xC2\x8D\"", getLLVMStyleWithColumns(10))); 10439 } 10440 10441 TEST_F(FormatTest, HandlesDoubleWidthCharsInMultiLineStrings) { 10442 EXPECT_EQ("const char *sssss =\n" 10443 " \"一二三四五六七八\\\n" 10444 " 九 十\";", 10445 format("const char *sssss = \"一二三四五六七八\\\n" 10446 " 九 十\";", 10447 getLLVMStyleWithColumns(30))); 10448 } 10449 10450 TEST_F(FormatTest, SplitsUTF8LineComments) { 10451 EXPECT_EQ("// aaaaÄ\xc2\x8d", 10452 format("// aaaaÄ\xc2\x8d", getLLVMStyleWithColumns(10))); 10453 EXPECT_EQ("// Я из лесу\n" 10454 "// вышел; был\n" 10455 "// сильный\n" 10456 "// мороз.", 10457 format("// Я из лесу вышел; был сильный мороз.", 10458 getLLVMStyleWithColumns(13))); 10459 EXPECT_EQ("// 一二三\n" 10460 "// 四五六七\n" 10461 "// 八 九\n" 10462 "// 十", 10463 format("// 一二三 四五六七 八 九 十", getLLVMStyleWithColumns(9))); 10464 } 10465 10466 TEST_F(FormatTest, SplitsUTF8BlockComments) { 10467 EXPECT_EQ("/* Гляжу,\n" 10468 " * поднимается\n" 10469 " * медленно в\n" 10470 " * гору\n" 10471 " * Лошадка,\n" 10472 " * везущая\n" 10473 " * хворосту\n" 10474 " * воз. */", 10475 format("/* Гляжу, поднимается медленно в гору\n" 10476 " * Лошадка, везущая хворосту воз. */", 10477 getLLVMStyleWithColumns(13))); 10478 EXPECT_EQ( 10479 "/* 一二三\n" 10480 " * 四五六七\n" 10481 " * 八 九\n" 10482 " * 十 */", 10483 format("/* 一二三 四五六七 八 九 十 */", getLLVMStyleWithColumns(9))); 10484 EXPECT_EQ("/* �������� ��������\n" 10485 " * ��������\n" 10486 " * ������-�� */", 10487 format("/* �������� �������� �������� ������-�� */", getLLVMStyleWithColumns(12))); 10488 } 10489 10490 #endif // _MSC_VER 10491 10492 TEST_F(FormatTest, ConstructorInitializerIndentWidth) { 10493 FormatStyle Style = getLLVMStyle(); 10494 10495 Style.ConstructorInitializerIndentWidth = 4; 10496 verifyFormat( 10497 "SomeClass::Constructor()\n" 10498 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 10499 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 10500 Style); 10501 10502 Style.ConstructorInitializerIndentWidth = 2; 10503 verifyFormat( 10504 "SomeClass::Constructor()\n" 10505 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 10506 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 10507 Style); 10508 10509 Style.ConstructorInitializerIndentWidth = 0; 10510 verifyFormat( 10511 "SomeClass::Constructor()\n" 10512 ": aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 10513 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 10514 Style); 10515 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 10516 verifyFormat( 10517 "SomeLongTemplateVariableName<\n" 10518 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>", 10519 Style); 10520 verifyFormat( 10521 "bool smaller = 1 < bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 10522 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 10523 Style); 10524 } 10525 10526 TEST_F(FormatTest, BreakConstructorInitializersBeforeComma) { 10527 FormatStyle Style = getLLVMStyle(); 10528 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 10529 Style.ConstructorInitializerIndentWidth = 4; 10530 verifyFormat("SomeClass::Constructor()\n" 10531 " : a(a)\n" 10532 " , b(b)\n" 10533 " , c(c) {}", 10534 Style); 10535 verifyFormat("SomeClass::Constructor()\n" 10536 " : a(a) {}", 10537 Style); 10538 10539 Style.ColumnLimit = 0; 10540 verifyFormat("SomeClass::Constructor()\n" 10541 " : a(a) {}", 10542 Style); 10543 verifyFormat("SomeClass::Constructor() noexcept\n" 10544 " : a(a) {}", 10545 Style); 10546 verifyFormat("SomeClass::Constructor()\n" 10547 " : a(a)\n" 10548 " , b(b)\n" 10549 " , c(c) {}", 10550 Style); 10551 verifyFormat("SomeClass::Constructor()\n" 10552 " : a(a) {\n" 10553 " foo();\n" 10554 " bar();\n" 10555 "}", 10556 Style); 10557 10558 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 10559 verifyFormat("SomeClass::Constructor()\n" 10560 " : a(a)\n" 10561 " , b(b)\n" 10562 " , c(c) {\n}", 10563 Style); 10564 verifyFormat("SomeClass::Constructor()\n" 10565 " : a(a) {\n}", 10566 Style); 10567 10568 Style.ColumnLimit = 80; 10569 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 10570 Style.ConstructorInitializerIndentWidth = 2; 10571 verifyFormat("SomeClass::Constructor()\n" 10572 " : a(a)\n" 10573 " , b(b)\n" 10574 " , c(c) {}", 10575 Style); 10576 10577 Style.ConstructorInitializerIndentWidth = 0; 10578 verifyFormat("SomeClass::Constructor()\n" 10579 ": a(a)\n" 10580 ", b(b)\n" 10581 ", c(c) {}", 10582 Style); 10583 10584 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 10585 Style.ConstructorInitializerIndentWidth = 4; 10586 verifyFormat("SomeClass::Constructor() : aaaaaaaa(aaaaaaaa) {}", Style); 10587 verifyFormat( 10588 "SomeClass::Constructor() : aaaaa(aaaaa), aaaaa(aaaaa), aaaaa(aaaaa)\n", 10589 Style); 10590 verifyFormat( 10591 "SomeClass::Constructor()\n" 10592 " : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa) {}", 10593 Style); 10594 Style.ConstructorInitializerIndentWidth = 4; 10595 Style.ColumnLimit = 60; 10596 verifyFormat("SomeClass::Constructor()\n" 10597 " : aaaaaaaa(aaaaaaaa)\n" 10598 " , aaaaaaaa(aaaaaaaa)\n" 10599 " , aaaaaaaa(aaaaaaaa) {}", 10600 Style); 10601 } 10602 10603 TEST_F(FormatTest, Destructors) { 10604 verifyFormat("void F(int &i) { i.~int(); }"); 10605 verifyFormat("void F(int &i) { i->~int(); }"); 10606 } 10607 10608 TEST_F(FormatTest, FormatsWithWebKitStyle) { 10609 FormatStyle Style = getWebKitStyle(); 10610 10611 // Don't indent in outer namespaces. 10612 verifyFormat("namespace outer {\n" 10613 "int i;\n" 10614 "namespace inner {\n" 10615 " int i;\n" 10616 "} // namespace inner\n" 10617 "} // namespace outer\n" 10618 "namespace other_outer {\n" 10619 "int i;\n" 10620 "}", 10621 Style); 10622 10623 // Don't indent case labels. 10624 verifyFormat("switch (variable) {\n" 10625 "case 1:\n" 10626 "case 2:\n" 10627 " doSomething();\n" 10628 " break;\n" 10629 "default:\n" 10630 " ++variable;\n" 10631 "}", 10632 Style); 10633 10634 // Wrap before binary operators. 10635 EXPECT_EQ("void f()\n" 10636 "{\n" 10637 " if (aaaaaaaaaaaaaaaa\n" 10638 " && bbbbbbbbbbbbbbbbbbbbbbbb\n" 10639 " && (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n" 10640 " return;\n" 10641 "}", 10642 format("void f() {\n" 10643 "if (aaaaaaaaaaaaaaaa\n" 10644 "&& bbbbbbbbbbbbbbbbbbbbbbbb\n" 10645 "&& (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n" 10646 "return;\n" 10647 "}", 10648 Style)); 10649 10650 // Allow functions on a single line. 10651 verifyFormat("void f() { return; }", Style); 10652 10653 // Constructor initializers are formatted one per line with the "," on the 10654 // new line. 10655 verifyFormat("Constructor()\n" 10656 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 10657 " , aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaa, // break\n" 10658 " aaaaaaaaaaaaaa)\n" 10659 " , aaaaaaaaaaaaaaaaaaaaaaa()\n" 10660 "{\n" 10661 "}", 10662 Style); 10663 verifyFormat("SomeClass::Constructor()\n" 10664 " : a(a)\n" 10665 "{\n" 10666 "}", 10667 Style); 10668 EXPECT_EQ("SomeClass::Constructor()\n" 10669 " : a(a)\n" 10670 "{\n" 10671 "}", 10672 format("SomeClass::Constructor():a(a){}", Style)); 10673 verifyFormat("SomeClass::Constructor()\n" 10674 " : a(a)\n" 10675 " , b(b)\n" 10676 " , c(c)\n" 10677 "{\n" 10678 "}", 10679 Style); 10680 verifyFormat("SomeClass::Constructor()\n" 10681 " : a(a)\n" 10682 "{\n" 10683 " foo();\n" 10684 " bar();\n" 10685 "}", 10686 Style); 10687 10688 // Access specifiers should be aligned left. 10689 verifyFormat("class C {\n" 10690 "public:\n" 10691 " int i;\n" 10692 "};", 10693 Style); 10694 10695 // Do not align comments. 10696 verifyFormat("int a; // Do not\n" 10697 "double b; // align comments.", 10698 Style); 10699 10700 // Do not align operands. 10701 EXPECT_EQ("ASSERT(aaaa\n" 10702 " || bbbb);", 10703 format("ASSERT ( aaaa\n||bbbb);", Style)); 10704 10705 // Accept input's line breaks. 10706 EXPECT_EQ("if (aaaaaaaaaaaaaaa\n" 10707 " || bbbbbbbbbbbbbbb) {\n" 10708 " i++;\n" 10709 "}", 10710 format("if (aaaaaaaaaaaaaaa\n" 10711 "|| bbbbbbbbbbbbbbb) { i++; }", 10712 Style)); 10713 EXPECT_EQ("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) {\n" 10714 " i++;\n" 10715 "}", 10716 format("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) { i++; }", Style)); 10717 10718 // Don't automatically break all macro definitions (llvm.org/PR17842). 10719 verifyFormat("#define aNumber 10", Style); 10720 // However, generally keep the line breaks that the user authored. 10721 EXPECT_EQ("#define aNumber \\\n" 10722 " 10", 10723 format("#define aNumber \\\n" 10724 " 10", 10725 Style)); 10726 10727 // Keep empty and one-element array literals on a single line. 10728 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[]\n" 10729 " copyItems:YES];", 10730 format("NSArray*a=[[NSArray alloc] initWithArray:@[]\n" 10731 "copyItems:YES];", 10732 Style)); 10733 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\" ]\n" 10734 " copyItems:YES];", 10735 format("NSArray*a=[[NSArray alloc]initWithArray:@[ @\"a\" ]\n" 10736 " copyItems:YES];", 10737 Style)); 10738 // FIXME: This does not seem right, there should be more indentation before 10739 // the array literal's entries. Nested blocks have the same problem. 10740 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[\n" 10741 " @\"a\",\n" 10742 " @\"a\"\n" 10743 "]\n" 10744 " copyItems:YES];", 10745 format("NSArray* a = [[NSArray alloc] initWithArray:@[\n" 10746 " @\"a\",\n" 10747 " @\"a\"\n" 10748 " ]\n" 10749 " copyItems:YES];", 10750 Style)); 10751 EXPECT_EQ( 10752 "NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n" 10753 " copyItems:YES];", 10754 format("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n" 10755 " copyItems:YES];", 10756 Style)); 10757 10758 verifyFormat("[self.a b:c c:d];", Style); 10759 EXPECT_EQ("[self.a b:c\n" 10760 " c:d];", 10761 format("[self.a b:c\n" 10762 "c:d];", 10763 Style)); 10764 } 10765 10766 TEST_F(FormatTest, FormatsLambdas) { 10767 verifyFormat("int c = [b]() mutable { return [&b] { return b++; }(); }();\n"); 10768 verifyFormat("int c = [&] { [=] { return b++; }(); }();\n"); 10769 verifyFormat("int c = [&, &a, a] { [=, c, &d] { return b++; }(); }();\n"); 10770 verifyFormat("int c = [&a, &a, a] { [=, a, b, &c] { return b++; }(); }();\n"); 10771 verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] { return b++; }(); }}\n"); 10772 verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] {}(); }}\n"); 10773 verifyFormat("auto c = [a = [b = 42] {}] {};\n"); 10774 verifyFormat("auto c = [a = &i + 10, b = [] {}] {};\n"); 10775 verifyFormat("int x = f(*+[] {});"); 10776 verifyFormat("void f() {\n" 10777 " other(x.begin(), x.end(), [&](int, int) { return 1; });\n" 10778 "}\n"); 10779 verifyFormat("void f() {\n" 10780 " other(x.begin(), //\n" 10781 " x.end(), //\n" 10782 " [&](int, int) { return 1; });\n" 10783 "}\n"); 10784 verifyFormat("SomeFunction([]() { // A cool function...\n" 10785 " return 43;\n" 10786 "});"); 10787 EXPECT_EQ("SomeFunction([]() {\n" 10788 "#define A a\n" 10789 " return 43;\n" 10790 "});", 10791 format("SomeFunction([](){\n" 10792 "#define A a\n" 10793 "return 43;\n" 10794 "});")); 10795 verifyFormat("void f() {\n" 10796 " SomeFunction([](decltype(x), A *a) {});\n" 10797 "}"); 10798 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 10799 " [](const aaaaaaaaaa &a) { return a; });"); 10800 verifyFormat("string abc = SomeFunction(aaaaaaaaaaaaa, aaaaa, []() {\n" 10801 " SomeOtherFunctioooooooooooooooooooooooooon();\n" 10802 "});"); 10803 verifyFormat("Constructor()\n" 10804 " : Field([] { // comment\n" 10805 " int i;\n" 10806 " }) {}"); 10807 verifyFormat("auto my_lambda = [](const string &some_parameter) {\n" 10808 " return some_parameter.size();\n" 10809 "};"); 10810 verifyFormat("std::function<std::string(const std::string &)> my_lambda =\n" 10811 " [](const string &s) { return s; };"); 10812 verifyFormat("int i = aaaaaa ? 1 //\n" 10813 " : [] {\n" 10814 " return 2; //\n" 10815 " }();"); 10816 verifyFormat("llvm::errs() << \"number of twos is \"\n" 10817 " << std::count_if(v.begin(), v.end(), [](int x) {\n" 10818 " return x == 2; // force break\n" 10819 " });"); 10820 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 10821 " [=](int iiiiiiiiiiii) {\n" 10822 " return aaaaaaaaaaaaaaaaaaaaaaa !=\n" 10823 " aaaaaaaaaaaaaaaaaaaaaaa;\n" 10824 " });", 10825 getLLVMStyleWithColumns(60)); 10826 verifyFormat("SomeFunction({[&] {\n" 10827 " // comment\n" 10828 " },\n" 10829 " [&] {\n" 10830 " // comment\n" 10831 " }});"); 10832 verifyFormat("SomeFunction({[&] {\n" 10833 " // comment\n" 10834 "}});"); 10835 verifyFormat("virtual aaaaaaaaaaaaaaaa(std::function<bool()> bbbbbbbbbbbb =\n" 10836 " [&]() { return true; },\n" 10837 " aaaaa aaaaaaaaa);"); 10838 10839 // Lambdas with return types. 10840 verifyFormat("int c = []() -> int { return 2; }();\n"); 10841 verifyFormat("int c = []() -> int * { return 2; }();\n"); 10842 verifyFormat("int c = []() -> vector<int> { return {2}; }();\n"); 10843 verifyFormat("Foo([]() -> std::vector<int> { return {2}; }());"); 10844 verifyGoogleFormat("auto a = [&b, c](D* d) -> D* {};"); 10845 verifyGoogleFormat("auto a = [&b, c](D* d) -> pair<D*, D*> {};"); 10846 verifyGoogleFormat("auto a = [&b, c](D* d) -> D& {};"); 10847 verifyGoogleFormat("auto a = [&b, c](D* d) -> const D* {};"); 10848 verifyFormat("[a, a]() -> a<1> {};"); 10849 verifyFormat("auto aaaaaaaa = [](int i, // break for some reason\n" 10850 " int j) -> int {\n" 10851 " return ffffffffffffffffffffffffffffffffffffffffffff(i * j);\n" 10852 "};"); 10853 verifyFormat( 10854 "aaaaaaaaaaaaaaaaaaaaaa(\n" 10855 " [](aaaaaaaaaaaaaaaaaaaaaaaaaaa &aaa) -> aaaaaaaaaaaaaaaa {\n" 10856 " return aaaaaaaaaaaaaaaaa;\n" 10857 " });", 10858 getLLVMStyleWithColumns(70)); 10859 verifyFormat("[]() //\n" 10860 " -> int {\n" 10861 " return 1; //\n" 10862 "};"); 10863 10864 // Multiple lambdas in the same parentheses change indentation rules. 10865 verifyFormat("SomeFunction(\n" 10866 " []() {\n" 10867 " int i = 42;\n" 10868 " return i;\n" 10869 " },\n" 10870 " []() {\n" 10871 " int j = 43;\n" 10872 " return j;\n" 10873 " });"); 10874 10875 // More complex introducers. 10876 verifyFormat("return [i, args...] {};"); 10877 10878 // Not lambdas. 10879 verifyFormat("constexpr char hello[]{\"hello\"};"); 10880 verifyFormat("double &operator[](int i) { return 0; }\n" 10881 "int i;"); 10882 verifyFormat("std::unique_ptr<int[]> foo() {}"); 10883 verifyFormat("int i = a[a][a]->f();"); 10884 verifyFormat("int i = (*b)[a]->f();"); 10885 10886 // Other corner cases. 10887 verifyFormat("void f() {\n" 10888 " bar([]() {} // Did not respect SpacesBeforeTrailingComments\n" 10889 " );\n" 10890 "}"); 10891 10892 // Lambdas created through weird macros. 10893 verifyFormat("void f() {\n" 10894 " MACRO((const AA &a) { return 1; });\n" 10895 " MACRO((AA &a) { return 1; });\n" 10896 "}"); 10897 10898 verifyFormat("if (blah_blah(whatever, whatever, [] {\n" 10899 " doo_dah();\n" 10900 " doo_dah();\n" 10901 " })) {\n" 10902 "}"); 10903 verifyFormat("if constexpr (blah_blah(whatever, whatever, [] {\n" 10904 " doo_dah();\n" 10905 " doo_dah();\n" 10906 " })) {\n" 10907 "}"); 10908 verifyFormat("auto lambda = []() {\n" 10909 " int a = 2\n" 10910 "#if A\n" 10911 " + 2\n" 10912 "#endif\n" 10913 " ;\n" 10914 "};"); 10915 10916 // Lambdas with complex multiline introducers. 10917 verifyFormat( 10918 "aaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 10919 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]()\n" 10920 " -> ::std::unordered_set<\n" 10921 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> {\n" 10922 " //\n" 10923 " });"); 10924 } 10925 10926 TEST_F(FormatTest, FormatsBlocks) { 10927 FormatStyle ShortBlocks = getLLVMStyle(); 10928 ShortBlocks.AllowShortBlocksOnASingleLine = true; 10929 verifyFormat("int (^Block)(int, int);", ShortBlocks); 10930 verifyFormat("int (^Block1)(int, int) = ^(int i, int j)", ShortBlocks); 10931 verifyFormat("void (^block)(int) = ^(id test) { int i; };", ShortBlocks); 10932 verifyFormat("void (^block)(int) = ^(int test) { int i; };", ShortBlocks); 10933 verifyFormat("void (^block)(int) = ^id(int test) { int i; };", ShortBlocks); 10934 verifyFormat("void (^block)(int) = ^int(int test) { int i; };", ShortBlocks); 10935 10936 verifyFormat("foo(^{ bar(); });", ShortBlocks); 10937 verifyFormat("foo(a, ^{ bar(); });", ShortBlocks); 10938 verifyFormat("{ void (^block)(Object *x); }", ShortBlocks); 10939 10940 verifyFormat("[operation setCompletionBlock:^{\n" 10941 " [self onOperationDone];\n" 10942 "}];"); 10943 verifyFormat("int i = {[operation setCompletionBlock:^{\n" 10944 " [self onOperationDone];\n" 10945 "}]};"); 10946 verifyFormat("[operation setCompletionBlock:^(int *i) {\n" 10947 " f();\n" 10948 "}];"); 10949 verifyFormat("int a = [operation block:^int(int *i) {\n" 10950 " return 1;\n" 10951 "}];"); 10952 verifyFormat("[myObject doSomethingWith:arg1\n" 10953 " aaa:^int(int *a) {\n" 10954 " return 1;\n" 10955 " }\n" 10956 " bbb:f(a * bbbbbbbb)];"); 10957 10958 verifyFormat("[operation setCompletionBlock:^{\n" 10959 " [self.delegate newDataAvailable];\n" 10960 "}];", 10961 getLLVMStyleWithColumns(60)); 10962 verifyFormat("dispatch_async(_fileIOQueue, ^{\n" 10963 " NSString *path = [self sessionFilePath];\n" 10964 " if (path) {\n" 10965 " // ...\n" 10966 " }\n" 10967 "});"); 10968 verifyFormat("[[SessionService sharedService]\n" 10969 " loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 10970 " if (window) {\n" 10971 " [self windowDidLoad:window];\n" 10972 " } else {\n" 10973 " [self errorLoadingWindow];\n" 10974 " }\n" 10975 " }];"); 10976 verifyFormat("void (^largeBlock)(void) = ^{\n" 10977 " // ...\n" 10978 "};\n", 10979 getLLVMStyleWithColumns(40)); 10980 verifyFormat("[[SessionService sharedService]\n" 10981 " loadWindowWithCompletionBlock: //\n" 10982 " ^(SessionWindow *window) {\n" 10983 " if (window) {\n" 10984 " [self windowDidLoad:window];\n" 10985 " } else {\n" 10986 " [self errorLoadingWindow];\n" 10987 " }\n" 10988 " }];", 10989 getLLVMStyleWithColumns(60)); 10990 verifyFormat("[myObject doSomethingWith:arg1\n" 10991 " firstBlock:^(Foo *a) {\n" 10992 " // ...\n" 10993 " int i;\n" 10994 " }\n" 10995 " secondBlock:^(Bar *b) {\n" 10996 " // ...\n" 10997 " int i;\n" 10998 " }\n" 10999 " thirdBlock:^Foo(Bar *b) {\n" 11000 " // ...\n" 11001 " int i;\n" 11002 " }];"); 11003 verifyFormat("[myObject doSomethingWith:arg1\n" 11004 " firstBlock:-1\n" 11005 " secondBlock:^(Bar *b) {\n" 11006 " // ...\n" 11007 " int i;\n" 11008 " }];"); 11009 11010 verifyFormat("f(^{\n" 11011 " @autoreleasepool {\n" 11012 " if (a) {\n" 11013 " g();\n" 11014 " }\n" 11015 " }\n" 11016 "});"); 11017 verifyFormat("Block b = ^int *(A *a, B *b) {}"); 11018 verifyFormat("BOOL (^aaa)(void) = ^BOOL {\n" 11019 "};"); 11020 11021 FormatStyle FourIndent = getLLVMStyle(); 11022 FourIndent.ObjCBlockIndentWidth = 4; 11023 verifyFormat("[operation setCompletionBlock:^{\n" 11024 " [self onOperationDone];\n" 11025 "}];", 11026 FourIndent); 11027 } 11028 11029 TEST_F(FormatTest, FormatsBlocksWithZeroColumnWidth) { 11030 FormatStyle ZeroColumn = getLLVMStyle(); 11031 ZeroColumn.ColumnLimit = 0; 11032 11033 verifyFormat("[[SessionService sharedService] " 11034 "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 11035 " if (window) {\n" 11036 " [self windowDidLoad:window];\n" 11037 " } else {\n" 11038 " [self errorLoadingWindow];\n" 11039 " }\n" 11040 "}];", 11041 ZeroColumn); 11042 EXPECT_EQ("[[SessionService sharedService]\n" 11043 " loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 11044 " if (window) {\n" 11045 " [self windowDidLoad:window];\n" 11046 " } else {\n" 11047 " [self errorLoadingWindow];\n" 11048 " }\n" 11049 " }];", 11050 format("[[SessionService sharedService]\n" 11051 "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 11052 " if (window) {\n" 11053 " [self windowDidLoad:window];\n" 11054 " } else {\n" 11055 " [self errorLoadingWindow];\n" 11056 " }\n" 11057 "}];", 11058 ZeroColumn)); 11059 verifyFormat("[myObject doSomethingWith:arg1\n" 11060 " firstBlock:^(Foo *a) {\n" 11061 " // ...\n" 11062 " int i;\n" 11063 " }\n" 11064 " secondBlock:^(Bar *b) {\n" 11065 " // ...\n" 11066 " int i;\n" 11067 " }\n" 11068 " thirdBlock:^Foo(Bar *b) {\n" 11069 " // ...\n" 11070 " int i;\n" 11071 " }];", 11072 ZeroColumn); 11073 verifyFormat("f(^{\n" 11074 " @autoreleasepool {\n" 11075 " if (a) {\n" 11076 " g();\n" 11077 " }\n" 11078 " }\n" 11079 "});", 11080 ZeroColumn); 11081 verifyFormat("void (^largeBlock)(void) = ^{\n" 11082 " // ...\n" 11083 "};", 11084 ZeroColumn); 11085 11086 ZeroColumn.AllowShortBlocksOnASingleLine = true; 11087 EXPECT_EQ("void (^largeBlock)(void) = ^{ int i; };", 11088 format("void (^largeBlock)(void) = ^{ int i; };", ZeroColumn)); 11089 ZeroColumn.AllowShortBlocksOnASingleLine = false; 11090 EXPECT_EQ("void (^largeBlock)(void) = ^{\n" 11091 " int i;\n" 11092 "};", 11093 format("void (^largeBlock)(void) = ^{ int i; };", ZeroColumn)); 11094 } 11095 11096 TEST_F(FormatTest, SupportsCRLF) { 11097 EXPECT_EQ("int a;\r\n" 11098 "int b;\r\n" 11099 "int c;\r\n", 11100 format("int a;\r\n" 11101 " int b;\r\n" 11102 " int c;\r\n", 11103 getLLVMStyle())); 11104 EXPECT_EQ("int a;\r\n" 11105 "int b;\r\n" 11106 "int c;\r\n", 11107 format("int a;\r\n" 11108 " int b;\n" 11109 " int c;\r\n", 11110 getLLVMStyle())); 11111 EXPECT_EQ("int a;\n" 11112 "int b;\n" 11113 "int c;\n", 11114 format("int a;\r\n" 11115 " int b;\n" 11116 " int c;\n", 11117 getLLVMStyle())); 11118 EXPECT_EQ("\"aaaaaaa \"\r\n" 11119 "\"bbbbbbb\";\r\n", 11120 format("\"aaaaaaa bbbbbbb\";\r\n", getLLVMStyleWithColumns(10))); 11121 EXPECT_EQ("#define A \\\r\n" 11122 " b; \\\r\n" 11123 " c; \\\r\n" 11124 " d;\r\n", 11125 format("#define A \\\r\n" 11126 " b; \\\r\n" 11127 " c; d; \r\n", 11128 getGoogleStyle())); 11129 11130 EXPECT_EQ("/*\r\n" 11131 "multi line block comments\r\n" 11132 "should not introduce\r\n" 11133 "an extra carriage return\r\n" 11134 "*/\r\n", 11135 format("/*\r\n" 11136 "multi line block comments\r\n" 11137 "should not introduce\r\n" 11138 "an extra carriage return\r\n" 11139 "*/\r\n")); 11140 } 11141 11142 TEST_F(FormatTest, MunchSemicolonAfterBlocks) { 11143 verifyFormat("MY_CLASS(C) {\n" 11144 " int i;\n" 11145 " int j;\n" 11146 "};"); 11147 } 11148 11149 TEST_F(FormatTest, ConfigurableContinuationIndentWidth) { 11150 FormatStyle TwoIndent = getLLVMStyleWithColumns(15); 11151 TwoIndent.ContinuationIndentWidth = 2; 11152 11153 EXPECT_EQ("int i =\n" 11154 " longFunction(\n" 11155 " arg);", 11156 format("int i = longFunction(arg);", TwoIndent)); 11157 11158 FormatStyle SixIndent = getLLVMStyleWithColumns(20); 11159 SixIndent.ContinuationIndentWidth = 6; 11160 11161 EXPECT_EQ("int i =\n" 11162 " longFunction(\n" 11163 " arg);", 11164 format("int i = longFunction(arg);", SixIndent)); 11165 } 11166 11167 TEST_F(FormatTest, SpacesInAngles) { 11168 FormatStyle Spaces = getLLVMStyle(); 11169 Spaces.SpacesInAngles = true; 11170 11171 verifyFormat("static_cast< int >(arg);", Spaces); 11172 verifyFormat("template < typename T0, typename T1 > void f() {}", Spaces); 11173 verifyFormat("f< int, float >();", Spaces); 11174 verifyFormat("template <> g() {}", Spaces); 11175 verifyFormat("template < std::vector< int > > f() {}", Spaces); 11176 verifyFormat("std::function< void(int, int) > fct;", Spaces); 11177 verifyFormat("void inFunction() { std::function< void(int, int) > fct; }", 11178 Spaces); 11179 11180 Spaces.Standard = FormatStyle::LS_Cpp03; 11181 Spaces.SpacesInAngles = true; 11182 verifyFormat("A< A< int > >();", Spaces); 11183 11184 Spaces.SpacesInAngles = false; 11185 verifyFormat("A<A<int> >();", Spaces); 11186 11187 Spaces.Standard = FormatStyle::LS_Cpp11; 11188 Spaces.SpacesInAngles = true; 11189 verifyFormat("A< A< int > >();", Spaces); 11190 11191 Spaces.SpacesInAngles = false; 11192 verifyFormat("A<A<int>>();", Spaces); 11193 } 11194 11195 TEST_F(FormatTest, SpaceAfterTemplateKeyword) { 11196 FormatStyle Style = getLLVMStyle(); 11197 Style.SpaceAfterTemplateKeyword = false; 11198 verifyFormat("template<int> void foo();", Style); 11199 } 11200 11201 TEST_F(FormatTest, TripleAngleBrackets) { 11202 verifyFormat("f<<<1, 1>>>();"); 11203 verifyFormat("f<<<1, 1, 1, s>>>();"); 11204 verifyFormat("f<<<a, b, c, d>>>();"); 11205 EXPECT_EQ("f<<<1, 1>>>();", format("f <<< 1, 1 >>> ();")); 11206 verifyFormat("f<param><<<1, 1>>>();"); 11207 verifyFormat("f<1><<<1, 1>>>();"); 11208 EXPECT_EQ("f<param><<<1, 1>>>();", format("f< param > <<< 1, 1 >>> ();")); 11209 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 11210 "aaaaaaaaaaa<<<\n 1, 1>>>();"); 11211 verifyFormat("aaaaaaaaaaaaaaa<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaa>\n" 11212 " <<<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaaaaaa>>>();"); 11213 } 11214 11215 TEST_F(FormatTest, MergeLessLessAtEnd) { 11216 verifyFormat("<<"); 11217 EXPECT_EQ("< < <", format("\\\n<<<")); 11218 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 11219 "aaallvm::outs() <<"); 11220 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 11221 "aaaallvm::outs()\n <<"); 11222 } 11223 11224 TEST_F(FormatTest, HandleUnbalancedImplicitBracesAcrossPPBranches) { 11225 std::string code = "#if A\n" 11226 "#if B\n" 11227 "a.\n" 11228 "#endif\n" 11229 " a = 1;\n" 11230 "#else\n" 11231 "#endif\n" 11232 "#if C\n" 11233 "#else\n" 11234 "#endif\n"; 11235 EXPECT_EQ(code, format(code)); 11236 } 11237 11238 TEST_F(FormatTest, HandleConflictMarkers) { 11239 // Git/SVN conflict markers. 11240 EXPECT_EQ("int a;\n" 11241 "void f() {\n" 11242 " callme(some(parameter1,\n" 11243 "<<<<<<< text by the vcs\n" 11244 " parameter2),\n" 11245 "||||||| text by the vcs\n" 11246 " parameter2),\n" 11247 " parameter3,\n" 11248 "======= text by the vcs\n" 11249 " parameter2, parameter3),\n" 11250 ">>>>>>> text by the vcs\n" 11251 " otherparameter);\n", 11252 format("int a;\n" 11253 "void f() {\n" 11254 " callme(some(parameter1,\n" 11255 "<<<<<<< text by the vcs\n" 11256 " parameter2),\n" 11257 "||||||| text by the vcs\n" 11258 " parameter2),\n" 11259 " parameter3,\n" 11260 "======= text by the vcs\n" 11261 " parameter2,\n" 11262 " parameter3),\n" 11263 ">>>>>>> text by the vcs\n" 11264 " otherparameter);\n")); 11265 11266 // Perforce markers. 11267 EXPECT_EQ("void f() {\n" 11268 " function(\n" 11269 ">>>> text by the vcs\n" 11270 " parameter,\n" 11271 "==== text by the vcs\n" 11272 " parameter,\n" 11273 "==== text by the vcs\n" 11274 " parameter,\n" 11275 "<<<< text by the vcs\n" 11276 " parameter);\n", 11277 format("void f() {\n" 11278 " function(\n" 11279 ">>>> text by the vcs\n" 11280 " parameter,\n" 11281 "==== text by the vcs\n" 11282 " parameter,\n" 11283 "==== text by the vcs\n" 11284 " parameter,\n" 11285 "<<<< text by the vcs\n" 11286 " parameter);\n")); 11287 11288 EXPECT_EQ("<<<<<<<\n" 11289 "|||||||\n" 11290 "=======\n" 11291 ">>>>>>>", 11292 format("<<<<<<<\n" 11293 "|||||||\n" 11294 "=======\n" 11295 ">>>>>>>")); 11296 11297 EXPECT_EQ("<<<<<<<\n" 11298 "|||||||\n" 11299 "int i;\n" 11300 "=======\n" 11301 ">>>>>>>", 11302 format("<<<<<<<\n" 11303 "|||||||\n" 11304 "int i;\n" 11305 "=======\n" 11306 ">>>>>>>")); 11307 11308 // FIXME: Handle parsing of macros around conflict markers correctly: 11309 EXPECT_EQ("#define Macro \\\n" 11310 "<<<<<<<\n" 11311 "Something \\\n" 11312 "|||||||\n" 11313 "Else \\\n" 11314 "=======\n" 11315 "Other \\\n" 11316 ">>>>>>>\n" 11317 " End int i;\n", 11318 format("#define Macro \\\n" 11319 "<<<<<<<\n" 11320 " Something \\\n" 11321 "|||||||\n" 11322 " Else \\\n" 11323 "=======\n" 11324 " Other \\\n" 11325 ">>>>>>>\n" 11326 " End\n" 11327 "int i;\n")); 11328 } 11329 11330 TEST_F(FormatTest, DisableRegions) { 11331 EXPECT_EQ("int i;\n" 11332 "// clang-format off\n" 11333 " int j;\n" 11334 "// clang-format on\n" 11335 "int k;", 11336 format(" int i;\n" 11337 " // clang-format off\n" 11338 " int j;\n" 11339 " // clang-format on\n" 11340 " int k;")); 11341 EXPECT_EQ("int i;\n" 11342 "/* clang-format off */\n" 11343 " int j;\n" 11344 "/* clang-format on */\n" 11345 "int k;", 11346 format(" int i;\n" 11347 " /* clang-format off */\n" 11348 " int j;\n" 11349 " /* clang-format on */\n" 11350 " int k;")); 11351 11352 // Don't reflow comments within disabled regions. 11353 EXPECT_EQ( 11354 "// clang-format off\n" 11355 "// long long long long long long line\n" 11356 "/* clang-format on */\n" 11357 "/* long long long\n" 11358 " * long long long\n" 11359 " * line */\n" 11360 "int i;\n" 11361 "/* clang-format off */\n" 11362 "/* long long long long long long line */\n", 11363 format("// clang-format off\n" 11364 "// long long long long long long line\n" 11365 "/* clang-format on */\n" 11366 "/* long long long long long long line */\n" 11367 "int i;\n" 11368 "/* clang-format off */\n" 11369 "/* long long long long long long line */\n", 11370 getLLVMStyleWithColumns(20))); 11371 } 11372 11373 TEST_F(FormatTest, DoNotCrashOnInvalidInput) { 11374 format("? ) ="); 11375 verifyNoCrash("#define a\\\n /**/}"); 11376 } 11377 11378 TEST_F(FormatTest, FormatsTableGenCode) { 11379 FormatStyle Style = getLLVMStyle(); 11380 Style.Language = FormatStyle::LK_TableGen; 11381 verifyFormat("include \"a.td\"\ninclude \"b.td\"", Style); 11382 } 11383 11384 TEST_F(FormatTest, ArrayOfTemplates) { 11385 EXPECT_EQ("auto a = new unique_ptr<int>[10];", 11386 format("auto a = new unique_ptr<int > [ 10];")); 11387 11388 FormatStyle Spaces = getLLVMStyle(); 11389 Spaces.SpacesInSquareBrackets = true; 11390 EXPECT_EQ("auto a = new unique_ptr<int>[ 10 ];", 11391 format("auto a = new unique_ptr<int > [10];", Spaces)); 11392 } 11393 11394 TEST_F(FormatTest, ArrayAsTemplateType) { 11395 EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[10]>;", 11396 format("auto a = unique_ptr < Foo < Bar>[ 10]> ;")); 11397 11398 FormatStyle Spaces = getLLVMStyle(); 11399 Spaces.SpacesInSquareBrackets = true; 11400 EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[ 10 ]>;", 11401 format("auto a = unique_ptr < Foo < Bar>[10]> ;", Spaces)); 11402 } 11403 11404 TEST_F(FormatTest, NoSpaceAfterSuper) { 11405 verifyFormat("__super::FooBar();"); 11406 } 11407 11408 TEST(FormatStyle, GetStyleOfFile) { 11409 vfs::InMemoryFileSystem FS; 11410 // Test 1: format file in the same directory. 11411 ASSERT_TRUE( 11412 FS.addFile("/a/.clang-format", 0, 11413 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM"))); 11414 ASSERT_TRUE( 11415 FS.addFile("/a/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;"))); 11416 auto Style1 = getStyle("file", "/a/.clang-format", "Google", "", &FS); 11417 ASSERT_TRUE((bool)Style1); 11418 ASSERT_EQ(*Style1, getLLVMStyle()); 11419 11420 // Test 2.1: fallback to default. 11421 ASSERT_TRUE( 11422 FS.addFile("/b/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;"))); 11423 auto Style2 = getStyle("file", "/b/test.cpp", "Mozilla", "", &FS); 11424 ASSERT_TRUE((bool)Style2); 11425 ASSERT_EQ(*Style2, getMozillaStyle()); 11426 11427 // Test 2.2: no format on 'none' fallback style. 11428 Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS); 11429 ASSERT_TRUE((bool)Style2); 11430 ASSERT_EQ(*Style2, getNoStyle()); 11431 11432 // Test 2.3: format if config is found with no based style while fallback is 11433 // 'none'. 11434 ASSERT_TRUE(FS.addFile("/b/.clang-format", 0, 11435 llvm::MemoryBuffer::getMemBuffer("IndentWidth: 2"))); 11436 Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS); 11437 ASSERT_TRUE((bool)Style2); 11438 ASSERT_EQ(*Style2, getLLVMStyle()); 11439 11440 // Test 2.4: format if yaml with no based style, while fallback is 'none'. 11441 Style2 = getStyle("{}", "a.h", "none", "", &FS); 11442 ASSERT_TRUE((bool)Style2); 11443 ASSERT_EQ(*Style2, getLLVMStyle()); 11444 11445 // Test 3: format file in parent directory. 11446 ASSERT_TRUE( 11447 FS.addFile("/c/.clang-format", 0, 11448 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: Google"))); 11449 ASSERT_TRUE(FS.addFile("/c/sub/sub/sub/test.cpp", 0, 11450 llvm::MemoryBuffer::getMemBuffer("int i;"))); 11451 auto Style3 = getStyle("file", "/c/sub/sub/sub/test.cpp", "LLVM", "", &FS); 11452 ASSERT_TRUE((bool)Style3); 11453 ASSERT_EQ(*Style3, getGoogleStyle()); 11454 11455 // Test 4: error on invalid fallback style 11456 auto Style4 = getStyle("file", "a.h", "KungFu", "", &FS); 11457 ASSERT_FALSE((bool)Style4); 11458 llvm::consumeError(Style4.takeError()); 11459 11460 // Test 5: error on invalid yaml on command line 11461 auto Style5 = getStyle("{invalid_key=invalid_value}", "a.h", "LLVM", "", &FS); 11462 ASSERT_FALSE((bool)Style5); 11463 llvm::consumeError(Style5.takeError()); 11464 11465 // Test 6: error on invalid style 11466 auto Style6 = getStyle("KungFu", "a.h", "LLVM", "", &FS); 11467 ASSERT_FALSE((bool)Style6); 11468 llvm::consumeError(Style6.takeError()); 11469 11470 // Test 7: found config file, error on parsing it 11471 ASSERT_TRUE( 11472 FS.addFile("/d/.clang-format", 0, 11473 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM\n" 11474 "InvalidKey: InvalidValue"))); 11475 ASSERT_TRUE( 11476 FS.addFile("/d/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;"))); 11477 auto Style7 = getStyle("file", "/d/.clang-format", "LLVM", "", &FS); 11478 ASSERT_FALSE((bool)Style7); 11479 llvm::consumeError(Style7.takeError()); 11480 } 11481 11482 TEST_F(ReplacementTest, FormatCodeAfterReplacements) { 11483 // Column limit is 20. 11484 std::string Code = "Type *a =\n" 11485 " new Type();\n" 11486 "g(iiiii, 0, jjjjj,\n" 11487 " 0, kkkkk, 0, mm);\n" 11488 "int bad = format ;"; 11489 std::string Expected = "auto a = new Type();\n" 11490 "g(iiiii, nullptr,\n" 11491 " jjjjj, nullptr,\n" 11492 " kkkkk, nullptr,\n" 11493 " mm);\n" 11494 "int bad = format ;"; 11495 FileID ID = Context.createInMemoryFile("format.cpp", Code); 11496 tooling::Replacements Replaces = toReplacements( 11497 {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 6, 11498 "auto "), 11499 tooling::Replacement(Context.Sources, Context.getLocation(ID, 3, 10), 1, 11500 "nullptr"), 11501 tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 3), 1, 11502 "nullptr"), 11503 tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 13), 1, 11504 "nullptr")}); 11505 11506 format::FormatStyle Style = format::getLLVMStyle(); 11507 Style.ColumnLimit = 20; // Set column limit to 20 to increase readibility. 11508 auto FormattedReplaces = formatReplacements(Code, Replaces, Style); 11509 EXPECT_TRUE(static_cast<bool>(FormattedReplaces)) 11510 << llvm::toString(FormattedReplaces.takeError()) << "\n"; 11511 auto Result = applyAllReplacements(Code, *FormattedReplaces); 11512 EXPECT_TRUE(static_cast<bool>(Result)); 11513 EXPECT_EQ(Expected, *Result); 11514 } 11515 11516 TEST_F(ReplacementTest, SortIncludesAfterReplacement) { 11517 std::string Code = "#include \"a.h\"\n" 11518 "#include \"c.h\"\n" 11519 "\n" 11520 "int main() {\n" 11521 " return 0;\n" 11522 "}"; 11523 std::string Expected = "#include \"a.h\"\n" 11524 "#include \"b.h\"\n" 11525 "#include \"c.h\"\n" 11526 "\n" 11527 "int main() {\n" 11528 " return 0;\n" 11529 "}"; 11530 FileID ID = Context.createInMemoryFile("fix.cpp", Code); 11531 tooling::Replacements Replaces = toReplacements( 11532 {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 0, 11533 "#include \"b.h\"\n")}); 11534 11535 format::FormatStyle Style = format::getLLVMStyle(); 11536 Style.SortIncludes = true; 11537 auto FormattedReplaces = formatReplacements(Code, Replaces, Style); 11538 EXPECT_TRUE(static_cast<bool>(FormattedReplaces)) 11539 << llvm::toString(FormattedReplaces.takeError()) << "\n"; 11540 auto Result = applyAllReplacements(Code, *FormattedReplaces); 11541 EXPECT_TRUE(static_cast<bool>(Result)); 11542 EXPECT_EQ(Expected, *Result); 11543 } 11544 11545 TEST_F(FormatTest, FormatSortsUsingDeclarations) { 11546 EXPECT_EQ("using std::cin;\n" 11547 "using std::cout;", 11548 format("using std::cout;\n" 11549 "using std::cin;", getGoogleStyle())); 11550 } 11551 11552 TEST_F(FormatTest, UTF8CharacterLiteralCpp03) { 11553 format::FormatStyle Style = format::getLLVMStyle(); 11554 Style.Standard = FormatStyle::LS_Cpp03; 11555 // cpp03 recognize this string as identifier u8 and literal character 'a' 11556 EXPECT_EQ("auto c = u8 'a';", format("auto c = u8'a';", Style)); 11557 } 11558 11559 TEST_F(FormatTest, UTF8CharacterLiteralCpp11) { 11560 // u8'a' is a C++17 feature, utf8 literal character, LS_Cpp11 covers 11561 // all modes, including C++11, C++14 and C++17 11562 EXPECT_EQ("auto c = u8'a';", format("auto c = u8'a';")); 11563 } 11564 11565 TEST_F(FormatTest, DoNotFormatLikelyXml) { 11566 EXPECT_EQ("<!-- ;> -->", 11567 format("<!-- ;> -->", getGoogleStyle())); 11568 EXPECT_EQ(" <!-- >; -->", 11569 format(" <!-- >; -->", getGoogleStyle())); 11570 } 11571 11572 TEST_F(FormatTest, StructuredBindings) { 11573 // Structured bindings is a C++17 feature. 11574 // all modes, including C++11, C++14 and C++17 11575 verifyFormat("auto [a, b] = f();"); 11576 EXPECT_EQ("auto [a, b] = f();", format("auto[a, b] = f();")); 11577 EXPECT_EQ("const auto [a, b] = f();", format("const auto[a, b] = f();")); 11578 EXPECT_EQ("auto const [a, b] = f();", format("auto const[a, b] = f();")); 11579 EXPECT_EQ("auto const volatile [a, b] = f();", 11580 format("auto const volatile[a, b] = f();")); 11581 EXPECT_EQ("auto [a, b, c] = f();", format("auto [ a , b,c ] = f();")); 11582 EXPECT_EQ("auto & [a, b, c] = f();", 11583 format("auto &[ a , b,c ] = f();")); 11584 EXPECT_EQ("auto && [a, b, c] = f();", 11585 format("auto &&[ a , b,c ] = f();")); 11586 EXPECT_EQ("auto const & [a, b] = f();", format("auto const&[a, b] = f();")); 11587 EXPECT_EQ("auto const volatile && [a, b] = f();", 11588 format("auto const volatile &&[a, b] = f();")); 11589 EXPECT_EQ("auto && [a, b] = f();", format("auto &&[a, b] = f();")); 11590 11591 format::FormatStyle Spaces = format::getLLVMStyle(); 11592 Spaces.SpacesInSquareBrackets = true; 11593 verifyFormat("auto [ a, b ] = f();", Spaces); 11594 verifyFormat("auto && [ a, b ] = f();", Spaces); 11595 } 11596 11597 } // end namespace 11598 } // end namespace format 11599 } // end namespace clang 11600