1 //===- unittest/Format/FormatTest.cpp - Formatting unit tests -------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "clang/Format/Format.h" 10 11 #include "../Tooling/ReplacementTest.h" 12 #include "FormatTestUtils.h" 13 14 #include "clang/Frontend/TextDiagnosticPrinter.h" 15 #include "llvm/Support/Debug.h" 16 #include "llvm/Support/MemoryBuffer.h" 17 #include "gtest/gtest.h" 18 19 #define DEBUG_TYPE "format-test" 20 21 using clang::tooling::ReplacementTest; 22 using clang::tooling::toReplacements; 23 24 namespace clang { 25 namespace format { 26 namespace { 27 28 FormatStyle getGoogleStyle() { return getGoogleStyle(FormatStyle::LK_Cpp); } 29 30 class FormatTest : public ::testing::Test { 31 protected: 32 enum StatusCheck { 33 SC_ExpectComplete, 34 SC_ExpectIncomplete, 35 SC_DoNotCheck 36 }; 37 38 std::string format(llvm::StringRef Code, 39 const FormatStyle &Style = getLLVMStyle(), 40 StatusCheck CheckComplete = SC_ExpectComplete) { 41 LLVM_DEBUG(llvm::errs() << "---\n"); 42 LLVM_DEBUG(llvm::errs() << Code << "\n\n"); 43 std::vector<tooling::Range> Ranges(1, tooling::Range(0, Code.size())); 44 FormattingAttemptStatus Status; 45 tooling::Replacements Replaces = 46 reformat(Style, Code, Ranges, "<stdin>", &Status); 47 if (CheckComplete != SC_DoNotCheck) { 48 bool ExpectedCompleteFormat = CheckComplete == SC_ExpectComplete; 49 EXPECT_EQ(ExpectedCompleteFormat, Status.FormatComplete) 50 << Code << "\n\n"; 51 } 52 ReplacementCount = Replaces.size(); 53 auto Result = applyAllReplacements(Code, Replaces); 54 EXPECT_TRUE(static_cast<bool>(Result)); 55 LLVM_DEBUG(llvm::errs() << "\n" << *Result << "\n\n"); 56 return *Result; 57 } 58 59 FormatStyle getStyleWithColumns(FormatStyle Style, unsigned ColumnLimit) { 60 Style.ColumnLimit = ColumnLimit; 61 return Style; 62 } 63 64 FormatStyle getLLVMStyleWithColumns(unsigned ColumnLimit) { 65 return getStyleWithColumns(getLLVMStyle(), ColumnLimit); 66 } 67 68 FormatStyle getGoogleStyleWithColumns(unsigned ColumnLimit) { 69 return getStyleWithColumns(getGoogleStyle(), ColumnLimit); 70 } 71 72 void verifyFormat(llvm::StringRef Expected, llvm::StringRef Code, 73 const FormatStyle &Style = getLLVMStyle()) { 74 EXPECT_EQ(Expected.str(), format(Expected, Style)) 75 << "Expected code is not stable"; 76 EXPECT_EQ(Expected.str(), format(Code, Style)); 77 if (Style.Language == FormatStyle::LK_Cpp) { 78 // Objective-C++ is a superset of C++, so everything checked for C++ 79 // needs to be checked for Objective-C++ as well. 80 FormatStyle ObjCStyle = Style; 81 ObjCStyle.Language = FormatStyle::LK_ObjC; 82 EXPECT_EQ(Expected.str(), format(test::messUp(Code), ObjCStyle)); 83 } 84 } 85 86 void verifyFormat(llvm::StringRef Code, 87 const FormatStyle &Style = getLLVMStyle()) { 88 verifyFormat(Code, test::messUp(Code), Style); 89 } 90 91 void verifyIncompleteFormat(llvm::StringRef Code, 92 const FormatStyle &Style = getLLVMStyle()) { 93 EXPECT_EQ(Code.str(), 94 format(test::messUp(Code), Style, SC_ExpectIncomplete)); 95 } 96 97 void verifyGoogleFormat(llvm::StringRef Code) { 98 verifyFormat(Code, getGoogleStyle()); 99 } 100 101 void verifyIndependentOfContext(llvm::StringRef text) { 102 verifyFormat(text); 103 verifyFormat(llvm::Twine("void f() { " + text + " }").str()); 104 } 105 106 /// \brief Verify that clang-format does not crash on the given input. 107 void verifyNoCrash(llvm::StringRef Code, 108 const FormatStyle &Style = getLLVMStyle()) { 109 format(Code, Style, SC_DoNotCheck); 110 } 111 112 int ReplacementCount; 113 }; 114 115 TEST_F(FormatTest, MessUp) { 116 EXPECT_EQ("1 2 3", test::messUp("1 2 3")); 117 EXPECT_EQ("1 2 3\n", test::messUp("1\n2\n3\n")); 118 EXPECT_EQ("a\n//b\nc", test::messUp("a\n//b\nc")); 119 EXPECT_EQ("a\n#b\nc", test::messUp("a\n#b\nc")); 120 EXPECT_EQ("a\n#b c d\ne", test::messUp("a\n#b\\\nc\\\nd\ne")); 121 } 122 123 TEST_F(FormatTest, DefaultLLVMStyleIsCpp) { 124 EXPECT_EQ(FormatStyle::LK_Cpp, getLLVMStyle().Language); 125 } 126 127 TEST_F(FormatTest, LLVMStyleOverride) { 128 EXPECT_EQ(FormatStyle::LK_Proto, 129 getLLVMStyle(FormatStyle::LK_Proto).Language); 130 } 131 132 //===----------------------------------------------------------------------===// 133 // Basic function tests. 134 //===----------------------------------------------------------------------===// 135 136 TEST_F(FormatTest, DoesNotChangeCorrectlyFormattedCode) { 137 EXPECT_EQ(";", format(";")); 138 } 139 140 TEST_F(FormatTest, FormatsGlobalStatementsAt0) { 141 EXPECT_EQ("int i;", format(" int i;")); 142 EXPECT_EQ("\nint i;", format(" \n\t \v \f int i;")); 143 EXPECT_EQ("int i;\nint j;", format(" int i; int j;")); 144 EXPECT_EQ("int i;\nint j;", format(" int i;\n int j;")); 145 } 146 147 TEST_F(FormatTest, FormatsUnwrappedLinesAtFirstFormat) { 148 EXPECT_EQ("int i;", format("int\ni;")); 149 } 150 151 TEST_F(FormatTest, FormatsNestedBlockStatements) { 152 EXPECT_EQ("{\n {\n {}\n }\n}", format("{{{}}}")); 153 } 154 155 TEST_F(FormatTest, FormatsNestedCall) { 156 verifyFormat("Method(f1, f2(f3));"); 157 verifyFormat("Method(f1(f2, f3()));"); 158 verifyFormat("Method(f1(f2, (f3())));"); 159 } 160 161 TEST_F(FormatTest, NestedNameSpecifiers) { 162 verifyFormat("vector<::Type> v;"); 163 verifyFormat("::ns::SomeFunction(::ns::SomeOtherFunction())"); 164 verifyFormat("static constexpr bool Bar = decltype(bar())::value;"); 165 verifyFormat("bool a = 2 < ::SomeFunction();"); 166 verifyFormat("ALWAYS_INLINE ::std::string getName();"); 167 verifyFormat("some::string getName();"); 168 } 169 170 TEST_F(FormatTest, OnlyGeneratesNecessaryReplacements) { 171 EXPECT_EQ("if (a) {\n" 172 " f();\n" 173 "}", 174 format("if(a){f();}")); 175 EXPECT_EQ(4, ReplacementCount); 176 EXPECT_EQ("if (a) {\n" 177 " f();\n" 178 "}", 179 format("if (a) {\n" 180 " f();\n" 181 "}")); 182 EXPECT_EQ(0, ReplacementCount); 183 EXPECT_EQ("/*\r\n" 184 "\r\n" 185 "*/\r\n", 186 format("/*\r\n" 187 "\r\n" 188 "*/\r\n")); 189 EXPECT_EQ(0, ReplacementCount); 190 } 191 192 TEST_F(FormatTest, RemovesEmptyLines) { 193 EXPECT_EQ("class C {\n" 194 " int i;\n" 195 "};", 196 format("class C {\n" 197 " int i;\n" 198 "\n" 199 "};")); 200 201 // Don't remove empty lines at the start of namespaces or extern "C" blocks. 202 EXPECT_EQ("namespace N {\n" 203 "\n" 204 "int i;\n" 205 "}", 206 format("namespace N {\n" 207 "\n" 208 "int i;\n" 209 "}", 210 getGoogleStyle())); 211 EXPECT_EQ("/* something */ namespace N {\n" 212 "\n" 213 "int i;\n" 214 "}", 215 format("/* something */ namespace N {\n" 216 "\n" 217 "int i;\n" 218 "}", 219 getGoogleStyle())); 220 EXPECT_EQ("inline namespace N {\n" 221 "\n" 222 "int i;\n" 223 "}", 224 format("inline namespace N {\n" 225 "\n" 226 "int i;\n" 227 "}", 228 getGoogleStyle())); 229 EXPECT_EQ("/* something */ inline namespace N {\n" 230 "\n" 231 "int i;\n" 232 "}", 233 format("/* something */ inline namespace N {\n" 234 "\n" 235 "int i;\n" 236 "}", 237 getGoogleStyle())); 238 EXPECT_EQ("export namespace N {\n" 239 "\n" 240 "int i;\n" 241 "}", 242 format("export namespace N {\n" 243 "\n" 244 "int i;\n" 245 "}", 246 getGoogleStyle())); 247 EXPECT_EQ("extern /**/ \"C\" /**/ {\n" 248 "\n" 249 "int i;\n" 250 "}", 251 format("extern /**/ \"C\" /**/ {\n" 252 "\n" 253 "int i;\n" 254 "}", 255 getGoogleStyle())); 256 257 // ...but do keep inlining and removing empty lines for non-block extern "C" 258 // functions. 259 verifyFormat("extern \"C\" int f() { return 42; }", getGoogleStyle()); 260 EXPECT_EQ("extern \"C\" int f() {\n" 261 " int i = 42;\n" 262 " return i;\n" 263 "}", 264 format("extern \"C\" int f() {\n" 265 "\n" 266 " int i = 42;\n" 267 " return i;\n" 268 "}", 269 getGoogleStyle())); 270 271 // Remove empty lines at the beginning and end of blocks. 272 EXPECT_EQ("void f() {\n" 273 "\n" 274 " if (a) {\n" 275 "\n" 276 " f();\n" 277 " }\n" 278 "}", 279 format("void f() {\n" 280 "\n" 281 " if (a) {\n" 282 "\n" 283 " f();\n" 284 "\n" 285 " }\n" 286 "\n" 287 "}", 288 getLLVMStyle())); 289 EXPECT_EQ("void f() {\n" 290 " if (a) {\n" 291 " f();\n" 292 " }\n" 293 "}", 294 format("void f() {\n" 295 "\n" 296 " if (a) {\n" 297 "\n" 298 " f();\n" 299 "\n" 300 " }\n" 301 "\n" 302 "}", 303 getGoogleStyle())); 304 305 // Don't remove empty lines in more complex control statements. 306 EXPECT_EQ("void f() {\n" 307 " if (a) {\n" 308 " f();\n" 309 "\n" 310 " } else if (b) {\n" 311 " f();\n" 312 " }\n" 313 "}", 314 format("void f() {\n" 315 " if (a) {\n" 316 " f();\n" 317 "\n" 318 " } else if (b) {\n" 319 " f();\n" 320 "\n" 321 " }\n" 322 "\n" 323 "}")); 324 325 // Don't remove empty lines before namespace endings. 326 FormatStyle LLVMWithNoNamespaceFix = getLLVMStyle(); 327 LLVMWithNoNamespaceFix.FixNamespaceComments = false; 328 EXPECT_EQ("namespace {\n" 329 "int i;\n" 330 "\n" 331 "}", 332 format("namespace {\n" 333 "int i;\n" 334 "\n" 335 "}", LLVMWithNoNamespaceFix)); 336 EXPECT_EQ("namespace {\n" 337 "int i;\n" 338 "}", 339 format("namespace {\n" 340 "int i;\n" 341 "}", LLVMWithNoNamespaceFix)); 342 EXPECT_EQ("namespace {\n" 343 "int i;\n" 344 "\n" 345 "};", 346 format("namespace {\n" 347 "int i;\n" 348 "\n" 349 "};", LLVMWithNoNamespaceFix)); 350 EXPECT_EQ("namespace {\n" 351 "int i;\n" 352 "};", 353 format("namespace {\n" 354 "int i;\n" 355 "};", LLVMWithNoNamespaceFix)); 356 EXPECT_EQ("namespace {\n" 357 "int i;\n" 358 "\n" 359 "}", 360 format("namespace {\n" 361 "int i;\n" 362 "\n" 363 "}")); 364 EXPECT_EQ("namespace {\n" 365 "int i;\n" 366 "\n" 367 "} // namespace", 368 format("namespace {\n" 369 "int i;\n" 370 "\n" 371 "} // namespace")); 372 373 FormatStyle Style = getLLVMStyle(); 374 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 375 Style.MaxEmptyLinesToKeep = 2; 376 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 377 Style.BraceWrapping.AfterClass = true; 378 Style.BraceWrapping.AfterFunction = true; 379 Style.KeepEmptyLinesAtTheStartOfBlocks = false; 380 381 EXPECT_EQ("class Foo\n" 382 "{\n" 383 " Foo() {}\n" 384 "\n" 385 " void funk() {}\n" 386 "};", 387 format("class Foo\n" 388 "{\n" 389 " Foo()\n" 390 " {\n" 391 " }\n" 392 "\n" 393 " void funk() {}\n" 394 "};", 395 Style)); 396 } 397 398 TEST_F(FormatTest, RecognizesBinaryOperatorKeywords) { 399 verifyFormat("x = (a) and (b);"); 400 verifyFormat("x = (a) or (b);"); 401 verifyFormat("x = (a) bitand (b);"); 402 verifyFormat("x = (a) bitor (b);"); 403 verifyFormat("x = (a) not_eq (b);"); 404 verifyFormat("x = (a) and_eq (b);"); 405 verifyFormat("x = (a) or_eq (b);"); 406 verifyFormat("x = (a) xor (b);"); 407 } 408 409 TEST_F(FormatTest, RecognizesUnaryOperatorKeywords) { 410 verifyFormat("x = compl(a);"); 411 verifyFormat("x = not(a);"); 412 verifyFormat("x = bitand(a);"); 413 // Unary operator must not be merged with the next identifier 414 verifyFormat("x = compl a;"); 415 verifyFormat("x = not a;"); 416 verifyFormat("x = bitand a;"); 417 } 418 419 //===----------------------------------------------------------------------===// 420 // Tests for control statements. 421 //===----------------------------------------------------------------------===// 422 423 TEST_F(FormatTest, FormatIfWithoutCompoundStatement) { 424 verifyFormat("if (true)\n f();\ng();"); 425 verifyFormat("if (a)\n if (b)\n if (c)\n g();\nh();"); 426 verifyFormat("if (a)\n if (b) {\n f();\n }\ng();"); 427 verifyFormat("if constexpr (true)\n" 428 " f();\ng();"); 429 verifyFormat("if CONSTEXPR (true)\n" 430 " f();\ng();"); 431 verifyFormat("if constexpr (a)\n" 432 " if constexpr (b)\n" 433 " if constexpr (c)\n" 434 " g();\n" 435 "h();"); 436 verifyFormat("if CONSTEXPR (a)\n" 437 " if CONSTEXPR (b)\n" 438 " if CONSTEXPR (c)\n" 439 " g();\n" 440 "h();"); 441 verifyFormat("if constexpr (a)\n" 442 " if constexpr (b) {\n" 443 " f();\n" 444 " }\n" 445 "g();"); 446 verifyFormat("if CONSTEXPR (a)\n" 447 " if CONSTEXPR (b) {\n" 448 " f();\n" 449 " }\n" 450 "g();"); 451 452 FormatStyle AllowsMergedIf = getLLVMStyle(); 453 AllowsMergedIf.AlignEscapedNewlines = FormatStyle::ENAS_Left; 454 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = 455 FormatStyle::SIS_WithoutElse; 456 verifyFormat("if (a)\n" 457 " // comment\n" 458 " f();", 459 AllowsMergedIf); 460 verifyFormat("{\n" 461 " if (a)\n" 462 " label:\n" 463 " f();\n" 464 "}", 465 AllowsMergedIf); 466 verifyFormat("#define A \\\n" 467 " if (a) \\\n" 468 " label: \\\n" 469 " f()", 470 AllowsMergedIf); 471 verifyFormat("if (a)\n" 472 " ;", 473 AllowsMergedIf); 474 verifyFormat("if (a)\n" 475 " if (b) return;", 476 AllowsMergedIf); 477 478 verifyFormat("if (a) // Can't merge this\n" 479 " f();\n", 480 AllowsMergedIf); 481 verifyFormat("if (a) /* still don't merge */\n" 482 " f();", 483 AllowsMergedIf); 484 verifyFormat("if (a) { // Never merge this\n" 485 " f();\n" 486 "}", 487 AllowsMergedIf); 488 verifyFormat("if (a) { /* Never merge this */\n" 489 " f();\n" 490 "}", 491 AllowsMergedIf); 492 493 AllowsMergedIf.ColumnLimit = 14; 494 verifyFormat("if (a) return;", AllowsMergedIf); 495 verifyFormat("if (aaaaaaaaa)\n" 496 " return;", 497 AllowsMergedIf); 498 499 AllowsMergedIf.ColumnLimit = 13; 500 verifyFormat("if (a)\n return;", AllowsMergedIf); 501 } 502 503 TEST_F(FormatTest, FormatIfWithoutCompoundStatementButElseWith) { 504 FormatStyle AllowsMergedIf = getLLVMStyle(); 505 AllowsMergedIf.AlignEscapedNewlines = FormatStyle::ENAS_Left; 506 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = 507 FormatStyle::SIS_WithoutElse; 508 verifyFormat("if (a)\n" 509 " f();\n" 510 "else {\n" 511 " g();\n" 512 "}", 513 AllowsMergedIf); 514 verifyFormat("if (a)\n" 515 " f();\n" 516 "else\n" 517 " g();\n", 518 AllowsMergedIf); 519 520 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Always; 521 522 verifyFormat("if (a) f();\n" 523 "else {\n" 524 " g();\n" 525 "}", 526 AllowsMergedIf); 527 verifyFormat("if (a) f();\n" 528 "else {\n" 529 " if (a) f();\n" 530 " else {\n" 531 " g();\n" 532 " }\n" 533 " g();\n" 534 "}", 535 AllowsMergedIf); 536 } 537 538 TEST_F(FormatTest, FormatLoopsWithoutCompoundStatement) { 539 FormatStyle AllowsMergedLoops = getLLVMStyle(); 540 AllowsMergedLoops.AllowShortLoopsOnASingleLine = true; 541 verifyFormat("while (true) continue;", AllowsMergedLoops); 542 verifyFormat("for (;;) continue;", AllowsMergedLoops); 543 verifyFormat("for (int &v : vec) v *= 2;", AllowsMergedLoops); 544 verifyFormat("while (true)\n" 545 " ;", 546 AllowsMergedLoops); 547 verifyFormat("for (;;)\n" 548 " ;", 549 AllowsMergedLoops); 550 verifyFormat("for (;;)\n" 551 " for (;;) continue;", 552 AllowsMergedLoops); 553 verifyFormat("for (;;) // Can't merge this\n" 554 " continue;", 555 AllowsMergedLoops); 556 verifyFormat("for (;;) /* still don't merge */\n" 557 " continue;", 558 AllowsMergedLoops); 559 } 560 561 TEST_F(FormatTest, FormatShortBracedStatements) { 562 FormatStyle AllowSimpleBracedStatements = getLLVMStyle(); 563 AllowSimpleBracedStatements.ColumnLimit = 40; 564 AllowSimpleBracedStatements.AllowShortBlocksOnASingleLine = 565 FormatStyle::SBS_Always; 566 567 AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = 568 FormatStyle::SIS_WithoutElse; 569 AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = true; 570 571 AllowSimpleBracedStatements.BreakBeforeBraces = FormatStyle::BS_Custom; 572 AllowSimpleBracedStatements.BraceWrapping.AfterFunction = true; 573 AllowSimpleBracedStatements.BraceWrapping.SplitEmptyRecord = false; 574 575 verifyFormat("if (true) {}", AllowSimpleBracedStatements); 576 verifyFormat("if constexpr (true) {}", AllowSimpleBracedStatements); 577 verifyFormat("if CONSTEXPR (true) {}", AllowSimpleBracedStatements); 578 verifyFormat("while (true) {}", AllowSimpleBracedStatements); 579 verifyFormat("for (;;) {}", AllowSimpleBracedStatements); 580 verifyFormat("if (true) { f(); }", AllowSimpleBracedStatements); 581 verifyFormat("if constexpr (true) { f(); }", AllowSimpleBracedStatements); 582 verifyFormat("if CONSTEXPR (true) { f(); }", AllowSimpleBracedStatements); 583 verifyFormat("while (true) { f(); }", AllowSimpleBracedStatements); 584 verifyFormat("for (;;) { f(); }", AllowSimpleBracedStatements); 585 verifyFormat("if (true) {\n" 586 " ffffffffffffffffffffffffffffffffffffffffffffffffffffff();\n" 587 "}", 588 AllowSimpleBracedStatements); 589 verifyFormat("if (true) { //\n" 590 " f();\n" 591 "}", 592 AllowSimpleBracedStatements); 593 verifyFormat("if (true) {\n" 594 " f();\n" 595 " f();\n" 596 "}", 597 AllowSimpleBracedStatements); 598 verifyFormat("if (true) {\n" 599 " f();\n" 600 "} else {\n" 601 " f();\n" 602 "}", 603 AllowSimpleBracedStatements); 604 605 verifyFormat("struct A2 {\n" 606 " int X;\n" 607 "};", 608 AllowSimpleBracedStatements); 609 verifyFormat("typedef struct A2 {\n" 610 " int X;\n" 611 "} A2_t;", 612 AllowSimpleBracedStatements); 613 verifyFormat("template <int> struct A2 {\n" 614 " struct B {};\n" 615 "};", 616 AllowSimpleBracedStatements); 617 618 AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = 619 FormatStyle::SIS_Never; 620 verifyFormat("if (true) {}", AllowSimpleBracedStatements); 621 verifyFormat("if (true) {\n" 622 " f();\n" 623 "}", 624 AllowSimpleBracedStatements); 625 verifyFormat("if (true) {\n" 626 " f();\n" 627 "} else {\n" 628 " f();\n" 629 "}", 630 AllowSimpleBracedStatements); 631 632 AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = false; 633 verifyFormat("while (true) {}", AllowSimpleBracedStatements); 634 verifyFormat("while (true) {\n" 635 " f();\n" 636 "}", 637 AllowSimpleBracedStatements); 638 verifyFormat("for (;;) {}", AllowSimpleBracedStatements); 639 verifyFormat("for (;;) {\n" 640 " f();\n" 641 "}", 642 AllowSimpleBracedStatements); 643 644 AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = 645 FormatStyle::SIS_WithoutElse; 646 AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = true; 647 AllowSimpleBracedStatements.BraceWrapping.AfterControlStatement = true; 648 649 verifyFormat("if (true) {}", AllowSimpleBracedStatements); 650 verifyFormat("if constexpr (true) {}", AllowSimpleBracedStatements); 651 verifyFormat("if CONSTEXPR (true) {}", AllowSimpleBracedStatements); 652 verifyFormat("while (true) {}", AllowSimpleBracedStatements); 653 verifyFormat("for (;;) {}", AllowSimpleBracedStatements); 654 verifyFormat("if (true) { f(); }", AllowSimpleBracedStatements); 655 verifyFormat("if constexpr (true) { f(); }", AllowSimpleBracedStatements); 656 verifyFormat("if CONSTEXPR (true) { f(); }", AllowSimpleBracedStatements); 657 verifyFormat("while (true) { f(); }", AllowSimpleBracedStatements); 658 verifyFormat("for (;;) { f(); }", AllowSimpleBracedStatements); 659 verifyFormat("if (true)\n" 660 "{\n" 661 " ffffffffffffffffffffffffffffffffffffffffffffffffffffff();\n" 662 "}", 663 AllowSimpleBracedStatements); 664 verifyFormat("if (true)\n" 665 "{ //\n" 666 " f();\n" 667 "}", 668 AllowSimpleBracedStatements); 669 verifyFormat("if (true)\n" 670 "{\n" 671 " f();\n" 672 " f();\n" 673 "}", 674 AllowSimpleBracedStatements); 675 verifyFormat("if (true)\n" 676 "{\n" 677 " f();\n" 678 "} else\n" 679 "{\n" 680 " f();\n" 681 "}", 682 AllowSimpleBracedStatements); 683 684 AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = 685 FormatStyle::SIS_Never; 686 verifyFormat("if (true) {}", AllowSimpleBracedStatements); 687 verifyFormat("if (true)\n" 688 "{\n" 689 " f();\n" 690 "}", 691 AllowSimpleBracedStatements); 692 verifyFormat("if (true)\n" 693 "{\n" 694 " f();\n" 695 "} else\n" 696 "{\n" 697 " f();\n" 698 "}", 699 AllowSimpleBracedStatements); 700 701 AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = false; 702 verifyFormat("while (true) {}", AllowSimpleBracedStatements); 703 verifyFormat("while (true)\n" 704 "{\n" 705 " f();\n" 706 "}", 707 AllowSimpleBracedStatements); 708 verifyFormat("for (;;) {}", AllowSimpleBracedStatements); 709 verifyFormat("for (;;)\n" 710 "{\n" 711 " f();\n" 712 "}", 713 AllowSimpleBracedStatements); 714 } 715 716 TEST_F(FormatTest, ShortBlocksInMacrosDontMergeWithCodeAfterMacro) { 717 FormatStyle Style = getLLVMStyleWithColumns(60); 718 Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always; 719 Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_WithoutElse; 720 Style.BreakBeforeBraces = FormatStyle::BS_Allman; 721 EXPECT_EQ("#define A \\\n" 722 " if (HANDLEwernufrnuLwrmviferuvnierv) \\\n" 723 " { RET_ERR1_ANUIREUINERUIFNIOAerwfwrvnuier; }\n" 724 "X;", 725 format("#define A \\\n" 726 " if (HANDLEwernufrnuLwrmviferuvnierv) { \\\n" 727 " RET_ERR1_ANUIREUINERUIFNIOAerwfwrvnuier; \\\n" 728 " }\n" 729 "X;", 730 Style)); 731 } 732 733 TEST_F(FormatTest, ParseIfElse) { 734 verifyFormat("if (true)\n" 735 " if (true)\n" 736 " if (true)\n" 737 " f();\n" 738 " else\n" 739 " g();\n" 740 " else\n" 741 " h();\n" 742 "else\n" 743 " i();"); 744 verifyFormat("if (true)\n" 745 " if (true)\n" 746 " if (true) {\n" 747 " if (true)\n" 748 " f();\n" 749 " } else {\n" 750 " g();\n" 751 " }\n" 752 " else\n" 753 " h();\n" 754 "else {\n" 755 " i();\n" 756 "}"); 757 verifyFormat("if (true)\n" 758 " if constexpr (true)\n" 759 " if (true) {\n" 760 " if constexpr (true)\n" 761 " f();\n" 762 " } else {\n" 763 " g();\n" 764 " }\n" 765 " else\n" 766 " h();\n" 767 "else {\n" 768 " i();\n" 769 "}"); 770 verifyFormat("if (true)\n" 771 " if CONSTEXPR (true)\n" 772 " if (true) {\n" 773 " if CONSTEXPR (true)\n" 774 " f();\n" 775 " } else {\n" 776 " g();\n" 777 " }\n" 778 " else\n" 779 " h();\n" 780 "else {\n" 781 " i();\n" 782 "}"); 783 verifyFormat("void f() {\n" 784 " if (a) {\n" 785 " } else {\n" 786 " }\n" 787 "}"); 788 } 789 790 TEST_F(FormatTest, ElseIf) { 791 verifyFormat("if (a) {\n} else if (b) {\n}"); 792 verifyFormat("if (a)\n" 793 " f();\n" 794 "else if (b)\n" 795 " g();\n" 796 "else\n" 797 " h();"); 798 verifyFormat("if constexpr (a)\n" 799 " f();\n" 800 "else if constexpr (b)\n" 801 " g();\n" 802 "else\n" 803 " h();"); 804 verifyFormat("if CONSTEXPR (a)\n" 805 " f();\n" 806 "else if CONSTEXPR (b)\n" 807 " g();\n" 808 "else\n" 809 " h();"); 810 verifyFormat("if (a) {\n" 811 " f();\n" 812 "}\n" 813 "// or else ..\n" 814 "else {\n" 815 " g()\n" 816 "}"); 817 818 verifyFormat("if (a) {\n" 819 "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 820 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n" 821 "}"); 822 verifyFormat("if (a) {\n" 823 "} else if constexpr (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 824 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n" 825 "}"); 826 verifyFormat("if (a) {\n" 827 "} else if CONSTEXPR (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 828 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n" 829 "}"); 830 verifyFormat("if (a) {\n" 831 "} else if (\n" 832 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 833 "}", 834 getLLVMStyleWithColumns(62)); 835 verifyFormat("if (a) {\n" 836 "} else if constexpr (\n" 837 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 838 "}", 839 getLLVMStyleWithColumns(62)); 840 verifyFormat("if (a) {\n" 841 "} else if CONSTEXPR (\n" 842 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 843 "}", 844 getLLVMStyleWithColumns(62)); 845 } 846 847 TEST_F(FormatTest, FormatsForLoop) { 848 verifyFormat( 849 "for (int VeryVeryLongLoopVariable = 0; VeryVeryLongLoopVariable < 10;\n" 850 " ++VeryVeryLongLoopVariable)\n" 851 " ;"); 852 verifyFormat("for (;;)\n" 853 " f();"); 854 verifyFormat("for (;;) {\n}"); 855 verifyFormat("for (;;) {\n" 856 " f();\n" 857 "}"); 858 verifyFormat("for (int i = 0; (i < 10); ++i) {\n}"); 859 860 verifyFormat( 861 "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n" 862 " E = UnwrappedLines.end();\n" 863 " I != E; ++I) {\n}"); 864 865 verifyFormat( 866 "for (MachineFun::iterator IIII = PrevIt, EEEE = F.end(); IIII != EEEE;\n" 867 " ++IIIII) {\n}"); 868 verifyFormat("for (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaa =\n" 869 " aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa;\n" 870 " aaaaaaaaaaa != aaaaaaaaaaaaaaaaaaa; ++aaaaaaaaaaa) {\n}"); 871 verifyFormat("for (llvm::ArrayRef<NamedDecl *>::iterator\n" 872 " I = FD->getDeclsInPrototypeScope().begin(),\n" 873 " E = FD->getDeclsInPrototypeScope().end();\n" 874 " I != E; ++I) {\n}"); 875 verifyFormat("for (SmallVectorImpl<TemplateIdAnnotationn *>::iterator\n" 876 " I = Container.begin(),\n" 877 " E = Container.end();\n" 878 " I != E; ++I) {\n}", 879 getLLVMStyleWithColumns(76)); 880 881 verifyFormat( 882 "for (aaaaaaaaaaaaaaaaa aaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n" 883 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa !=\n" 884 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 885 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 886 " ++aaaaaaaaaaa) {\n}"); 887 verifyFormat("for (int i = 0; i < aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 888 " bbbbbbbbbbbbbbbbbbbb < ccccccccccccccc;\n" 889 " ++i) {\n}"); 890 verifyFormat("for (int aaaaaaaaaaa = 1; aaaaaaaaaaa <= bbbbbbbbbbbbbbb;\n" 891 " aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n" 892 "}"); 893 verifyFormat("for (some_namespace::SomeIterator iter( // force break\n" 894 " aaaaaaaaaa);\n" 895 " iter; ++iter) {\n" 896 "}"); 897 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 898 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 899 " aaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbbbbbbb;\n" 900 " ++aaaaaaaaaaaaaaaaaaaaaaaaaaa) {"); 901 902 // These should not be formatted as Objective-C for-in loops. 903 verifyFormat("for (Foo *x = 0; x != in; x++) {\n}"); 904 verifyFormat("Foo *x;\nfor (x = 0; x != in; x++) {\n}"); 905 verifyFormat("Foo *x;\nfor (x in y) {\n}"); 906 verifyFormat("for (const Foo<Bar> &baz = in.value(); !baz.at_end(); ++baz) {\n}"); 907 908 FormatStyle NoBinPacking = getLLVMStyle(); 909 NoBinPacking.BinPackParameters = false; 910 verifyFormat("for (int aaaaaaaaaaa = 1;\n" 911 " aaaaaaaaaaa <= aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa,\n" 912 " aaaaaaaaaaaaaaaa,\n" 913 " aaaaaaaaaaaaaaaa,\n" 914 " aaaaaaaaaaaaaaaa);\n" 915 " aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n" 916 "}", 917 NoBinPacking); 918 verifyFormat( 919 "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n" 920 " E = UnwrappedLines.end();\n" 921 " I != E;\n" 922 " ++I) {\n}", 923 NoBinPacking); 924 925 FormatStyle AlignLeft = getLLVMStyle(); 926 AlignLeft.PointerAlignment = FormatStyle::PAS_Left; 927 verifyFormat("for (A* a = start; a < end; ++a, ++value) {\n}", AlignLeft); 928 } 929 930 TEST_F(FormatTest, RangeBasedForLoops) { 931 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 932 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 933 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaa :\n" 934 " aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa, aaaaaaaaaaaaa)) {\n}"); 935 verifyFormat("for (const aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaa :\n" 936 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 937 verifyFormat("for (aaaaaaaaa aaaaaaaaaaaaaaaaaaaaa :\n" 938 " aaaaaaaaaaaa.aaaaaaaaaaaa().aaaaaaaaa().a()) {\n}"); 939 } 940 941 TEST_F(FormatTest, ForEachLoops) { 942 verifyFormat("void f() {\n" 943 " foreach (Item *item, itemlist) {}\n" 944 " Q_FOREACH (Item *item, itemlist) {}\n" 945 " BOOST_FOREACH (Item *item, itemlist) {}\n" 946 " UNKNOWN_FORACH(Item * item, itemlist) {}\n" 947 "}"); 948 949 // As function-like macros. 950 verifyFormat("#define foreach(x, y)\n" 951 "#define Q_FOREACH(x, y)\n" 952 "#define BOOST_FOREACH(x, y)\n" 953 "#define UNKNOWN_FOREACH(x, y)\n"); 954 955 // Not as function-like macros. 956 verifyFormat("#define foreach (x, y)\n" 957 "#define Q_FOREACH (x, y)\n" 958 "#define BOOST_FOREACH (x, y)\n" 959 "#define UNKNOWN_FOREACH (x, y)\n"); 960 } 961 962 TEST_F(FormatTest, FormatsWhileLoop) { 963 verifyFormat("while (true) {\n}"); 964 verifyFormat("while (true)\n" 965 " f();"); 966 verifyFormat("while () {\n}"); 967 verifyFormat("while () {\n" 968 " f();\n" 969 "}"); 970 } 971 972 TEST_F(FormatTest, FormatsDoWhile) { 973 verifyFormat("do {\n" 974 " do_something();\n" 975 "} while (something());"); 976 verifyFormat("do\n" 977 " do_something();\n" 978 "while (something());"); 979 } 980 981 TEST_F(FormatTest, FormatsSwitchStatement) { 982 verifyFormat("switch (x) {\n" 983 "case 1:\n" 984 " f();\n" 985 " break;\n" 986 "case kFoo:\n" 987 "case ns::kBar:\n" 988 "case kBaz:\n" 989 " break;\n" 990 "default:\n" 991 " g();\n" 992 " break;\n" 993 "}"); 994 verifyFormat("switch (x) {\n" 995 "case 1: {\n" 996 " f();\n" 997 " break;\n" 998 "}\n" 999 "case 2: {\n" 1000 " break;\n" 1001 "}\n" 1002 "}"); 1003 verifyFormat("switch (x) {\n" 1004 "case 1: {\n" 1005 " f();\n" 1006 " {\n" 1007 " g();\n" 1008 " h();\n" 1009 " }\n" 1010 " break;\n" 1011 "}\n" 1012 "}"); 1013 verifyFormat("switch (x) {\n" 1014 "case 1: {\n" 1015 " f();\n" 1016 " if (foo) {\n" 1017 " g();\n" 1018 " h();\n" 1019 " }\n" 1020 " break;\n" 1021 "}\n" 1022 "}"); 1023 verifyFormat("switch (x) {\n" 1024 "case 1: {\n" 1025 " f();\n" 1026 " g();\n" 1027 "} break;\n" 1028 "}"); 1029 verifyFormat("switch (test)\n" 1030 " ;"); 1031 verifyFormat("switch (x) {\n" 1032 "default: {\n" 1033 " // Do nothing.\n" 1034 "}\n" 1035 "}"); 1036 verifyFormat("switch (x) {\n" 1037 "// comment\n" 1038 "// if 1, do f()\n" 1039 "case 1:\n" 1040 " f();\n" 1041 "}"); 1042 verifyFormat("switch (x) {\n" 1043 "case 1:\n" 1044 " // Do amazing stuff\n" 1045 " {\n" 1046 " f();\n" 1047 " g();\n" 1048 " }\n" 1049 " break;\n" 1050 "}"); 1051 verifyFormat("#define A \\\n" 1052 " switch (x) { \\\n" 1053 " case a: \\\n" 1054 " foo = b; \\\n" 1055 " }", 1056 getLLVMStyleWithColumns(20)); 1057 verifyFormat("#define OPERATION_CASE(name) \\\n" 1058 " case OP_name: \\\n" 1059 " return operations::Operation##name\n", 1060 getLLVMStyleWithColumns(40)); 1061 verifyFormat("switch (x) {\n" 1062 "case 1:;\n" 1063 "default:;\n" 1064 " int i;\n" 1065 "}"); 1066 1067 verifyGoogleFormat("switch (x) {\n" 1068 " case 1:\n" 1069 " f();\n" 1070 " break;\n" 1071 " case kFoo:\n" 1072 " case ns::kBar:\n" 1073 " case kBaz:\n" 1074 " break;\n" 1075 " default:\n" 1076 " g();\n" 1077 " break;\n" 1078 "}"); 1079 verifyGoogleFormat("switch (x) {\n" 1080 " case 1: {\n" 1081 " f();\n" 1082 " break;\n" 1083 " }\n" 1084 "}"); 1085 verifyGoogleFormat("switch (test)\n" 1086 " ;"); 1087 1088 verifyGoogleFormat("#define OPERATION_CASE(name) \\\n" 1089 " case OP_name: \\\n" 1090 " return operations::Operation##name\n"); 1091 verifyGoogleFormat("Operation codeToOperation(OperationCode OpCode) {\n" 1092 " // Get the correction operation class.\n" 1093 " switch (OpCode) {\n" 1094 " CASE(Add);\n" 1095 " CASE(Subtract);\n" 1096 " default:\n" 1097 " return operations::Unknown;\n" 1098 " }\n" 1099 "#undef OPERATION_CASE\n" 1100 "}"); 1101 verifyFormat("DEBUG({\n" 1102 " switch (x) {\n" 1103 " case A:\n" 1104 " f();\n" 1105 " break;\n" 1106 " // fallthrough\n" 1107 " case B:\n" 1108 " g();\n" 1109 " break;\n" 1110 " }\n" 1111 "});"); 1112 EXPECT_EQ("DEBUG({\n" 1113 " switch (x) {\n" 1114 " case A:\n" 1115 " f();\n" 1116 " break;\n" 1117 " // On B:\n" 1118 " case B:\n" 1119 " g();\n" 1120 " break;\n" 1121 " }\n" 1122 "});", 1123 format("DEBUG({\n" 1124 " switch (x) {\n" 1125 " case A:\n" 1126 " f();\n" 1127 " break;\n" 1128 " // On B:\n" 1129 " case B:\n" 1130 " g();\n" 1131 " break;\n" 1132 " }\n" 1133 "});", 1134 getLLVMStyle())); 1135 EXPECT_EQ("switch (n) {\n" 1136 "case 0: {\n" 1137 " return false;\n" 1138 "}\n" 1139 "default: {\n" 1140 " return true;\n" 1141 "}\n" 1142 "}", 1143 format("switch (n)\n" 1144 "{\n" 1145 "case 0: {\n" 1146 " return false;\n" 1147 "}\n" 1148 "default: {\n" 1149 " return true;\n" 1150 "}\n" 1151 "}", 1152 getLLVMStyle())); 1153 verifyFormat("switch (a) {\n" 1154 "case (b):\n" 1155 " return;\n" 1156 "}"); 1157 1158 verifyFormat("switch (a) {\n" 1159 "case some_namespace::\n" 1160 " some_constant:\n" 1161 " return;\n" 1162 "}", 1163 getLLVMStyleWithColumns(34)); 1164 1165 FormatStyle Style = getLLVMStyle(); 1166 Style.IndentCaseLabels = true; 1167 Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Never; 1168 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 1169 Style.BraceWrapping.AfterCaseLabel = true; 1170 Style.BraceWrapping.AfterControlStatement = true; 1171 EXPECT_EQ("switch (n)\n" 1172 "{\n" 1173 " case 0:\n" 1174 " {\n" 1175 " return false;\n" 1176 " }\n" 1177 " default:\n" 1178 " {\n" 1179 " return true;\n" 1180 " }\n" 1181 "}", 1182 format("switch (n) {\n" 1183 " case 0: {\n" 1184 " return false;\n" 1185 " }\n" 1186 " default: {\n" 1187 " return true;\n" 1188 " }\n" 1189 "}", 1190 Style)); 1191 Style.BraceWrapping.AfterCaseLabel = false; 1192 EXPECT_EQ("switch (n)\n" 1193 "{\n" 1194 " case 0: {\n" 1195 " return false;\n" 1196 " }\n" 1197 " default: {\n" 1198 " return true;\n" 1199 " }\n" 1200 "}", 1201 format("switch (n) {\n" 1202 " case 0:\n" 1203 " {\n" 1204 " return false;\n" 1205 " }\n" 1206 " default:\n" 1207 " {\n" 1208 " return true;\n" 1209 " }\n" 1210 "}", 1211 Style)); 1212 } 1213 1214 TEST_F(FormatTest, CaseRanges) { 1215 verifyFormat("switch (x) {\n" 1216 "case 'A' ... 'Z':\n" 1217 "case 1 ... 5:\n" 1218 "case a ... b:\n" 1219 " break;\n" 1220 "}"); 1221 } 1222 1223 TEST_F(FormatTest, ShortCaseLabels) { 1224 FormatStyle Style = getLLVMStyle(); 1225 Style.AllowShortCaseLabelsOnASingleLine = true; 1226 verifyFormat("switch (a) {\n" 1227 "case 1: x = 1; break;\n" 1228 "case 2: return;\n" 1229 "case 3:\n" 1230 "case 4:\n" 1231 "case 5: return;\n" 1232 "case 6: // comment\n" 1233 " return;\n" 1234 "case 7:\n" 1235 " // comment\n" 1236 " return;\n" 1237 "case 8:\n" 1238 " x = 8; // comment\n" 1239 " break;\n" 1240 "default: y = 1; break;\n" 1241 "}", 1242 Style); 1243 verifyFormat("switch (a) {\n" 1244 "case 0: return; // comment\n" 1245 "case 1: break; // comment\n" 1246 "case 2: return;\n" 1247 "// comment\n" 1248 "case 3: return;\n" 1249 "// comment 1\n" 1250 "// comment 2\n" 1251 "// comment 3\n" 1252 "case 4: break; /* comment */\n" 1253 "case 5:\n" 1254 " // comment\n" 1255 " break;\n" 1256 "case 6: /* comment */ x = 1; break;\n" 1257 "case 7: x = /* comment */ 1; break;\n" 1258 "case 8:\n" 1259 " x = 1; /* comment */\n" 1260 " break;\n" 1261 "case 9:\n" 1262 " break; // comment line 1\n" 1263 " // comment line 2\n" 1264 "}", 1265 Style); 1266 EXPECT_EQ("switch (a) {\n" 1267 "case 1:\n" 1268 " x = 8;\n" 1269 " // fall through\n" 1270 "case 2: x = 8;\n" 1271 "// comment\n" 1272 "case 3:\n" 1273 " return; /* comment line 1\n" 1274 " * comment line 2 */\n" 1275 "case 4: i = 8;\n" 1276 "// something else\n" 1277 "#if FOO\n" 1278 "case 5: break;\n" 1279 "#endif\n" 1280 "}", 1281 format("switch (a) {\n" 1282 "case 1: x = 8;\n" 1283 " // fall through\n" 1284 "case 2:\n" 1285 " x = 8;\n" 1286 "// comment\n" 1287 "case 3:\n" 1288 " return; /* comment line 1\n" 1289 " * comment line 2 */\n" 1290 "case 4:\n" 1291 " i = 8;\n" 1292 "// something else\n" 1293 "#if FOO\n" 1294 "case 5: break;\n" 1295 "#endif\n" 1296 "}", 1297 Style)); 1298 EXPECT_EQ("switch (a) {\n" "case 0:\n" 1299 " return; // long long long long long long long long long long long long comment\n" 1300 " // line\n" "}", 1301 format("switch (a) {\n" 1302 "case 0: return; // long long long long long long long long long long long long comment line\n" 1303 "}", 1304 Style)); 1305 EXPECT_EQ("switch (a) {\n" 1306 "case 0:\n" 1307 " return; /* long long long long long long long long long long long long comment\n" 1308 " line */\n" 1309 "}", 1310 format("switch (a) {\n" 1311 "case 0: return; /* long long long long long long long long long long long long comment line */\n" 1312 "}", 1313 Style)); 1314 verifyFormat("switch (a) {\n" 1315 "#if FOO\n" 1316 "case 0: return 0;\n" 1317 "#endif\n" 1318 "}", 1319 Style); 1320 verifyFormat("switch (a) {\n" 1321 "case 1: {\n" 1322 "}\n" 1323 "case 2: {\n" 1324 " return;\n" 1325 "}\n" 1326 "case 3: {\n" 1327 " x = 1;\n" 1328 " return;\n" 1329 "}\n" 1330 "case 4:\n" 1331 " if (x)\n" 1332 " return;\n" 1333 "}", 1334 Style); 1335 Style.ColumnLimit = 21; 1336 verifyFormat("switch (a) {\n" 1337 "case 1: x = 1; break;\n" 1338 "case 2: return;\n" 1339 "case 3:\n" 1340 "case 4:\n" 1341 "case 5: return;\n" 1342 "default:\n" 1343 " y = 1;\n" 1344 " break;\n" 1345 "}", 1346 Style); 1347 Style.ColumnLimit = 80; 1348 Style.AllowShortCaseLabelsOnASingleLine = false; 1349 Style.IndentCaseLabels = true; 1350 EXPECT_EQ("switch (n) {\n" 1351 " default /*comments*/:\n" 1352 " return true;\n" 1353 " case 0:\n" 1354 " return false;\n" 1355 "}", 1356 format("switch (n) {\n" 1357 "default/*comments*/:\n" 1358 " return true;\n" 1359 "case 0:\n" 1360 " return false;\n" 1361 "}", 1362 Style)); 1363 Style.AllowShortCaseLabelsOnASingleLine = true; 1364 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 1365 Style.BraceWrapping.AfterCaseLabel = true; 1366 Style.BraceWrapping.AfterControlStatement = true; 1367 EXPECT_EQ("switch (n)\n" 1368 "{\n" 1369 " case 0:\n" 1370 " {\n" 1371 " return false;\n" 1372 " }\n" 1373 " default:\n" 1374 " {\n" 1375 " return true;\n" 1376 " }\n" 1377 "}", 1378 format("switch (n) {\n" 1379 " case 0: {\n" 1380 " return false;\n" 1381 " }\n" 1382 " default:\n" 1383 " {\n" 1384 " return true;\n" 1385 " }\n" 1386 "}", 1387 Style)); 1388 } 1389 1390 TEST_F(FormatTest, FormatsLabels) { 1391 verifyFormat("void f() {\n" 1392 " some_code();\n" 1393 "test_label:\n" 1394 " some_other_code();\n" 1395 " {\n" 1396 " some_more_code();\n" 1397 " another_label:\n" 1398 " some_more_code();\n" 1399 " }\n" 1400 "}"); 1401 verifyFormat("{\n" 1402 " some_code();\n" 1403 "test_label:\n" 1404 " some_other_code();\n" 1405 "}"); 1406 verifyFormat("{\n" 1407 " some_code();\n" 1408 "test_label:;\n" 1409 " int i = 0;\n" 1410 "}"); 1411 FormatStyle Style = getLLVMStyle(); 1412 Style.IndentGotoLabels = false; 1413 verifyFormat("void f() {\n" 1414 " some_code();\n" 1415 "test_label:\n" 1416 " some_other_code();\n" 1417 " {\n" 1418 " some_more_code();\n" 1419 "another_label:\n" 1420 " some_more_code();\n" 1421 " }\n" 1422 "}", 1423 Style); 1424 verifyFormat("{\n" 1425 " some_code();\n" 1426 "test_label:\n" 1427 " some_other_code();\n" 1428 "}", 1429 Style); 1430 verifyFormat("{\n" 1431 " some_code();\n" 1432 "test_label:;\n" 1433 " int i = 0;\n" 1434 "}"); 1435 } 1436 1437 //===----------------------------------------------------------------------===// 1438 // Tests for classes, namespaces, etc. 1439 //===----------------------------------------------------------------------===// 1440 1441 TEST_F(FormatTest, DoesNotBreakSemiAfterClassDecl) { 1442 verifyFormat("class A {};"); 1443 } 1444 1445 TEST_F(FormatTest, UnderstandsAccessSpecifiers) { 1446 verifyFormat("class A {\n" 1447 "public:\n" 1448 "public: // comment\n" 1449 "protected:\n" 1450 "private:\n" 1451 " void f() {}\n" 1452 "};"); 1453 verifyFormat("export class A {\n" 1454 "public:\n" 1455 "public: // comment\n" 1456 "protected:\n" 1457 "private:\n" 1458 " void f() {}\n" 1459 "};"); 1460 verifyGoogleFormat("class A {\n" 1461 " public:\n" 1462 " protected:\n" 1463 " private:\n" 1464 " void f() {}\n" 1465 "};"); 1466 verifyGoogleFormat("export class A {\n" 1467 " public:\n" 1468 " protected:\n" 1469 " private:\n" 1470 " void f() {}\n" 1471 "};"); 1472 verifyFormat("class A {\n" 1473 "public slots:\n" 1474 " void f1() {}\n" 1475 "public Q_SLOTS:\n" 1476 " void f2() {}\n" 1477 "protected slots:\n" 1478 " void f3() {}\n" 1479 "protected Q_SLOTS:\n" 1480 " void f4() {}\n" 1481 "private slots:\n" 1482 " void f5() {}\n" 1483 "private Q_SLOTS:\n" 1484 " void f6() {}\n" 1485 "signals:\n" 1486 " void g1();\n" 1487 "Q_SIGNALS:\n" 1488 " void g2();\n" 1489 "};"); 1490 1491 // Don't interpret 'signals' the wrong way. 1492 verifyFormat("signals.set();"); 1493 verifyFormat("for (Signals signals : f()) {\n}"); 1494 verifyFormat("{\n" 1495 " signals.set(); // This needs indentation.\n" 1496 "}"); 1497 verifyFormat("void f() {\n" 1498 "label:\n" 1499 " signals.baz();\n" 1500 "}"); 1501 } 1502 1503 TEST_F(FormatTest, SeparatesLogicalBlocks) { 1504 EXPECT_EQ("class A {\n" 1505 "public:\n" 1506 " void f();\n" 1507 "\n" 1508 "private:\n" 1509 " void g() {}\n" 1510 " // test\n" 1511 "protected:\n" 1512 " int h;\n" 1513 "};", 1514 format("class A {\n" 1515 "public:\n" 1516 "void f();\n" 1517 "private:\n" 1518 "void g() {}\n" 1519 "// test\n" 1520 "protected:\n" 1521 "int h;\n" 1522 "};")); 1523 EXPECT_EQ("class A {\n" 1524 "protected:\n" 1525 "public:\n" 1526 " void f();\n" 1527 "};", 1528 format("class A {\n" 1529 "protected:\n" 1530 "\n" 1531 "public:\n" 1532 "\n" 1533 " void f();\n" 1534 "};")); 1535 1536 // Even ensure proper spacing inside macros. 1537 EXPECT_EQ("#define B \\\n" 1538 " class A { \\\n" 1539 " protected: \\\n" 1540 " public: \\\n" 1541 " void f(); \\\n" 1542 " };", 1543 format("#define B \\\n" 1544 " class A { \\\n" 1545 " protected: \\\n" 1546 " \\\n" 1547 " public: \\\n" 1548 " \\\n" 1549 " void f(); \\\n" 1550 " };", 1551 getGoogleStyle())); 1552 // But don't remove empty lines after macros ending in access specifiers. 1553 EXPECT_EQ("#define A private:\n" 1554 "\n" 1555 "int i;", 1556 format("#define A private:\n" 1557 "\n" 1558 "int i;")); 1559 } 1560 1561 TEST_F(FormatTest, FormatsClasses) { 1562 verifyFormat("class A : public B {};"); 1563 verifyFormat("class A : public ::B {};"); 1564 1565 verifyFormat( 1566 "class AAAAAAAAAAAAAAAAAAAA : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n" 1567 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};"); 1568 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n" 1569 " : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n" 1570 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};"); 1571 verifyFormat( 1572 "class A : public B, public C, public D, public E, public F {};"); 1573 verifyFormat("class AAAAAAAAAAAA : public B,\n" 1574 " public C,\n" 1575 " public D,\n" 1576 " public E,\n" 1577 " public F,\n" 1578 " public G {};"); 1579 1580 verifyFormat("class\n" 1581 " ReallyReallyLongClassName {\n" 1582 " int i;\n" 1583 "};", 1584 getLLVMStyleWithColumns(32)); 1585 verifyFormat("struct aaaaaaaaaaaaa : public aaaaaaaaaaaaaaaaaaa< // break\n" 1586 " aaaaaaaaaaaaaaaa> {};"); 1587 verifyFormat("struct aaaaaaaaaaaaaaaaaaaa\n" 1588 " : public aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaa,\n" 1589 " aaaaaaaaaaaaaaaaaaaaaa> {};"); 1590 verifyFormat("template <class R, class C>\n" 1591 "struct Aaaaaaaaaaaaaaaaa<R (C::*)(int) const>\n" 1592 " : Aaaaaaaaaaaaaaaaa<R (C::*)(int)> {};"); 1593 verifyFormat("class ::A::B {};"); 1594 } 1595 1596 TEST_F(FormatTest, BreakInheritanceStyle) { 1597 FormatStyle StyleWithInheritanceBreakBeforeComma = getLLVMStyle(); 1598 StyleWithInheritanceBreakBeforeComma.BreakInheritanceList = 1599 FormatStyle::BILS_BeforeComma; 1600 verifyFormat("class MyClass : public X {};", 1601 StyleWithInheritanceBreakBeforeComma); 1602 verifyFormat("class MyClass\n" 1603 " : public X\n" 1604 " , public Y {};", 1605 StyleWithInheritanceBreakBeforeComma); 1606 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAA\n" 1607 " : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n" 1608 " , public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};", 1609 StyleWithInheritanceBreakBeforeComma); 1610 verifyFormat("struct aaaaaaaaaaaaa\n" 1611 " : public aaaaaaaaaaaaaaaaaaa< // break\n" 1612 " aaaaaaaaaaaaaaaa> {};", 1613 StyleWithInheritanceBreakBeforeComma); 1614 1615 FormatStyle StyleWithInheritanceBreakAfterColon = getLLVMStyle(); 1616 StyleWithInheritanceBreakAfterColon.BreakInheritanceList = 1617 FormatStyle::BILS_AfterColon; 1618 verifyFormat("class MyClass : public X {};", 1619 StyleWithInheritanceBreakAfterColon); 1620 verifyFormat("class MyClass : public X, public Y {};", 1621 StyleWithInheritanceBreakAfterColon); 1622 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAA :\n" 1623 " public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n" 1624 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};", 1625 StyleWithInheritanceBreakAfterColon); 1626 verifyFormat("struct aaaaaaaaaaaaa :\n" 1627 " public aaaaaaaaaaaaaaaaaaa< // break\n" 1628 " aaaaaaaaaaaaaaaa> {};", 1629 StyleWithInheritanceBreakAfterColon); 1630 } 1631 1632 TEST_F(FormatTest, FormatsVariableDeclarationsAfterStructOrClass) { 1633 verifyFormat("class A {\n} a, b;"); 1634 verifyFormat("struct A {\n} a, b;"); 1635 verifyFormat("union A {\n} a;"); 1636 } 1637 1638 TEST_F(FormatTest, FormatsEnum) { 1639 verifyFormat("enum {\n" 1640 " Zero,\n" 1641 " One = 1,\n" 1642 " Two = One + 1,\n" 1643 " Three = (One + Two),\n" 1644 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1645 " Five = (One, Two, Three, Four, 5)\n" 1646 "};"); 1647 verifyGoogleFormat("enum {\n" 1648 " Zero,\n" 1649 " One = 1,\n" 1650 " Two = One + 1,\n" 1651 " Three = (One + Two),\n" 1652 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1653 " Five = (One, Two, Three, Four, 5)\n" 1654 "};"); 1655 verifyFormat("enum Enum {};"); 1656 verifyFormat("enum {};"); 1657 verifyFormat("enum X E {} d;"); 1658 verifyFormat("enum __attribute__((...)) E {} d;"); 1659 verifyFormat("enum __declspec__((...)) E {} d;"); 1660 verifyFormat("enum {\n" 1661 " Bar = Foo<int, int>::value\n" 1662 "};", 1663 getLLVMStyleWithColumns(30)); 1664 1665 verifyFormat("enum ShortEnum { A, B, C };"); 1666 verifyGoogleFormat("enum ShortEnum { A, B, C };"); 1667 1668 EXPECT_EQ("enum KeepEmptyLines {\n" 1669 " ONE,\n" 1670 "\n" 1671 " TWO,\n" 1672 "\n" 1673 " THREE\n" 1674 "}", 1675 format("enum KeepEmptyLines {\n" 1676 " ONE,\n" 1677 "\n" 1678 " TWO,\n" 1679 "\n" 1680 "\n" 1681 " THREE\n" 1682 "}")); 1683 verifyFormat("enum E { // comment\n" 1684 " ONE,\n" 1685 " TWO\n" 1686 "};\n" 1687 "int i;"); 1688 // Not enums. 1689 verifyFormat("enum X f() {\n" 1690 " a();\n" 1691 " return 42;\n" 1692 "}"); 1693 verifyFormat("enum X Type::f() {\n" 1694 " a();\n" 1695 " return 42;\n" 1696 "}"); 1697 verifyFormat("enum ::X f() {\n" 1698 " a();\n" 1699 " return 42;\n" 1700 "}"); 1701 verifyFormat("enum ns::X f() {\n" 1702 " a();\n" 1703 " return 42;\n" 1704 "}"); 1705 } 1706 1707 TEST_F(FormatTest, FormatsEnumsWithErrors) { 1708 verifyFormat("enum Type {\n" 1709 " One = 0; // These semicolons should be commas.\n" 1710 " Two = 1;\n" 1711 "};"); 1712 verifyFormat("namespace n {\n" 1713 "enum Type {\n" 1714 " One,\n" 1715 " Two, // missing };\n" 1716 " int i;\n" 1717 "}\n" 1718 "void g() {}"); 1719 } 1720 1721 TEST_F(FormatTest, FormatsEnumStruct) { 1722 verifyFormat("enum struct {\n" 1723 " Zero,\n" 1724 " One = 1,\n" 1725 " Two = One + 1,\n" 1726 " Three = (One + Two),\n" 1727 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1728 " Five = (One, Two, Three, Four, 5)\n" 1729 "};"); 1730 verifyFormat("enum struct Enum {};"); 1731 verifyFormat("enum struct {};"); 1732 verifyFormat("enum struct X E {} d;"); 1733 verifyFormat("enum struct __attribute__((...)) E {} d;"); 1734 verifyFormat("enum struct __declspec__((...)) E {} d;"); 1735 verifyFormat("enum struct X f() {\n a();\n return 42;\n}"); 1736 } 1737 1738 TEST_F(FormatTest, FormatsEnumClass) { 1739 verifyFormat("enum class {\n" 1740 " Zero,\n" 1741 " One = 1,\n" 1742 " Two = One + 1,\n" 1743 " Three = (One + Two),\n" 1744 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1745 " Five = (One, Two, Three, Four, 5)\n" 1746 "};"); 1747 verifyFormat("enum class Enum {};"); 1748 verifyFormat("enum class {};"); 1749 verifyFormat("enum class X E {} d;"); 1750 verifyFormat("enum class __attribute__((...)) E {} d;"); 1751 verifyFormat("enum class __declspec__((...)) E {} d;"); 1752 verifyFormat("enum class X f() {\n a();\n return 42;\n}"); 1753 } 1754 1755 TEST_F(FormatTest, FormatsEnumTypes) { 1756 verifyFormat("enum X : int {\n" 1757 " A, // Force multiple lines.\n" 1758 " B\n" 1759 "};"); 1760 verifyFormat("enum X : int { A, B };"); 1761 verifyFormat("enum X : std::uint32_t { A, B };"); 1762 } 1763 1764 TEST_F(FormatTest, FormatsTypedefEnum) { 1765 FormatStyle Style = getLLVMStyle(); 1766 Style.ColumnLimit = 40; 1767 verifyFormat("typedef enum {} EmptyEnum;"); 1768 verifyFormat("typedef enum { A, B, C } ShortEnum;"); 1769 verifyFormat("typedef enum {\n" 1770 " ZERO = 0,\n" 1771 " ONE = 1,\n" 1772 " TWO = 2,\n" 1773 " THREE = 3\n" 1774 "} LongEnum;", 1775 Style); 1776 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 1777 Style.BraceWrapping.AfterEnum = true; 1778 verifyFormat("typedef enum {} EmptyEnum;"); 1779 verifyFormat("typedef enum { A, B, C } ShortEnum;"); 1780 verifyFormat("typedef enum\n" 1781 "{\n" 1782 " ZERO = 0,\n" 1783 " ONE = 1,\n" 1784 " TWO = 2,\n" 1785 " THREE = 3\n" 1786 "} LongEnum;", 1787 Style); 1788 } 1789 1790 TEST_F(FormatTest, FormatsNSEnums) { 1791 verifyGoogleFormat("typedef NS_ENUM(NSInteger, SomeName) { AAA, BBB }"); 1792 verifyGoogleFormat( 1793 "typedef NS_CLOSED_ENUM(NSInteger, SomeName) { AAA, BBB }"); 1794 verifyGoogleFormat("typedef NS_ENUM(NSInteger, MyType) {\n" 1795 " // Information about someDecentlyLongValue.\n" 1796 " someDecentlyLongValue,\n" 1797 " // Information about anotherDecentlyLongValue.\n" 1798 " anotherDecentlyLongValue,\n" 1799 " // Information about aThirdDecentlyLongValue.\n" 1800 " aThirdDecentlyLongValue\n" 1801 "};"); 1802 verifyGoogleFormat("typedef NS_CLOSED_ENUM(NSInteger, MyType) {\n" 1803 " // Information about someDecentlyLongValue.\n" 1804 " someDecentlyLongValue,\n" 1805 " // Information about anotherDecentlyLongValue.\n" 1806 " anotherDecentlyLongValue,\n" 1807 " // Information about aThirdDecentlyLongValue.\n" 1808 " aThirdDecentlyLongValue\n" 1809 "};"); 1810 verifyGoogleFormat("typedef NS_OPTIONS(NSInteger, MyType) {\n" 1811 " a = 1,\n" 1812 " b = 2,\n" 1813 " c = 3,\n" 1814 "};"); 1815 verifyGoogleFormat("typedef CF_ENUM(NSInteger, MyType) {\n" 1816 " a = 1,\n" 1817 " b = 2,\n" 1818 " c = 3,\n" 1819 "};"); 1820 verifyGoogleFormat("typedef CF_CLOSED_ENUM(NSInteger, MyType) {\n" 1821 " a = 1,\n" 1822 " b = 2,\n" 1823 " c = 3,\n" 1824 "};"); 1825 verifyGoogleFormat("typedef CF_OPTIONS(NSInteger, MyType) {\n" 1826 " a = 1,\n" 1827 " b = 2,\n" 1828 " c = 3,\n" 1829 "};"); 1830 } 1831 1832 TEST_F(FormatTest, FormatsBitfields) { 1833 verifyFormat("struct Bitfields {\n" 1834 " unsigned sClass : 8;\n" 1835 " unsigned ValueKind : 2;\n" 1836 "};"); 1837 verifyFormat("struct A {\n" 1838 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa : 1,\n" 1839 " bbbbbbbbbbbbbbbbbbbbbbbbb;\n" 1840 "};"); 1841 verifyFormat("struct MyStruct {\n" 1842 " uchar data;\n" 1843 " uchar : 8;\n" 1844 " uchar : 8;\n" 1845 " uchar other;\n" 1846 "};"); 1847 } 1848 1849 TEST_F(FormatTest, FormatsNamespaces) { 1850 FormatStyle LLVMWithNoNamespaceFix = getLLVMStyle(); 1851 LLVMWithNoNamespaceFix.FixNamespaceComments = false; 1852 1853 verifyFormat("namespace some_namespace {\n" 1854 "class A {};\n" 1855 "void f() { f(); }\n" 1856 "}", 1857 LLVMWithNoNamespaceFix); 1858 verifyFormat("namespace N::inline D {\n" 1859 "class A {};\n" 1860 "void f() { f(); }\n" 1861 "}", 1862 LLVMWithNoNamespaceFix); 1863 verifyFormat("namespace N::inline D::E {\n" 1864 "class A {};\n" 1865 "void f() { f(); }\n" 1866 "}", 1867 LLVMWithNoNamespaceFix); 1868 verifyFormat("namespace [[deprecated(\"foo[bar\")]] some_namespace {\n" 1869 "class A {};\n" 1870 "void f() { f(); }\n" 1871 "}", 1872 LLVMWithNoNamespaceFix); 1873 verifyFormat("/* something */ namespace some_namespace {\n" 1874 "class A {};\n" 1875 "void f() { f(); }\n" 1876 "}", 1877 LLVMWithNoNamespaceFix); 1878 verifyFormat("namespace {\n" 1879 "class A {};\n" 1880 "void f() { f(); }\n" 1881 "}", 1882 LLVMWithNoNamespaceFix); 1883 verifyFormat("/* something */ namespace {\n" 1884 "class A {};\n" 1885 "void f() { f(); }\n" 1886 "}", 1887 LLVMWithNoNamespaceFix); 1888 verifyFormat("inline namespace X {\n" 1889 "class A {};\n" 1890 "void f() { f(); }\n" 1891 "}", 1892 LLVMWithNoNamespaceFix); 1893 verifyFormat("/* something */ inline namespace X {\n" 1894 "class A {};\n" 1895 "void f() { f(); }\n" 1896 "}", 1897 LLVMWithNoNamespaceFix); 1898 verifyFormat("export namespace X {\n" 1899 "class A {};\n" 1900 "void f() { f(); }\n" 1901 "}", 1902 LLVMWithNoNamespaceFix); 1903 verifyFormat("using namespace some_namespace;\n" 1904 "class A {};\n" 1905 "void f() { f(); }", 1906 LLVMWithNoNamespaceFix); 1907 1908 // This code is more common than we thought; if we 1909 // layout this correctly the semicolon will go into 1910 // its own line, which is undesirable. 1911 verifyFormat("namespace {};", 1912 LLVMWithNoNamespaceFix); 1913 verifyFormat("namespace {\n" 1914 "class A {};\n" 1915 "};", 1916 LLVMWithNoNamespaceFix); 1917 1918 verifyFormat("namespace {\n" 1919 "int SomeVariable = 0; // comment\n" 1920 "} // namespace", 1921 LLVMWithNoNamespaceFix); 1922 EXPECT_EQ("#ifndef HEADER_GUARD\n" 1923 "#define HEADER_GUARD\n" 1924 "namespace my_namespace {\n" 1925 "int i;\n" 1926 "} // my_namespace\n" 1927 "#endif // HEADER_GUARD", 1928 format("#ifndef HEADER_GUARD\n" 1929 " #define HEADER_GUARD\n" 1930 " namespace my_namespace {\n" 1931 "int i;\n" 1932 "} // my_namespace\n" 1933 "#endif // HEADER_GUARD", 1934 LLVMWithNoNamespaceFix)); 1935 1936 EXPECT_EQ("namespace A::B {\n" 1937 "class C {};\n" 1938 "}", 1939 format("namespace A::B {\n" 1940 "class C {};\n" 1941 "}", 1942 LLVMWithNoNamespaceFix)); 1943 1944 FormatStyle Style = getLLVMStyle(); 1945 Style.NamespaceIndentation = FormatStyle::NI_All; 1946 EXPECT_EQ("namespace out {\n" 1947 " int i;\n" 1948 " namespace in {\n" 1949 " int i;\n" 1950 " } // namespace in\n" 1951 "} // namespace out", 1952 format("namespace out {\n" 1953 "int i;\n" 1954 "namespace in {\n" 1955 "int i;\n" 1956 "} // namespace in\n" 1957 "} // namespace out", 1958 Style)); 1959 1960 Style.NamespaceIndentation = FormatStyle::NI_Inner; 1961 EXPECT_EQ("namespace out {\n" 1962 "int i;\n" 1963 "namespace in {\n" 1964 " int i;\n" 1965 "} // namespace in\n" 1966 "} // namespace out", 1967 format("namespace out {\n" 1968 "int i;\n" 1969 "namespace in {\n" 1970 "int i;\n" 1971 "} // namespace in\n" 1972 "} // namespace out", 1973 Style)); 1974 } 1975 1976 TEST_F(FormatTest, NamespaceMacros) { 1977 FormatStyle Style = getLLVMStyle(); 1978 Style.NamespaceMacros.push_back("TESTSUITE"); 1979 1980 verifyFormat("TESTSUITE(A) {\n" 1981 "int foo();\n" 1982 "} // TESTSUITE(A)", 1983 Style); 1984 1985 verifyFormat("TESTSUITE(A, B) {\n" 1986 "int foo();\n" 1987 "} // TESTSUITE(A)", 1988 Style); 1989 1990 // Properly indent according to NamespaceIndentation style 1991 Style.NamespaceIndentation = FormatStyle::NI_All; 1992 verifyFormat("TESTSUITE(A) {\n" 1993 " int foo();\n" 1994 "} // TESTSUITE(A)", 1995 Style); 1996 verifyFormat("TESTSUITE(A) {\n" 1997 " namespace B {\n" 1998 " int foo();\n" 1999 " } // namespace B\n" 2000 "} // TESTSUITE(A)", 2001 Style); 2002 verifyFormat("namespace A {\n" 2003 " TESTSUITE(B) {\n" 2004 " int foo();\n" 2005 " } // TESTSUITE(B)\n" 2006 "} // namespace A", 2007 Style); 2008 2009 Style.NamespaceIndentation = FormatStyle::NI_Inner; 2010 verifyFormat("TESTSUITE(A) {\n" 2011 "TESTSUITE(B) {\n" 2012 " int foo();\n" 2013 "} // TESTSUITE(B)\n" 2014 "} // TESTSUITE(A)", 2015 Style); 2016 verifyFormat("TESTSUITE(A) {\n" 2017 "namespace B {\n" 2018 " int foo();\n" 2019 "} // namespace B\n" 2020 "} // TESTSUITE(A)", 2021 Style); 2022 verifyFormat("namespace A {\n" 2023 "TESTSUITE(B) {\n" 2024 " int foo();\n" 2025 "} // TESTSUITE(B)\n" 2026 "} // namespace A", 2027 Style); 2028 2029 // Properly merge namespace-macros blocks in CompactNamespaces mode 2030 Style.NamespaceIndentation = FormatStyle::NI_None; 2031 Style.CompactNamespaces = true; 2032 verifyFormat("TESTSUITE(A) { TESTSUITE(B) {\n" 2033 "}} // TESTSUITE(A::B)", 2034 Style); 2035 2036 EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n" 2037 "}} // TESTSUITE(out::in)", 2038 format("TESTSUITE(out) {\n" 2039 "TESTSUITE(in) {\n" 2040 "} // TESTSUITE(in)\n" 2041 "} // TESTSUITE(out)", 2042 Style)); 2043 2044 EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n" 2045 "}} // TESTSUITE(out::in)", 2046 format("TESTSUITE(out) {\n" 2047 "TESTSUITE(in) {\n" 2048 "} // TESTSUITE(in)\n" 2049 "} // TESTSUITE(out)", 2050 Style)); 2051 2052 // Do not merge different namespaces/macros 2053 EXPECT_EQ("namespace out {\n" 2054 "TESTSUITE(in) {\n" 2055 "} // TESTSUITE(in)\n" 2056 "} // namespace out", 2057 format("namespace out {\n" 2058 "TESTSUITE(in) {\n" 2059 "} // TESTSUITE(in)\n" 2060 "} // namespace out", 2061 Style)); 2062 EXPECT_EQ("TESTSUITE(out) {\n" 2063 "namespace in {\n" 2064 "} // namespace in\n" 2065 "} // TESTSUITE(out)", 2066 format("TESTSUITE(out) {\n" 2067 "namespace in {\n" 2068 "} // namespace in\n" 2069 "} // TESTSUITE(out)", 2070 Style)); 2071 Style.NamespaceMacros.push_back("FOOBAR"); 2072 EXPECT_EQ("TESTSUITE(out) {\n" 2073 "FOOBAR(in) {\n" 2074 "} // FOOBAR(in)\n" 2075 "} // TESTSUITE(out)", 2076 format("TESTSUITE(out) {\n" 2077 "FOOBAR(in) {\n" 2078 "} // FOOBAR(in)\n" 2079 "} // TESTSUITE(out)", 2080 Style)); 2081 } 2082 2083 TEST_F(FormatTest, FormatsCompactNamespaces) { 2084 FormatStyle Style = getLLVMStyle(); 2085 Style.CompactNamespaces = true; 2086 Style.NamespaceMacros.push_back("TESTSUITE"); 2087 2088 verifyFormat("namespace A { namespace B {\n" 2089 "}} // namespace A::B", 2090 Style); 2091 2092 EXPECT_EQ("namespace out { namespace in {\n" 2093 "}} // namespace out::in", 2094 format("namespace out {\n" 2095 "namespace in {\n" 2096 "} // namespace in\n" 2097 "} // namespace out", 2098 Style)); 2099 2100 // Only namespaces which have both consecutive opening and end get compacted 2101 EXPECT_EQ("namespace out {\n" 2102 "namespace in1 {\n" 2103 "} // namespace in1\n" 2104 "namespace in2 {\n" 2105 "} // namespace in2\n" 2106 "} // namespace out", 2107 format("namespace out {\n" 2108 "namespace in1 {\n" 2109 "} // namespace in1\n" 2110 "namespace in2 {\n" 2111 "} // namespace in2\n" 2112 "} // namespace out", 2113 Style)); 2114 2115 EXPECT_EQ("namespace out {\n" 2116 "int i;\n" 2117 "namespace in {\n" 2118 "int j;\n" 2119 "} // namespace in\n" 2120 "int k;\n" 2121 "} // namespace out", 2122 format("namespace out { int i;\n" 2123 "namespace in { int j; } // namespace in\n" 2124 "int k; } // namespace out", 2125 Style)); 2126 2127 EXPECT_EQ("namespace A { namespace B { namespace C {\n" 2128 "}}} // namespace A::B::C\n", 2129 format("namespace A { namespace B {\n" 2130 "namespace C {\n" 2131 "}} // namespace B::C\n" 2132 "} // namespace A\n", 2133 Style)); 2134 2135 Style.ColumnLimit = 40; 2136 EXPECT_EQ("namespace aaaaaaaaaa {\n" 2137 "namespace bbbbbbbbbb {\n" 2138 "}} // namespace aaaaaaaaaa::bbbbbbbbbb", 2139 format("namespace aaaaaaaaaa {\n" 2140 "namespace bbbbbbbbbb {\n" 2141 "} // namespace bbbbbbbbbb\n" 2142 "} // namespace aaaaaaaaaa", 2143 Style)); 2144 2145 EXPECT_EQ("namespace aaaaaa { namespace bbbbbb {\n" 2146 "namespace cccccc {\n" 2147 "}}} // namespace aaaaaa::bbbbbb::cccccc", 2148 format("namespace aaaaaa {\n" 2149 "namespace bbbbbb {\n" 2150 "namespace cccccc {\n" 2151 "} // namespace cccccc\n" 2152 "} // namespace bbbbbb\n" 2153 "} // namespace aaaaaa", 2154 Style)); 2155 Style.ColumnLimit = 80; 2156 2157 // Extra semicolon after 'inner' closing brace prevents merging 2158 EXPECT_EQ("namespace out { namespace in {\n" 2159 "}; } // namespace out::in", 2160 format("namespace out {\n" 2161 "namespace in {\n" 2162 "}; // namespace in\n" 2163 "} // namespace out", 2164 Style)); 2165 2166 // Extra semicolon after 'outer' closing brace is conserved 2167 EXPECT_EQ("namespace out { namespace in {\n" 2168 "}}; // namespace out::in", 2169 format("namespace out {\n" 2170 "namespace in {\n" 2171 "} // namespace in\n" 2172 "}; // namespace out", 2173 Style)); 2174 2175 Style.NamespaceIndentation = FormatStyle::NI_All; 2176 EXPECT_EQ("namespace out { namespace in {\n" 2177 " int i;\n" 2178 "}} // namespace out::in", 2179 format("namespace out {\n" 2180 "namespace in {\n" 2181 "int i;\n" 2182 "} // namespace in\n" 2183 "} // namespace out", 2184 Style)); 2185 EXPECT_EQ("namespace out { namespace mid {\n" 2186 " namespace in {\n" 2187 " int j;\n" 2188 " } // namespace in\n" 2189 " int k;\n" 2190 "}} // namespace out::mid", 2191 format("namespace out { namespace mid {\n" 2192 "namespace in { int j; } // namespace in\n" 2193 "int k; }} // namespace out::mid", 2194 Style)); 2195 2196 Style.NamespaceIndentation = FormatStyle::NI_Inner; 2197 EXPECT_EQ("namespace out { namespace in {\n" 2198 " int i;\n" 2199 "}} // namespace out::in", 2200 format("namespace out {\n" 2201 "namespace in {\n" 2202 "int i;\n" 2203 "} // namespace in\n" 2204 "} // namespace out", 2205 Style)); 2206 EXPECT_EQ("namespace out { namespace mid { namespace in {\n" 2207 " int i;\n" 2208 "}}} // namespace out::mid::in", 2209 format("namespace out {\n" 2210 "namespace mid {\n" 2211 "namespace in {\n" 2212 "int i;\n" 2213 "} // namespace in\n" 2214 "} // namespace mid\n" 2215 "} // namespace out", 2216 Style)); 2217 } 2218 2219 TEST_F(FormatTest, FormatsExternC) { 2220 verifyFormat("extern \"C\" {\nint a;"); 2221 verifyFormat("extern \"C\" {}"); 2222 verifyFormat("extern \"C\" {\n" 2223 "int foo();\n" 2224 "}"); 2225 verifyFormat("extern \"C\" int foo() {}"); 2226 verifyFormat("extern \"C\" int foo();"); 2227 verifyFormat("extern \"C\" int foo() {\n" 2228 " int i = 42;\n" 2229 " return i;\n" 2230 "}"); 2231 2232 FormatStyle Style = getLLVMStyle(); 2233 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 2234 Style.BraceWrapping.AfterFunction = true; 2235 verifyFormat("extern \"C\" int foo() {}", Style); 2236 verifyFormat("extern \"C\" int foo();", Style); 2237 verifyFormat("extern \"C\" int foo()\n" 2238 "{\n" 2239 " int i = 42;\n" 2240 " return i;\n" 2241 "}", 2242 Style); 2243 2244 Style.BraceWrapping.AfterExternBlock = true; 2245 Style.BraceWrapping.SplitEmptyRecord = false; 2246 verifyFormat("extern \"C\"\n" 2247 "{}", 2248 Style); 2249 verifyFormat("extern \"C\"\n" 2250 "{\n" 2251 " int foo();\n" 2252 "}", 2253 Style); 2254 } 2255 2256 TEST_F(FormatTest, FormatsInlineASM) { 2257 verifyFormat("asm(\"xyz\" : \"=a\"(a), \"=d\"(b) : \"a\"(data));"); 2258 verifyFormat("asm(\"nop\" ::: \"memory\");"); 2259 verifyFormat( 2260 "asm(\"movq\\t%%rbx, %%rsi\\n\\t\"\n" 2261 " \"cpuid\\n\\t\"\n" 2262 " \"xchgq\\t%%rbx, %%rsi\\n\\t\"\n" 2263 " : \"=a\"(*rEAX), \"=S\"(*rEBX), \"=c\"(*rECX), \"=d\"(*rEDX)\n" 2264 " : \"a\"(value));"); 2265 EXPECT_EQ( 2266 "void NS_InvokeByIndex(void *that, unsigned int methodIndex) {\n" 2267 " __asm {\n" 2268 " mov edx,[that] // vtable in edx\n" 2269 " mov eax,methodIndex\n" 2270 " call [edx][eax*4] // stdcall\n" 2271 " }\n" 2272 "}", 2273 format("void NS_InvokeByIndex(void *that, unsigned int methodIndex) {\n" 2274 " __asm {\n" 2275 " mov edx,[that] // vtable in edx\n" 2276 " mov eax,methodIndex\n" 2277 " call [edx][eax*4] // stdcall\n" 2278 " }\n" 2279 "}")); 2280 EXPECT_EQ("_asm {\n" 2281 " xor eax, eax;\n" 2282 " cpuid;\n" 2283 "}", 2284 format("_asm {\n" 2285 " xor eax, eax;\n" 2286 " cpuid;\n" 2287 "}")); 2288 verifyFormat("void function() {\n" 2289 " // comment\n" 2290 " asm(\"\");\n" 2291 "}"); 2292 EXPECT_EQ("__asm {\n" 2293 "}\n" 2294 "int i;", 2295 format("__asm {\n" 2296 "}\n" 2297 "int i;")); 2298 } 2299 2300 TEST_F(FormatTest, FormatTryCatch) { 2301 verifyFormat("try {\n" 2302 " throw a * b;\n" 2303 "} catch (int a) {\n" 2304 " // Do nothing.\n" 2305 "} catch (...) {\n" 2306 " exit(42);\n" 2307 "}"); 2308 2309 // Function-level try statements. 2310 verifyFormat("int f() try { return 4; } catch (...) {\n" 2311 " return 5;\n" 2312 "}"); 2313 verifyFormat("class A {\n" 2314 " int a;\n" 2315 " A() try : a(0) {\n" 2316 " } catch (...) {\n" 2317 " throw;\n" 2318 " }\n" 2319 "};\n"); 2320 2321 // Incomplete try-catch blocks. 2322 verifyIncompleteFormat("try {} catch ("); 2323 } 2324 2325 TEST_F(FormatTest, FormatSEHTryCatch) { 2326 verifyFormat("__try {\n" 2327 " int a = b * c;\n" 2328 "} __except (EXCEPTION_EXECUTE_HANDLER) {\n" 2329 " // Do nothing.\n" 2330 "}"); 2331 2332 verifyFormat("__try {\n" 2333 " int a = b * c;\n" 2334 "} __finally {\n" 2335 " // Do nothing.\n" 2336 "}"); 2337 2338 verifyFormat("DEBUG({\n" 2339 " __try {\n" 2340 " } __finally {\n" 2341 " }\n" 2342 "});\n"); 2343 } 2344 2345 TEST_F(FormatTest, IncompleteTryCatchBlocks) { 2346 verifyFormat("try {\n" 2347 " f();\n" 2348 "} catch {\n" 2349 " g();\n" 2350 "}"); 2351 verifyFormat("try {\n" 2352 " f();\n" 2353 "} catch (A a) MACRO(x) {\n" 2354 " g();\n" 2355 "} catch (B b) MACRO(x) {\n" 2356 " g();\n" 2357 "}"); 2358 } 2359 2360 TEST_F(FormatTest, FormatTryCatchBraceStyles) { 2361 FormatStyle Style = getLLVMStyle(); 2362 for (auto BraceStyle : {FormatStyle::BS_Attach, FormatStyle::BS_Mozilla, 2363 FormatStyle::BS_WebKit}) { 2364 Style.BreakBeforeBraces = BraceStyle; 2365 verifyFormat("try {\n" 2366 " // something\n" 2367 "} catch (...) {\n" 2368 " // something\n" 2369 "}", 2370 Style); 2371 } 2372 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 2373 verifyFormat("try {\n" 2374 " // something\n" 2375 "}\n" 2376 "catch (...) {\n" 2377 " // something\n" 2378 "}", 2379 Style); 2380 verifyFormat("__try {\n" 2381 " // something\n" 2382 "}\n" 2383 "__finally {\n" 2384 " // something\n" 2385 "}", 2386 Style); 2387 verifyFormat("@try {\n" 2388 " // something\n" 2389 "}\n" 2390 "@finally {\n" 2391 " // something\n" 2392 "}", 2393 Style); 2394 Style.BreakBeforeBraces = FormatStyle::BS_Allman; 2395 verifyFormat("try\n" 2396 "{\n" 2397 " // something\n" 2398 "}\n" 2399 "catch (...)\n" 2400 "{\n" 2401 " // something\n" 2402 "}", 2403 Style); 2404 Style.BreakBeforeBraces = FormatStyle::BS_GNU; 2405 verifyFormat("try\n" 2406 " {\n" 2407 " // something\n" 2408 " }\n" 2409 "catch (...)\n" 2410 " {\n" 2411 " // something\n" 2412 " }", 2413 Style); 2414 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 2415 Style.BraceWrapping.BeforeCatch = true; 2416 verifyFormat("try {\n" 2417 " // something\n" 2418 "}\n" 2419 "catch (...) {\n" 2420 " // something\n" 2421 "}", 2422 Style); 2423 } 2424 2425 TEST_F(FormatTest, StaticInitializers) { 2426 verifyFormat("static SomeClass SC = {1, 'a'};"); 2427 2428 verifyFormat("static SomeClass WithALoooooooooooooooooooongName = {\n" 2429 " 100000000, " 2430 "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"};"); 2431 2432 // Here, everything other than the "}" would fit on a line. 2433 verifyFormat("static int LooooooooooooooooooooooooongVariable[1] = {\n" 2434 " 10000000000000000000000000};"); 2435 EXPECT_EQ("S s = {a,\n" 2436 "\n" 2437 " b};", 2438 format("S s = {\n" 2439 " a,\n" 2440 "\n" 2441 " b\n" 2442 "};")); 2443 2444 // FIXME: This would fit into the column limit if we'd fit "{ {" on the first 2445 // line. However, the formatting looks a bit off and this probably doesn't 2446 // happen often in practice. 2447 verifyFormat("static int Variable[1] = {\n" 2448 " {1000000000000000000000000000000000000}};", 2449 getLLVMStyleWithColumns(40)); 2450 } 2451 2452 TEST_F(FormatTest, DesignatedInitializers) { 2453 verifyFormat("const struct A a = {.a = 1, .b = 2};"); 2454 verifyFormat("const struct A a = {.aaaaaaaaaa = 1,\n" 2455 " .bbbbbbbbbb = 2,\n" 2456 " .cccccccccc = 3,\n" 2457 " .dddddddddd = 4,\n" 2458 " .eeeeeeeeee = 5};"); 2459 verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n" 2460 " .aaaaaaaaaaaaaaaaaaaaaaaaaaa = 1,\n" 2461 " .bbbbbbbbbbbbbbbbbbbbbbbbbbb = 2,\n" 2462 " .ccccccccccccccccccccccccccc = 3,\n" 2463 " .ddddddddddddddddddddddddddd = 4,\n" 2464 " .eeeeeeeeeeeeeeeeeeeeeeeeeee = 5};"); 2465 2466 verifyGoogleFormat("const struct A a = {.a = 1, .b = 2};"); 2467 2468 verifyFormat("const struct A a = {[0] = 1, [1] = 2};"); 2469 verifyFormat("const struct A a = {[1] = aaaaaaaaaa,\n" 2470 " [2] = bbbbbbbbbb,\n" 2471 " [3] = cccccccccc,\n" 2472 " [4] = dddddddddd,\n" 2473 " [5] = eeeeeeeeee};"); 2474 verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n" 2475 " [1] = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 2476 " [2] = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" 2477 " [3] = cccccccccccccccccccccccccccccccccccccc,\n" 2478 " [4] = dddddddddddddddddddddddddddddddddddddd,\n" 2479 " [5] = eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee};"); 2480 } 2481 2482 TEST_F(FormatTest, NestedStaticInitializers) { 2483 verifyFormat("static A x = {{{}}};\n"); 2484 verifyFormat("static A x = {{{init1, init2, init3, init4},\n" 2485 " {init1, init2, init3, init4}}};", 2486 getLLVMStyleWithColumns(50)); 2487 2488 verifyFormat("somes Status::global_reps[3] = {\n" 2489 " {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n" 2490 " {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n" 2491 " {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};", 2492 getLLVMStyleWithColumns(60)); 2493 verifyGoogleFormat("SomeType Status::global_reps[3] = {\n" 2494 " {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n" 2495 " {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n" 2496 " {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};"); 2497 verifyFormat("CGRect cg_rect = {{rect.fLeft, rect.fTop},\n" 2498 " {rect.fRight - rect.fLeft, rect.fBottom - " 2499 "rect.fTop}};"); 2500 2501 verifyFormat( 2502 "SomeArrayOfSomeType a = {\n" 2503 " {{1, 2, 3},\n" 2504 " {1, 2, 3},\n" 2505 " {111111111111111111111111111111, 222222222222222222222222222222,\n" 2506 " 333333333333333333333333333333},\n" 2507 " {1, 2, 3},\n" 2508 " {1, 2, 3}}};"); 2509 verifyFormat( 2510 "SomeArrayOfSomeType a = {\n" 2511 " {{1, 2, 3}},\n" 2512 " {{1, 2, 3}},\n" 2513 " {{111111111111111111111111111111, 222222222222222222222222222222,\n" 2514 " 333333333333333333333333333333}},\n" 2515 " {{1, 2, 3}},\n" 2516 " {{1, 2, 3}}};"); 2517 2518 verifyFormat("struct {\n" 2519 " unsigned bit;\n" 2520 " const char *const name;\n" 2521 "} kBitsToOs[] = {{kOsMac, \"Mac\"},\n" 2522 " {kOsWin, \"Windows\"},\n" 2523 " {kOsLinux, \"Linux\"},\n" 2524 " {kOsCrOS, \"Chrome OS\"}};"); 2525 verifyFormat("struct {\n" 2526 " unsigned bit;\n" 2527 " const char *const name;\n" 2528 "} kBitsToOs[] = {\n" 2529 " {kOsMac, \"Mac\"},\n" 2530 " {kOsWin, \"Windows\"},\n" 2531 " {kOsLinux, \"Linux\"},\n" 2532 " {kOsCrOS, \"Chrome OS\"},\n" 2533 "};"); 2534 } 2535 2536 TEST_F(FormatTest, FormatsSmallMacroDefinitionsInSingleLine) { 2537 verifyFormat("#define ALooooooooooooooooooooooooooooooooooooooongMacro(" 2538 " \\\n" 2539 " aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)"); 2540 } 2541 2542 TEST_F(FormatTest, DoesNotBreakPureVirtualFunctionDefinition) { 2543 verifyFormat("virtual void write(ELFWriter *writerrr,\n" 2544 " OwningPtr<FileOutputBuffer> &buffer) = 0;"); 2545 2546 // Do break defaulted and deleted functions. 2547 verifyFormat("virtual void ~Deeeeeeeestructor() =\n" 2548 " default;", 2549 getLLVMStyleWithColumns(40)); 2550 verifyFormat("virtual void ~Deeeeeeeestructor() =\n" 2551 " delete;", 2552 getLLVMStyleWithColumns(40)); 2553 } 2554 2555 TEST_F(FormatTest, BreaksStringLiteralsOnlyInDefine) { 2556 verifyFormat("# 1111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\" 2 3", 2557 getLLVMStyleWithColumns(40)); 2558 verifyFormat("#line 11111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"", 2559 getLLVMStyleWithColumns(40)); 2560 EXPECT_EQ("#define Q \\\n" 2561 " \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/\" \\\n" 2562 " \"aaaaaaaa.cpp\"", 2563 format("#define Q \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"", 2564 getLLVMStyleWithColumns(40))); 2565 } 2566 2567 TEST_F(FormatTest, UnderstandsLinePPDirective) { 2568 EXPECT_EQ("# 123 \"A string literal\"", 2569 format(" # 123 \"A string literal\"")); 2570 } 2571 2572 TEST_F(FormatTest, LayoutUnknownPPDirective) { 2573 EXPECT_EQ("#;", format("#;")); 2574 verifyFormat("#\n;\n;\n;"); 2575 } 2576 2577 TEST_F(FormatTest, UnescapedEndOfLineEndsPPDirective) { 2578 EXPECT_EQ("#line 42 \"test\"\n", 2579 format("# \\\n line \\\n 42 \\\n \"test\"\n")); 2580 EXPECT_EQ("#define A B\n", format("# \\\n define \\\n A \\\n B\n", 2581 getLLVMStyleWithColumns(12))); 2582 } 2583 2584 TEST_F(FormatTest, EndOfFileEndsPPDirective) { 2585 EXPECT_EQ("#line 42 \"test\"", 2586 format("# \\\n line \\\n 42 \\\n \"test\"")); 2587 EXPECT_EQ("#define A B", format("# \\\n define \\\n A \\\n B")); 2588 } 2589 2590 TEST_F(FormatTest, DoesntRemoveUnknownTokens) { 2591 verifyFormat("#define A \\x20"); 2592 verifyFormat("#define A \\ x20"); 2593 EXPECT_EQ("#define A \\ x20", format("#define A \\ x20")); 2594 verifyFormat("#define A ''"); 2595 verifyFormat("#define A ''qqq"); 2596 verifyFormat("#define A `qqq"); 2597 verifyFormat("f(\"aaaa, bbbb, \"\\\"ccccc\\\"\");"); 2598 EXPECT_EQ("const char *c = STRINGIFY(\n" 2599 "\\na : b);", 2600 format("const char * c = STRINGIFY(\n" 2601 "\\na : b);")); 2602 2603 verifyFormat("a\r\\"); 2604 verifyFormat("a\v\\"); 2605 verifyFormat("a\f\\"); 2606 } 2607 2608 TEST_F(FormatTest, IndentsPPDirectiveInReducedSpace) { 2609 verifyFormat("#define A(BB)", getLLVMStyleWithColumns(13)); 2610 verifyFormat("#define A( \\\n BB)", getLLVMStyleWithColumns(12)); 2611 verifyFormat("#define A( \\\n A, B)", getLLVMStyleWithColumns(12)); 2612 // FIXME: We never break before the macro name. 2613 verifyFormat("#define AA( \\\n B)", getLLVMStyleWithColumns(12)); 2614 2615 verifyFormat("#define A A\n#define A A"); 2616 verifyFormat("#define A(X) A\n#define A A"); 2617 2618 verifyFormat("#define Something Other", getLLVMStyleWithColumns(23)); 2619 verifyFormat("#define Something \\\n Other", getLLVMStyleWithColumns(22)); 2620 } 2621 2622 TEST_F(FormatTest, HandlePreprocessorDirectiveContext) { 2623 EXPECT_EQ("// somecomment\n" 2624 "#include \"a.h\"\n" 2625 "#define A( \\\n" 2626 " A, B)\n" 2627 "#include \"b.h\"\n" 2628 "// somecomment\n", 2629 format(" // somecomment\n" 2630 " #include \"a.h\"\n" 2631 "#define A(A,\\\n" 2632 " B)\n" 2633 " #include \"b.h\"\n" 2634 " // somecomment\n", 2635 getLLVMStyleWithColumns(13))); 2636 } 2637 2638 TEST_F(FormatTest, LayoutSingleHash) { EXPECT_EQ("#\na;", format("#\na;")); } 2639 2640 TEST_F(FormatTest, LayoutCodeInMacroDefinitions) { 2641 EXPECT_EQ("#define A \\\n" 2642 " c; \\\n" 2643 " e;\n" 2644 "f;", 2645 format("#define A c; e;\n" 2646 "f;", 2647 getLLVMStyleWithColumns(14))); 2648 } 2649 2650 TEST_F(FormatTest, LayoutRemainingTokens) { EXPECT_EQ("{}", format("{}")); } 2651 2652 TEST_F(FormatTest, MacroDefinitionInsideStatement) { 2653 EXPECT_EQ("int x,\n" 2654 "#define A\n" 2655 " y;", 2656 format("int x,\n#define A\ny;")); 2657 } 2658 2659 TEST_F(FormatTest, HashInMacroDefinition) { 2660 EXPECT_EQ("#define A(c) L#c", format("#define A(c) L#c", getLLVMStyle())); 2661 verifyFormat("#define A \\\n b #c;", getLLVMStyleWithColumns(11)); 2662 verifyFormat("#define A \\\n" 2663 " { \\\n" 2664 " f(#c); \\\n" 2665 " }", 2666 getLLVMStyleWithColumns(11)); 2667 2668 verifyFormat("#define A(X) \\\n" 2669 " void function##X()", 2670 getLLVMStyleWithColumns(22)); 2671 2672 verifyFormat("#define A(a, b, c) \\\n" 2673 " void a##b##c()", 2674 getLLVMStyleWithColumns(22)); 2675 2676 verifyFormat("#define A void # ## #", getLLVMStyleWithColumns(22)); 2677 } 2678 2679 TEST_F(FormatTest, RespectWhitespaceInMacroDefinitions) { 2680 EXPECT_EQ("#define A (x)", format("#define A (x)")); 2681 EXPECT_EQ("#define A(x)", format("#define A(x)")); 2682 2683 FormatStyle Style = getLLVMStyle(); 2684 Style.SpaceBeforeParens = FormatStyle::SBPO_Never; 2685 verifyFormat("#define true ((foo)1)", Style); 2686 Style.SpaceBeforeParens = FormatStyle::SBPO_Always; 2687 verifyFormat("#define false((foo)0)", Style); 2688 } 2689 2690 TEST_F(FormatTest, EmptyLinesInMacroDefinitions) { 2691 EXPECT_EQ("#define A b;", format("#define A \\\n" 2692 " \\\n" 2693 " b;", 2694 getLLVMStyleWithColumns(25))); 2695 EXPECT_EQ("#define A \\\n" 2696 " \\\n" 2697 " a; \\\n" 2698 " b;", 2699 format("#define A \\\n" 2700 " \\\n" 2701 " a; \\\n" 2702 " b;", 2703 getLLVMStyleWithColumns(11))); 2704 EXPECT_EQ("#define A \\\n" 2705 " a; \\\n" 2706 " \\\n" 2707 " b;", 2708 format("#define A \\\n" 2709 " a; \\\n" 2710 " \\\n" 2711 " b;", 2712 getLLVMStyleWithColumns(11))); 2713 } 2714 2715 TEST_F(FormatTest, MacroDefinitionsWithIncompleteCode) { 2716 verifyIncompleteFormat("#define A :"); 2717 verifyFormat("#define SOMECASES \\\n" 2718 " case 1: \\\n" 2719 " case 2\n", 2720 getLLVMStyleWithColumns(20)); 2721 verifyFormat("#define MACRO(a) \\\n" 2722 " if (a) \\\n" 2723 " f(); \\\n" 2724 " else \\\n" 2725 " g()", 2726 getLLVMStyleWithColumns(18)); 2727 verifyFormat("#define A template <typename T>"); 2728 verifyIncompleteFormat("#define STR(x) #x\n" 2729 "f(STR(this_is_a_string_literal{));"); 2730 verifyFormat("#pragma omp threadprivate( \\\n" 2731 " y)), // expected-warning", 2732 getLLVMStyleWithColumns(28)); 2733 verifyFormat("#d, = };"); 2734 verifyFormat("#if \"a"); 2735 verifyIncompleteFormat("({\n" 2736 "#define b \\\n" 2737 " } \\\n" 2738 " a\n" 2739 "a", 2740 getLLVMStyleWithColumns(15)); 2741 verifyFormat("#define A \\\n" 2742 " { \\\n" 2743 " {\n" 2744 "#define B \\\n" 2745 " } \\\n" 2746 " }", 2747 getLLVMStyleWithColumns(15)); 2748 verifyNoCrash("#if a\na(\n#else\n#endif\n{a"); 2749 verifyNoCrash("a={0,1\n#if a\n#else\n;\n#endif\n}"); 2750 verifyNoCrash("#if a\na(\n#else\n#endif\n) a {a,b,c,d,f,g};"); 2751 verifyNoCrash("#ifdef A\n a(\n #else\n #endif\n) = []() { \n)}"); 2752 } 2753 2754 TEST_F(FormatTest, MacrosWithoutTrailingSemicolon) { 2755 verifyFormat("SOME_TYPE_NAME abc;"); // Gated on the newline. 2756 EXPECT_EQ("class A : public QObject {\n" 2757 " Q_OBJECT\n" 2758 "\n" 2759 " A() {}\n" 2760 "};", 2761 format("class A : public QObject {\n" 2762 " Q_OBJECT\n" 2763 "\n" 2764 " A() {\n}\n" 2765 "} ;")); 2766 EXPECT_EQ("MACRO\n" 2767 "/*static*/ int i;", 2768 format("MACRO\n" 2769 " /*static*/ int i;")); 2770 EXPECT_EQ("SOME_MACRO\n" 2771 "namespace {\n" 2772 "void f();\n" 2773 "} // namespace", 2774 format("SOME_MACRO\n" 2775 " namespace {\n" 2776 "void f( );\n" 2777 "} // namespace")); 2778 // Only if the identifier contains at least 5 characters. 2779 EXPECT_EQ("HTTP f();", format("HTTP\nf();")); 2780 EXPECT_EQ("MACRO\nf();", format("MACRO\nf();")); 2781 // Only if everything is upper case. 2782 EXPECT_EQ("class A : public QObject {\n" 2783 " Q_Object A() {}\n" 2784 "};", 2785 format("class A : public QObject {\n" 2786 " Q_Object\n" 2787 " A() {\n}\n" 2788 "} ;")); 2789 2790 // Only if the next line can actually start an unwrapped line. 2791 EXPECT_EQ("SOME_WEIRD_LOG_MACRO << SomeThing;", 2792 format("SOME_WEIRD_LOG_MACRO\n" 2793 "<< SomeThing;")); 2794 2795 verifyFormat("VISIT_GL_CALL(GenBuffers, void, (GLsizei n, GLuint* buffers), " 2796 "(n, buffers))\n", 2797 getChromiumStyle(FormatStyle::LK_Cpp)); 2798 2799 // See PR41483 2800 EXPECT_EQ("/**/ FOO(a)\n" 2801 "FOO(b)", 2802 format("/**/ FOO(a)\n" 2803 "FOO(b)")); 2804 } 2805 2806 TEST_F(FormatTest, MacroCallsWithoutTrailingSemicolon) { 2807 EXPECT_EQ("INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n" 2808 "INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n" 2809 "INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n" 2810 "class X {};\n" 2811 "INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n" 2812 "int *createScopDetectionPass() { return 0; }", 2813 format(" INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n" 2814 " INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n" 2815 " INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n" 2816 " class X {};\n" 2817 " INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n" 2818 " int *createScopDetectionPass() { return 0; }")); 2819 // FIXME: We could probably treat IPC_BEGIN_MESSAGE_MAP/IPC_END_MESSAGE_MAP as 2820 // braces, so that inner block is indented one level more. 2821 EXPECT_EQ("int q() {\n" 2822 " IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n" 2823 " IPC_MESSAGE_HANDLER(xxx, qqq)\n" 2824 " IPC_END_MESSAGE_MAP()\n" 2825 "}", 2826 format("int q() {\n" 2827 " IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n" 2828 " IPC_MESSAGE_HANDLER(xxx, qqq)\n" 2829 " IPC_END_MESSAGE_MAP()\n" 2830 "}")); 2831 2832 // Same inside macros. 2833 EXPECT_EQ("#define LIST(L) \\\n" 2834 " L(A) \\\n" 2835 " L(B) \\\n" 2836 " L(C)", 2837 format("#define LIST(L) \\\n" 2838 " L(A) \\\n" 2839 " L(B) \\\n" 2840 " L(C)", 2841 getGoogleStyle())); 2842 2843 // These must not be recognized as macros. 2844 EXPECT_EQ("int q() {\n" 2845 " f(x);\n" 2846 " f(x) {}\n" 2847 " f(x)->g();\n" 2848 " f(x)->*g();\n" 2849 " f(x).g();\n" 2850 " f(x) = x;\n" 2851 " f(x) += x;\n" 2852 " f(x) -= x;\n" 2853 " f(x) *= x;\n" 2854 " f(x) /= x;\n" 2855 " f(x) %= x;\n" 2856 " f(x) &= x;\n" 2857 " f(x) |= x;\n" 2858 " f(x) ^= x;\n" 2859 " f(x) >>= x;\n" 2860 " f(x) <<= x;\n" 2861 " f(x)[y].z();\n" 2862 " LOG(INFO) << x;\n" 2863 " ifstream(x) >> x;\n" 2864 "}\n", 2865 format("int q() {\n" 2866 " f(x)\n;\n" 2867 " f(x)\n {}\n" 2868 " f(x)\n->g();\n" 2869 " f(x)\n->*g();\n" 2870 " f(x)\n.g();\n" 2871 " f(x)\n = x;\n" 2872 " f(x)\n += x;\n" 2873 " f(x)\n -= x;\n" 2874 " f(x)\n *= x;\n" 2875 " f(x)\n /= x;\n" 2876 " f(x)\n %= x;\n" 2877 " f(x)\n &= x;\n" 2878 " f(x)\n |= x;\n" 2879 " f(x)\n ^= x;\n" 2880 " f(x)\n >>= x;\n" 2881 " f(x)\n <<= x;\n" 2882 " f(x)\n[y].z();\n" 2883 " LOG(INFO)\n << x;\n" 2884 " ifstream(x)\n >> x;\n" 2885 "}\n")); 2886 EXPECT_EQ("int q() {\n" 2887 " F(x)\n" 2888 " if (1) {\n" 2889 " }\n" 2890 " F(x)\n" 2891 " while (1) {\n" 2892 " }\n" 2893 " F(x)\n" 2894 " G(x);\n" 2895 " F(x)\n" 2896 " try {\n" 2897 " Q();\n" 2898 " } catch (...) {\n" 2899 " }\n" 2900 "}\n", 2901 format("int q() {\n" 2902 "F(x)\n" 2903 "if (1) {}\n" 2904 "F(x)\n" 2905 "while (1) {}\n" 2906 "F(x)\n" 2907 "G(x);\n" 2908 "F(x)\n" 2909 "try { Q(); } catch (...) {}\n" 2910 "}\n")); 2911 EXPECT_EQ("class A {\n" 2912 " A() : t(0) {}\n" 2913 " A(int i) noexcept() : {}\n" 2914 " A(X x)\n" // FIXME: function-level try blocks are broken. 2915 " try : t(0) {\n" 2916 " } catch (...) {\n" 2917 " }\n" 2918 "};", 2919 format("class A {\n" 2920 " A()\n : t(0) {}\n" 2921 " A(int i)\n noexcept() : {}\n" 2922 " A(X x)\n" 2923 " try : t(0) {} catch (...) {}\n" 2924 "};")); 2925 FormatStyle Style = getLLVMStyle(); 2926 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 2927 Style.BraceWrapping.AfterControlStatement = true; 2928 Style.BraceWrapping.AfterFunction = true; 2929 EXPECT_EQ("void f()\n" 2930 "try\n" 2931 "{\n" 2932 "}", 2933 format("void f() try {\n" 2934 "}", Style)); 2935 EXPECT_EQ("class SomeClass {\n" 2936 "public:\n" 2937 " SomeClass() EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 2938 "};", 2939 format("class SomeClass {\n" 2940 "public:\n" 2941 " SomeClass()\n" 2942 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 2943 "};")); 2944 EXPECT_EQ("class SomeClass {\n" 2945 "public:\n" 2946 " SomeClass()\n" 2947 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 2948 "};", 2949 format("class SomeClass {\n" 2950 "public:\n" 2951 " SomeClass()\n" 2952 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 2953 "};", 2954 getLLVMStyleWithColumns(40))); 2955 2956 verifyFormat("MACRO(>)"); 2957 2958 // Some macros contain an implicit semicolon. 2959 Style = getLLVMStyle(); 2960 Style.StatementMacros.push_back("FOO"); 2961 verifyFormat("FOO(a) int b = 0;"); 2962 verifyFormat("FOO(a)\n" 2963 "int b = 0;", 2964 Style); 2965 verifyFormat("FOO(a);\n" 2966 "int b = 0;", 2967 Style); 2968 verifyFormat("FOO(argc, argv, \"4.0.2\")\n" 2969 "int b = 0;", 2970 Style); 2971 verifyFormat("FOO()\n" 2972 "int b = 0;", 2973 Style); 2974 verifyFormat("FOO\n" 2975 "int b = 0;", 2976 Style); 2977 verifyFormat("void f() {\n" 2978 " FOO(a)\n" 2979 " return a;\n" 2980 "}", 2981 Style); 2982 verifyFormat("FOO(a)\n" 2983 "FOO(b)", 2984 Style); 2985 verifyFormat("int a = 0;\n" 2986 "FOO(b)\n" 2987 "int c = 0;", 2988 Style); 2989 verifyFormat("int a = 0;\n" 2990 "int x = FOO(a)\n" 2991 "int b = 0;", 2992 Style); 2993 verifyFormat("void foo(int a) { FOO(a) }\n" 2994 "uint32_t bar() {}", 2995 Style); 2996 } 2997 2998 TEST_F(FormatTest, LayoutMacroDefinitionsStatementsSpanningBlocks) { 2999 verifyFormat("#define A \\\n" 3000 " f({ \\\n" 3001 " g(); \\\n" 3002 " });", 3003 getLLVMStyleWithColumns(11)); 3004 } 3005 3006 TEST_F(FormatTest, IndentPreprocessorDirectives) { 3007 FormatStyle Style = getLLVMStyle(); 3008 Style.IndentPPDirectives = FormatStyle::PPDIS_None; 3009 Style.ColumnLimit = 40; 3010 verifyFormat("#ifdef _WIN32\n" 3011 "#define A 0\n" 3012 "#ifdef VAR2\n" 3013 "#define B 1\n" 3014 "#include <someheader.h>\n" 3015 "#define MACRO \\\n" 3016 " some_very_long_func_aaaaaaaaaa();\n" 3017 "#endif\n" 3018 "#else\n" 3019 "#define A 1\n" 3020 "#endif", 3021 Style); 3022 Style.IndentPPDirectives = FormatStyle::PPDIS_AfterHash; 3023 verifyFormat("#ifdef _WIN32\n" 3024 "# define A 0\n" 3025 "# ifdef VAR2\n" 3026 "# define B 1\n" 3027 "# include <someheader.h>\n" 3028 "# define MACRO \\\n" 3029 " some_very_long_func_aaaaaaaaaa();\n" 3030 "# endif\n" 3031 "#else\n" 3032 "# define A 1\n" 3033 "#endif", 3034 Style); 3035 verifyFormat("#if A\n" 3036 "# define MACRO \\\n" 3037 " void a(int x) { \\\n" 3038 " b(); \\\n" 3039 " c(); \\\n" 3040 " d(); \\\n" 3041 " e(); \\\n" 3042 " f(); \\\n" 3043 " }\n" 3044 "#endif", 3045 Style); 3046 // Comments before include guard. 3047 verifyFormat("// file comment\n" 3048 "// file comment\n" 3049 "#ifndef HEADER_H\n" 3050 "#define HEADER_H\n" 3051 "code();\n" 3052 "#endif", 3053 Style); 3054 // Test with include guards. 3055 verifyFormat("#ifndef HEADER_H\n" 3056 "#define HEADER_H\n" 3057 "code();\n" 3058 "#endif", 3059 Style); 3060 // Include guards must have a #define with the same variable immediately 3061 // after #ifndef. 3062 verifyFormat("#ifndef NOT_GUARD\n" 3063 "# define FOO\n" 3064 "code();\n" 3065 "#endif", 3066 Style); 3067 3068 // Include guards must cover the entire file. 3069 verifyFormat("code();\n" 3070 "code();\n" 3071 "#ifndef NOT_GUARD\n" 3072 "# define NOT_GUARD\n" 3073 "code();\n" 3074 "#endif", 3075 Style); 3076 verifyFormat("#ifndef NOT_GUARD\n" 3077 "# define NOT_GUARD\n" 3078 "code();\n" 3079 "#endif\n" 3080 "code();", 3081 Style); 3082 // Test with trailing blank lines. 3083 verifyFormat("#ifndef HEADER_H\n" 3084 "#define HEADER_H\n" 3085 "code();\n" 3086 "#endif\n", 3087 Style); 3088 // Include guards don't have #else. 3089 verifyFormat("#ifndef NOT_GUARD\n" 3090 "# define NOT_GUARD\n" 3091 "code();\n" 3092 "#else\n" 3093 "#endif", 3094 Style); 3095 verifyFormat("#ifndef NOT_GUARD\n" 3096 "# define NOT_GUARD\n" 3097 "code();\n" 3098 "#elif FOO\n" 3099 "#endif", 3100 Style); 3101 // Non-identifier #define after potential include guard. 3102 verifyFormat("#ifndef FOO\n" 3103 "# define 1\n" 3104 "#endif\n", 3105 Style); 3106 // #if closes past last non-preprocessor line. 3107 verifyFormat("#ifndef FOO\n" 3108 "#define FOO\n" 3109 "#if 1\n" 3110 "int i;\n" 3111 "# define A 0\n" 3112 "#endif\n" 3113 "#endif\n", 3114 Style); 3115 // Don't crash if there is an #elif directive without a condition. 3116 verifyFormat("#if 1\n" 3117 "int x;\n" 3118 "#elif\n" 3119 "int y;\n" 3120 "#else\n" 3121 "int z;\n" 3122 "#endif", 3123 Style); 3124 // FIXME: This doesn't handle the case where there's code between the 3125 // #ifndef and #define but all other conditions hold. This is because when 3126 // the #define line is parsed, UnwrappedLineParser::Lines doesn't hold the 3127 // previous code line yet, so we can't detect it. 3128 EXPECT_EQ("#ifndef NOT_GUARD\n" 3129 "code();\n" 3130 "#define NOT_GUARD\n" 3131 "code();\n" 3132 "#endif", 3133 format("#ifndef NOT_GUARD\n" 3134 "code();\n" 3135 "# define NOT_GUARD\n" 3136 "code();\n" 3137 "#endif", 3138 Style)); 3139 // FIXME: This doesn't handle cases where legitimate preprocessor lines may 3140 // be outside an include guard. Examples are #pragma once and 3141 // #pragma GCC diagnostic, or anything else that does not change the meaning 3142 // of the file if it's included multiple times. 3143 EXPECT_EQ("#ifdef WIN32\n" 3144 "# pragma once\n" 3145 "#endif\n" 3146 "#ifndef HEADER_H\n" 3147 "# define HEADER_H\n" 3148 "code();\n" 3149 "#endif", 3150 format("#ifdef WIN32\n" 3151 "# pragma once\n" 3152 "#endif\n" 3153 "#ifndef HEADER_H\n" 3154 "#define HEADER_H\n" 3155 "code();\n" 3156 "#endif", 3157 Style)); 3158 // FIXME: This does not detect when there is a single non-preprocessor line 3159 // in front of an include-guard-like structure where other conditions hold 3160 // because ScopedLineState hides the line. 3161 EXPECT_EQ("code();\n" 3162 "#ifndef HEADER_H\n" 3163 "#define HEADER_H\n" 3164 "code();\n" 3165 "#endif", 3166 format("code();\n" 3167 "#ifndef HEADER_H\n" 3168 "# define HEADER_H\n" 3169 "code();\n" 3170 "#endif", 3171 Style)); 3172 // Keep comments aligned with #, otherwise indent comments normally. These 3173 // tests cannot use verifyFormat because messUp manipulates leading 3174 // whitespace. 3175 { 3176 const char *Expected = "" 3177 "void f() {\n" 3178 "#if 1\n" 3179 "// Preprocessor aligned.\n" 3180 "# define A 0\n" 3181 " // Code. Separated by blank line.\n" 3182 "\n" 3183 "# define B 0\n" 3184 " // Code. Not aligned with #\n" 3185 "# define C 0\n" 3186 "#endif"; 3187 const char *ToFormat = "" 3188 "void f() {\n" 3189 "#if 1\n" 3190 "// Preprocessor aligned.\n" 3191 "# define A 0\n" 3192 "// Code. Separated by blank line.\n" 3193 "\n" 3194 "# define B 0\n" 3195 " // Code. Not aligned with #\n" 3196 "# define C 0\n" 3197 "#endif"; 3198 EXPECT_EQ(Expected, format(ToFormat, Style)); 3199 EXPECT_EQ(Expected, format(Expected, Style)); 3200 } 3201 // Keep block quotes aligned. 3202 { 3203 const char *Expected = "" 3204 "void f() {\n" 3205 "#if 1\n" 3206 "/* Preprocessor aligned. */\n" 3207 "# define A 0\n" 3208 " /* Code. Separated by blank line. */\n" 3209 "\n" 3210 "# define B 0\n" 3211 " /* Code. Not aligned with # */\n" 3212 "# define C 0\n" 3213 "#endif"; 3214 const char *ToFormat = "" 3215 "void f() {\n" 3216 "#if 1\n" 3217 "/* Preprocessor aligned. */\n" 3218 "# define A 0\n" 3219 "/* Code. Separated by blank line. */\n" 3220 "\n" 3221 "# define B 0\n" 3222 " /* Code. Not aligned with # */\n" 3223 "# define C 0\n" 3224 "#endif"; 3225 EXPECT_EQ(Expected, format(ToFormat, Style)); 3226 EXPECT_EQ(Expected, format(Expected, Style)); 3227 } 3228 // Keep comments aligned with un-indented directives. 3229 { 3230 const char *Expected = "" 3231 "void f() {\n" 3232 "// Preprocessor aligned.\n" 3233 "#define A 0\n" 3234 " // Code. Separated by blank line.\n" 3235 "\n" 3236 "#define B 0\n" 3237 " // Code. Not aligned with #\n" 3238 "#define C 0\n"; 3239 const char *ToFormat = "" 3240 "void f() {\n" 3241 "// Preprocessor aligned.\n" 3242 "#define A 0\n" 3243 "// Code. Separated by blank line.\n" 3244 "\n" 3245 "#define B 0\n" 3246 " // Code. Not aligned with #\n" 3247 "#define C 0\n"; 3248 EXPECT_EQ(Expected, format(ToFormat, Style)); 3249 EXPECT_EQ(Expected, format(Expected, Style)); 3250 } 3251 // Test AfterHash with tabs. 3252 { 3253 FormatStyle Tabbed = Style; 3254 Tabbed.UseTab = FormatStyle::UT_Always; 3255 Tabbed.IndentWidth = 8; 3256 Tabbed.TabWidth = 8; 3257 verifyFormat("#ifdef _WIN32\n" 3258 "#\tdefine A 0\n" 3259 "#\tifdef VAR2\n" 3260 "#\t\tdefine B 1\n" 3261 "#\t\tinclude <someheader.h>\n" 3262 "#\t\tdefine MACRO \\\n" 3263 "\t\t\tsome_very_long_func_aaaaaaaaaa();\n" 3264 "#\tendif\n" 3265 "#else\n" 3266 "#\tdefine A 1\n" 3267 "#endif", 3268 Tabbed); 3269 } 3270 3271 // Regression test: Multiline-macro inside include guards. 3272 verifyFormat("#ifndef HEADER_H\n" 3273 "#define HEADER_H\n" 3274 "#define A() \\\n" 3275 " int i; \\\n" 3276 " int j;\n" 3277 "#endif // HEADER_H", 3278 getLLVMStyleWithColumns(20)); 3279 3280 Style.IndentPPDirectives = FormatStyle::PPDIS_BeforeHash; 3281 // Basic before hash indent tests 3282 verifyFormat("#ifdef _WIN32\n" 3283 " #define A 0\n" 3284 " #ifdef VAR2\n" 3285 " #define B 1\n" 3286 " #include <someheader.h>\n" 3287 " #define MACRO \\\n" 3288 " some_very_long_func_aaaaaaaaaa();\n" 3289 " #endif\n" 3290 "#else\n" 3291 " #define A 1\n" 3292 "#endif", 3293 Style); 3294 verifyFormat("#if A\n" 3295 " #define MACRO \\\n" 3296 " void a(int x) { \\\n" 3297 " b(); \\\n" 3298 " c(); \\\n" 3299 " d(); \\\n" 3300 " e(); \\\n" 3301 " f(); \\\n" 3302 " }\n" 3303 "#endif", 3304 Style); 3305 // Keep comments aligned with indented directives. These 3306 // tests cannot use verifyFormat because messUp manipulates leading 3307 // whitespace. 3308 { 3309 const char *Expected = "void f() {\n" 3310 "// Aligned to preprocessor.\n" 3311 "#if 1\n" 3312 " // Aligned to code.\n" 3313 " int a;\n" 3314 " #if 1\n" 3315 " // Aligned to preprocessor.\n" 3316 " #define A 0\n" 3317 " // Aligned to code.\n" 3318 " int b;\n" 3319 " #endif\n" 3320 "#endif\n" 3321 "}"; 3322 const char *ToFormat = "void f() {\n" 3323 "// Aligned to preprocessor.\n" 3324 "#if 1\n" 3325 "// Aligned to code.\n" 3326 "int a;\n" 3327 "#if 1\n" 3328 "// Aligned to preprocessor.\n" 3329 "#define A 0\n" 3330 "// Aligned to code.\n" 3331 "int b;\n" 3332 "#endif\n" 3333 "#endif\n" 3334 "}"; 3335 EXPECT_EQ(Expected, format(ToFormat, Style)); 3336 EXPECT_EQ(Expected, format(Expected, Style)); 3337 } 3338 { 3339 const char *Expected = "void f() {\n" 3340 "/* Aligned to preprocessor. */\n" 3341 "#if 1\n" 3342 " /* Aligned to code. */\n" 3343 " int a;\n" 3344 " #if 1\n" 3345 " /* Aligned to preprocessor. */\n" 3346 " #define A 0\n" 3347 " /* Aligned to code. */\n" 3348 " int b;\n" 3349 " #endif\n" 3350 "#endif\n" 3351 "}"; 3352 const char *ToFormat = "void f() {\n" 3353 "/* Aligned to preprocessor. */\n" 3354 "#if 1\n" 3355 "/* Aligned to code. */\n" 3356 "int a;\n" 3357 "#if 1\n" 3358 "/* Aligned to preprocessor. */\n" 3359 "#define A 0\n" 3360 "/* Aligned to code. */\n" 3361 "int b;\n" 3362 "#endif\n" 3363 "#endif\n" 3364 "}"; 3365 EXPECT_EQ(Expected, format(ToFormat, Style)); 3366 EXPECT_EQ(Expected, format(Expected, Style)); 3367 } 3368 3369 // Test single comment before preprocessor 3370 verifyFormat("// Comment\n" 3371 "\n" 3372 "#if 1\n" 3373 "#endif", 3374 Style); 3375 } 3376 3377 TEST_F(FormatTest, FormatHashIfNotAtStartOfLine) { 3378 verifyFormat("{\n { a #c; }\n}"); 3379 } 3380 3381 TEST_F(FormatTest, FormatUnbalancedStructuralElements) { 3382 EXPECT_EQ("#define A \\\n { \\\n {\nint i;", 3383 format("#define A { {\nint i;", getLLVMStyleWithColumns(11))); 3384 EXPECT_EQ("#define A \\\n } \\\n }\nint i;", 3385 format("#define A } }\nint i;", getLLVMStyleWithColumns(11))); 3386 } 3387 3388 TEST_F(FormatTest, EscapedNewlines) { 3389 FormatStyle Narrow = getLLVMStyleWithColumns(11); 3390 EXPECT_EQ("#define A \\\n int i; \\\n int j;", 3391 format("#define A \\\nint i;\\\n int j;", Narrow)); 3392 EXPECT_EQ("#define A\n\nint i;", format("#define A \\\n\n int i;")); 3393 EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();")); 3394 EXPECT_EQ("/* \\ \\ \\\n */", format("\\\n/* \\ \\ \\\n */")); 3395 EXPECT_EQ("<a\n\\\\\n>", format("<a\n\\\\\n>")); 3396 3397 FormatStyle AlignLeft = getLLVMStyle(); 3398 AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left; 3399 EXPECT_EQ("#define MACRO(x) \\\n" 3400 "private: \\\n" 3401 " int x(int a);\n", 3402 format("#define MACRO(x) \\\n" 3403 "private: \\\n" 3404 " int x(int a);\n", 3405 AlignLeft)); 3406 3407 // CRLF line endings 3408 EXPECT_EQ("#define A \\\r\n int i; \\\r\n int j;", 3409 format("#define A \\\r\nint i;\\\r\n int j;", Narrow)); 3410 EXPECT_EQ("#define A\r\n\r\nint i;", format("#define A \\\r\n\r\n int i;")); 3411 EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();")); 3412 EXPECT_EQ("/* \\ \\ \\\r\n */", format("\\\r\n/* \\ \\ \\\r\n */")); 3413 EXPECT_EQ("<a\r\n\\\\\r\n>", format("<a\r\n\\\\\r\n>")); 3414 EXPECT_EQ("#define MACRO(x) \\\r\n" 3415 "private: \\\r\n" 3416 " int x(int a);\r\n", 3417 format("#define MACRO(x) \\\r\n" 3418 "private: \\\r\n" 3419 " int x(int a);\r\n", 3420 AlignLeft)); 3421 3422 FormatStyle DontAlign = getLLVMStyle(); 3423 DontAlign.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign; 3424 DontAlign.MaxEmptyLinesToKeep = 3; 3425 // FIXME: can't use verifyFormat here because the newline before 3426 // "public:" is not inserted the first time it's reformatted 3427 EXPECT_EQ("#define A \\\n" 3428 " class Foo { \\\n" 3429 " void bar(); \\\n" 3430 "\\\n" 3431 "\\\n" 3432 "\\\n" 3433 " public: \\\n" 3434 " void baz(); \\\n" 3435 " };", 3436 format("#define A \\\n" 3437 " class Foo { \\\n" 3438 " void bar(); \\\n" 3439 "\\\n" 3440 "\\\n" 3441 "\\\n" 3442 " public: \\\n" 3443 " void baz(); \\\n" 3444 " };", 3445 DontAlign)); 3446 } 3447 3448 TEST_F(FormatTest, CalculateSpaceOnConsecutiveLinesInMacro) { 3449 verifyFormat("#define A \\\n" 3450 " int v( \\\n" 3451 " a); \\\n" 3452 " int i;", 3453 getLLVMStyleWithColumns(11)); 3454 } 3455 3456 TEST_F(FormatTest, MixingPreprocessorDirectivesAndNormalCode) { 3457 EXPECT_EQ( 3458 "#define ALooooooooooooooooooooooooooooooooooooooongMacro(" 3459 " \\\n" 3460 " aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n" 3461 "\n" 3462 "AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n" 3463 " aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n", 3464 format(" #define ALooooooooooooooooooooooooooooooooooooooongMacro(" 3465 "\\\n" 3466 "aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n" 3467 " \n" 3468 " AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n" 3469 " aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n")); 3470 } 3471 3472 TEST_F(FormatTest, LayoutStatementsAroundPreprocessorDirectives) { 3473 EXPECT_EQ("int\n" 3474 "#define A\n" 3475 " a;", 3476 format("int\n#define A\na;")); 3477 verifyFormat("functionCallTo(\n" 3478 " someOtherFunction(\n" 3479 " withSomeParameters, whichInSequence,\n" 3480 " areLongerThanALine(andAnotherCall,\n" 3481 "#define A B\n" 3482 " withMoreParamters,\n" 3483 " whichStronglyInfluenceTheLayout),\n" 3484 " andMoreParameters),\n" 3485 " trailing);", 3486 getLLVMStyleWithColumns(69)); 3487 verifyFormat("Foo::Foo()\n" 3488 "#ifdef BAR\n" 3489 " : baz(0)\n" 3490 "#endif\n" 3491 "{\n" 3492 "}"); 3493 verifyFormat("void f() {\n" 3494 " if (true)\n" 3495 "#ifdef A\n" 3496 " f(42);\n" 3497 " x();\n" 3498 "#else\n" 3499 " g();\n" 3500 " x();\n" 3501 "#endif\n" 3502 "}"); 3503 verifyFormat("void f(param1, param2,\n" 3504 " param3,\n" 3505 "#ifdef A\n" 3506 " param4(param5,\n" 3507 "#ifdef A1\n" 3508 " param6,\n" 3509 "#ifdef A2\n" 3510 " param7),\n" 3511 "#else\n" 3512 " param8),\n" 3513 " param9,\n" 3514 "#endif\n" 3515 " param10,\n" 3516 "#endif\n" 3517 " param11)\n" 3518 "#else\n" 3519 " param12)\n" 3520 "#endif\n" 3521 "{\n" 3522 " x();\n" 3523 "}", 3524 getLLVMStyleWithColumns(28)); 3525 verifyFormat("#if 1\n" 3526 "int i;"); 3527 verifyFormat("#if 1\n" 3528 "#endif\n" 3529 "#if 1\n" 3530 "#else\n" 3531 "#endif\n"); 3532 verifyFormat("DEBUG({\n" 3533 " return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3534 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n" 3535 "});\n" 3536 "#if a\n" 3537 "#else\n" 3538 "#endif"); 3539 3540 verifyIncompleteFormat("void f(\n" 3541 "#if A\n" 3542 ");\n" 3543 "#else\n" 3544 "#endif"); 3545 } 3546 3547 TEST_F(FormatTest, GraciouslyHandleIncorrectPreprocessorConditions) { 3548 verifyFormat("#endif\n" 3549 "#if B"); 3550 } 3551 3552 TEST_F(FormatTest, FormatsJoinedLinesOnSubsequentRuns) { 3553 FormatStyle SingleLine = getLLVMStyle(); 3554 SingleLine.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_WithoutElse; 3555 verifyFormat("#if 0\n" 3556 "#elif 1\n" 3557 "#endif\n" 3558 "void foo() {\n" 3559 " if (test) foo2();\n" 3560 "}", 3561 SingleLine); 3562 } 3563 3564 TEST_F(FormatTest, LayoutBlockInsideParens) { 3565 verifyFormat("functionCall({ int i; });"); 3566 verifyFormat("functionCall({\n" 3567 " int i;\n" 3568 " int j;\n" 3569 "});"); 3570 verifyFormat("functionCall(\n" 3571 " {\n" 3572 " int i;\n" 3573 " int j;\n" 3574 " },\n" 3575 " aaaa, bbbb, cccc);"); 3576 verifyFormat("functionA(functionB({\n" 3577 " int i;\n" 3578 " int j;\n" 3579 " }),\n" 3580 " aaaa, bbbb, cccc);"); 3581 verifyFormat("functionCall(\n" 3582 " {\n" 3583 " int i;\n" 3584 " int j;\n" 3585 " },\n" 3586 " aaaa, bbbb, // comment\n" 3587 " cccc);"); 3588 verifyFormat("functionA(functionB({\n" 3589 " int i;\n" 3590 " int j;\n" 3591 " }),\n" 3592 " aaaa, bbbb, // comment\n" 3593 " cccc);"); 3594 verifyFormat("functionCall(aaaa, bbbb, { int i; });"); 3595 verifyFormat("functionCall(aaaa, bbbb, {\n" 3596 " int i;\n" 3597 " int j;\n" 3598 "});"); 3599 verifyFormat( 3600 "Aaa(\n" // FIXME: There shouldn't be a linebreak here. 3601 " {\n" 3602 " int i; // break\n" 3603 " },\n" 3604 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" 3605 " ccccccccccccccccc));"); 3606 verifyFormat("DEBUG({\n" 3607 " if (a)\n" 3608 " f();\n" 3609 "});"); 3610 } 3611 3612 TEST_F(FormatTest, LayoutBlockInsideStatement) { 3613 EXPECT_EQ("SOME_MACRO { int i; }\n" 3614 "int i;", 3615 format(" SOME_MACRO {int i;} int i;")); 3616 } 3617 3618 TEST_F(FormatTest, LayoutNestedBlocks) { 3619 verifyFormat("void AddOsStrings(unsigned bitmask) {\n" 3620 " struct s {\n" 3621 " int i;\n" 3622 " };\n" 3623 " s kBitsToOs[] = {{10}};\n" 3624 " for (int i = 0; i < 10; ++i)\n" 3625 " return;\n" 3626 "}"); 3627 verifyFormat("call(parameter, {\n" 3628 " something();\n" 3629 " // Comment using all columns.\n" 3630 " somethingelse();\n" 3631 "});", 3632 getLLVMStyleWithColumns(40)); 3633 verifyFormat("DEBUG( //\n" 3634 " { f(); }, a);"); 3635 verifyFormat("DEBUG( //\n" 3636 " {\n" 3637 " f(); //\n" 3638 " },\n" 3639 " a);"); 3640 3641 EXPECT_EQ("call(parameter, {\n" 3642 " something();\n" 3643 " // Comment too\n" 3644 " // looooooooooong.\n" 3645 " somethingElse();\n" 3646 "});", 3647 format("call(parameter, {\n" 3648 " something();\n" 3649 " // Comment too looooooooooong.\n" 3650 " somethingElse();\n" 3651 "});", 3652 getLLVMStyleWithColumns(29))); 3653 EXPECT_EQ("DEBUG({ int i; });", format("DEBUG({ int i; });")); 3654 EXPECT_EQ("DEBUG({ // comment\n" 3655 " int i;\n" 3656 "});", 3657 format("DEBUG({ // comment\n" 3658 "int i;\n" 3659 "});")); 3660 EXPECT_EQ("DEBUG({\n" 3661 " int i;\n" 3662 "\n" 3663 " // comment\n" 3664 " int j;\n" 3665 "});", 3666 format("DEBUG({\n" 3667 " int i;\n" 3668 "\n" 3669 " // comment\n" 3670 " int j;\n" 3671 "});")); 3672 3673 verifyFormat("DEBUG({\n" 3674 " if (a)\n" 3675 " return;\n" 3676 "});"); 3677 verifyGoogleFormat("DEBUG({\n" 3678 " if (a) return;\n" 3679 "});"); 3680 FormatStyle Style = getGoogleStyle(); 3681 Style.ColumnLimit = 45; 3682 verifyFormat("Debug(\n" 3683 " aaaaa,\n" 3684 " {\n" 3685 " if (aaaaaaaaaaaaaaaaaaaaaaaa) return;\n" 3686 " },\n" 3687 " a);", 3688 Style); 3689 3690 verifyFormat("SomeFunction({MACRO({ return output; }), b});"); 3691 3692 verifyNoCrash("^{v^{a}}"); 3693 } 3694 3695 TEST_F(FormatTest, FormatNestedBlocksInMacros) { 3696 EXPECT_EQ("#define MACRO() \\\n" 3697 " Debug(aaa, /* force line break */ \\\n" 3698 " { \\\n" 3699 " int i; \\\n" 3700 " int j; \\\n" 3701 " })", 3702 format("#define MACRO() Debug(aaa, /* force line break */ \\\n" 3703 " { int i; int j; })", 3704 getGoogleStyle())); 3705 3706 EXPECT_EQ("#define A \\\n" 3707 " [] { \\\n" 3708 " xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n" 3709 " xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); \\\n" 3710 " }", 3711 format("#define A [] { xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n" 3712 "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); }", 3713 getGoogleStyle())); 3714 } 3715 3716 TEST_F(FormatTest, PutEmptyBlocksIntoOneLine) { 3717 EXPECT_EQ("{}", format("{}")); 3718 verifyFormat("enum E {};"); 3719 verifyFormat("enum E {}"); 3720 FormatStyle Style = getLLVMStyle(); 3721 Style.SpaceInEmptyBlock = true; 3722 EXPECT_EQ("void f() { }", format("void f() {}", Style)); 3723 Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty; 3724 EXPECT_EQ("while (true) { }", format("while (true) {}", Style)); 3725 } 3726 3727 TEST_F(FormatTest, FormatBeginBlockEndMacros) { 3728 FormatStyle Style = getLLVMStyle(); 3729 Style.MacroBlockBegin = "^[A-Z_]+_BEGIN$"; 3730 Style.MacroBlockEnd = "^[A-Z_]+_END$"; 3731 verifyFormat("FOO_BEGIN\n" 3732 " FOO_ENTRY\n" 3733 "FOO_END", Style); 3734 verifyFormat("FOO_BEGIN\n" 3735 " NESTED_FOO_BEGIN\n" 3736 " NESTED_FOO_ENTRY\n" 3737 " NESTED_FOO_END\n" 3738 "FOO_END", Style); 3739 verifyFormat("FOO_BEGIN(Foo, Bar)\n" 3740 " int x;\n" 3741 " x = 1;\n" 3742 "FOO_END(Baz)", Style); 3743 } 3744 3745 //===----------------------------------------------------------------------===// 3746 // Line break tests. 3747 //===----------------------------------------------------------------------===// 3748 3749 TEST_F(FormatTest, PreventConfusingIndents) { 3750 verifyFormat( 3751 "void f() {\n" 3752 " SomeLongMethodName(SomeReallyLongMethod(CallOtherReallyLongMethod(\n" 3753 " parameter, parameter, parameter)),\n" 3754 " SecondLongCall(parameter));\n" 3755 "}"); 3756 verifyFormat( 3757 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3758 " aaaaaaaaaaaaaaaaaaaaaaaa(\n" 3759 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 3760 " aaaaaaaaaaaaaaaaaaaaaaaa);"); 3761 verifyFormat( 3762 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3763 " [aaaaaaaaaaaaaaaaaaaaaaaa\n" 3764 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n" 3765 " [aaaaaaaaaaaaaaaaaaaaaaaa]];"); 3766 verifyFormat( 3767 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n" 3768 " aaaaaaaaaaaaaaaaaaaaaaaa<\n" 3769 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>,\n" 3770 " aaaaaaaaaaaaaaaaaaaaaaaa>;"); 3771 verifyFormat("int a = bbbb && ccc &&\n" 3772 " fffff(\n" 3773 "#define A Just forcing a new line\n" 3774 " ddd);"); 3775 } 3776 3777 TEST_F(FormatTest, LineBreakingInBinaryExpressions) { 3778 verifyFormat( 3779 "bool aaaaaaa =\n" 3780 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() ||\n" 3781 " bbbbbbbb();"); 3782 verifyFormat( 3783 "bool aaaaaaa =\n" 3784 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() or\n" 3785 " bbbbbbbb();"); 3786 3787 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n" 3788 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb &&\n" 3789 " ccccccccc == ddddddddddd;"); 3790 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n" 3791 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb and\n" 3792 " ccccccccc == ddddddddddd;"); 3793 verifyFormat( 3794 "bool aaaaaaaaaaaaaaaaaaaaa =\n" 3795 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa not_eq bbbbbbbbbbbbbbbbbb and\n" 3796 " ccccccccc == ddddddddddd;"); 3797 3798 verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n" 3799 " aaaaaa) &&\n" 3800 " bbbbbb && cccccc;"); 3801 verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n" 3802 " aaaaaa) >>\n" 3803 " bbbbbb;"); 3804 verifyFormat("aa = Whitespaces.addUntouchableComment(\n" 3805 " SourceMgr.getSpellingColumnNumber(\n" 3806 " TheLine.Last->FormatTok.Tok.getLocation()) -\n" 3807 " 1);"); 3808 3809 verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 3810 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaaaaaaa\n" 3811 " cccccc) {\n}"); 3812 verifyFormat("if constexpr ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 3813 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaa\n" 3814 " cccccc) {\n}"); 3815 verifyFormat("if CONSTEXPR ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 3816 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaa\n" 3817 " cccccc) {\n}"); 3818 verifyFormat("b = a &&\n" 3819 " // Comment\n" 3820 " b.c && d;"); 3821 3822 // If the LHS of a comparison is not a binary expression itself, the 3823 // additional linebreak confuses many people. 3824 verifyFormat( 3825 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3826 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) > 5) {\n" 3827 "}"); 3828 verifyFormat( 3829 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3830 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n" 3831 "}"); 3832 verifyFormat( 3833 "if (aaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaa(\n" 3834 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n" 3835 "}"); 3836 verifyFormat( 3837 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3838 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) <=> 5) {\n" 3839 "}"); 3840 // Even explicit parentheses stress the precedence enough to make the 3841 // additional break unnecessary. 3842 verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3843 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n" 3844 "}"); 3845 // This cases is borderline, but with the indentation it is still readable. 3846 verifyFormat( 3847 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3848 " aaaaaaaaaaaaaaa) > aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3849 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 3850 "}", 3851 getLLVMStyleWithColumns(75)); 3852 3853 // If the LHS is a binary expression, we should still use the additional break 3854 // as otherwise the formatting hides the operator precedence. 3855 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3856 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 3857 " 5) {\n" 3858 "}"); 3859 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3860 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa <=>\n" 3861 " 5) {\n" 3862 "}"); 3863 3864 FormatStyle OnePerLine = getLLVMStyle(); 3865 OnePerLine.BinPackParameters = false; 3866 verifyFormat( 3867 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 3868 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 3869 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}", 3870 OnePerLine); 3871 3872 verifyFormat("int i = someFunction(aaaaaaa, 0)\n" 3873 " .aaa(aaaaaaaaaaaaa) *\n" 3874 " aaaaaaa +\n" 3875 " aaaaaaa;", 3876 getLLVMStyleWithColumns(40)); 3877 } 3878 3879 TEST_F(FormatTest, ExpressionIndentation) { 3880 verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3881 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3882 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 3883 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 3884 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb +\n" 3885 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb &&\n" 3886 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 3887 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >\n" 3888 " ccccccccccccccccccccccccccccccccccccccccc;"); 3889 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 3890 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3891 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 3892 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); 3893 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3894 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 3895 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 3896 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); 3897 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 3898 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 3899 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3900 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); 3901 verifyFormat("if () {\n" 3902 "} else if (aaaaa && bbbbb > // break\n" 3903 " ccccc) {\n" 3904 "}"); 3905 verifyFormat("if () {\n" 3906 "} else if constexpr (aaaaa && bbbbb > // break\n" 3907 " ccccc) {\n" 3908 "}"); 3909 verifyFormat("if () {\n" 3910 "} else if CONSTEXPR (aaaaa && bbbbb > // break\n" 3911 " ccccc) {\n" 3912 "}"); 3913 verifyFormat("if () {\n" 3914 "} else if (aaaaa &&\n" 3915 " bbbbb > // break\n" 3916 " ccccc &&\n" 3917 " ddddd) {\n" 3918 "}"); 3919 3920 // Presence of a trailing comment used to change indentation of b. 3921 verifyFormat("return aaaaaaaaaaaaaaaaaaa +\n" 3922 " b;\n" 3923 "return aaaaaaaaaaaaaaaaaaa +\n" 3924 " b; //", 3925 getLLVMStyleWithColumns(30)); 3926 } 3927 3928 TEST_F(FormatTest, ExpressionIndentationBreakingBeforeOperators) { 3929 // Not sure what the best system is here. Like this, the LHS can be found 3930 // immediately above an operator (everything with the same or a higher 3931 // indent). The RHS is aligned right of the operator and so compasses 3932 // everything until something with the same indent as the operator is found. 3933 // FIXME: Is this a good system? 3934 FormatStyle Style = getLLVMStyle(); 3935 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 3936 verifyFormat( 3937 "bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3938 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3939 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3940 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3941 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 3942 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 3943 " && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3944 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3945 " > ccccccccccccccccccccccccccccccccccccccccc;", 3946 Style); 3947 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3948 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3949 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3950 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 3951 Style); 3952 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3953 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3954 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3955 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 3956 Style); 3957 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3958 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3959 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3960 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 3961 Style); 3962 verifyFormat("if () {\n" 3963 "} else if (aaaaa\n" 3964 " && bbbbb // break\n" 3965 " > ccccc) {\n" 3966 "}", 3967 Style); 3968 verifyFormat("return (a)\n" 3969 " // comment\n" 3970 " + b;", 3971 Style); 3972 verifyFormat( 3973 "int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3974 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 3975 " + cc;", 3976 Style); 3977 3978 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3979 " = aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 3980 Style); 3981 3982 // Forced by comments. 3983 verifyFormat( 3984 "unsigned ContentSize =\n" 3985 " sizeof(int16_t) // DWARF ARange version number\n" 3986 " + sizeof(int32_t) // Offset of CU in the .debug_info section\n" 3987 " + sizeof(int8_t) // Pointer Size (in bytes)\n" 3988 " + sizeof(int8_t); // Segment Size (in bytes)"); 3989 3990 verifyFormat("return boost::fusion::at_c<0>(iiii).second\n" 3991 " == boost::fusion::at_c<1>(iiii).second;", 3992 Style); 3993 3994 Style.ColumnLimit = 60; 3995 verifyFormat("zzzzzzzzzz\n" 3996 " = bbbbbbbbbbbbbbbbb\n" 3997 " >> aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa);", 3998 Style); 3999 4000 Style.ColumnLimit = 80; 4001 Style.IndentWidth = 4; 4002 Style.TabWidth = 4; 4003 Style.UseTab = FormatStyle::UT_Always; 4004 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 4005 Style.AlignOperands = false; 4006 EXPECT_EQ("return someVeryVeryLongConditionThatBarelyFitsOnALine\n" 4007 "\t&& (someOtherLongishConditionPart1\n" 4008 "\t\t|| someOtherEvenLongerNestedConditionPart2);", 4009 format("return someVeryVeryLongConditionThatBarelyFitsOnALine && (someOtherLongishConditionPart1 || someOtherEvenLongerNestedConditionPart2);", 4010 Style)); 4011 } 4012 4013 TEST_F(FormatTest, EnforcedOperatorWraps) { 4014 // Here we'd like to wrap after the || operators, but a comment is forcing an 4015 // earlier wrap. 4016 verifyFormat("bool x = aaaaa //\n" 4017 " || bbbbb\n" 4018 " //\n" 4019 " || cccc;"); 4020 } 4021 4022 TEST_F(FormatTest, NoOperandAlignment) { 4023 FormatStyle Style = getLLVMStyle(); 4024 Style.AlignOperands = false; 4025 verifyFormat("aaaaaaaaaaaaaa(aaaaaaaaaaaa,\n" 4026 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4027 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 4028 Style); 4029 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment; 4030 verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4031 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4032 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4033 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4034 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4035 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4036 " && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4037 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4038 " > ccccccccccccccccccccccccccccccccccccccccc;", 4039 Style); 4040 4041 verifyFormat("int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4042 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4043 " + cc;", 4044 Style); 4045 verifyFormat("int a = aa\n" 4046 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4047 " * cccccccccccccccccccccccccccccccccccc;\n", 4048 Style); 4049 4050 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 4051 verifyFormat("return (a > b\n" 4052 " // comment1\n" 4053 " // comment2\n" 4054 " || c);", 4055 Style); 4056 } 4057 4058 TEST_F(FormatTest, BreakingBeforeNonAssigmentOperators) { 4059 FormatStyle Style = getLLVMStyle(); 4060 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment; 4061 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 4062 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4063 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;", 4064 Style); 4065 } 4066 4067 TEST_F(FormatTest, AllowBinPackingInsideArguments) { 4068 FormatStyle Style = getLLVMStyle(); 4069 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment; 4070 Style.BinPackArguments = false; 4071 Style.ColumnLimit = 40; 4072 verifyFormat("void test() {\n" 4073 " someFunction(\n" 4074 " this + argument + is + quite\n" 4075 " + long + so + it + gets + wrapped\n" 4076 " + but + remains + bin - packed);\n" 4077 "}", 4078 Style); 4079 verifyFormat("void test() {\n" 4080 " someFunction(arg1,\n" 4081 " this + argument + is\n" 4082 " + quite + long + so\n" 4083 " + it + gets + wrapped\n" 4084 " + but + remains + bin\n" 4085 " - packed,\n" 4086 " arg3);\n" 4087 "}", 4088 Style); 4089 verifyFormat("void test() {\n" 4090 " someFunction(\n" 4091 " arg1,\n" 4092 " this + argument + has\n" 4093 " + anotherFunc(nested,\n" 4094 " calls + whose\n" 4095 " + arguments\n" 4096 " + are + also\n" 4097 " + wrapped,\n" 4098 " in + addition)\n" 4099 " + to + being + bin - packed,\n" 4100 " arg3);\n" 4101 "}", 4102 Style); 4103 4104 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 4105 verifyFormat("void test() {\n" 4106 " someFunction(\n" 4107 " arg1,\n" 4108 " this + argument + has +\n" 4109 " anotherFunc(nested,\n" 4110 " calls + whose +\n" 4111 " arguments +\n" 4112 " are + also +\n" 4113 " wrapped,\n" 4114 " in + addition) +\n" 4115 " to + being + bin - packed,\n" 4116 " arg3);\n" 4117 "}", 4118 Style); 4119 } 4120 4121 TEST_F(FormatTest, ConstructorInitializers) { 4122 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}"); 4123 verifyFormat("Constructor() : Inttializer(FitsOnTheLine) {}", 4124 getLLVMStyleWithColumns(45)); 4125 verifyFormat("Constructor()\n" 4126 " : Inttializer(FitsOnTheLine) {}", 4127 getLLVMStyleWithColumns(44)); 4128 verifyFormat("Constructor()\n" 4129 " : Inttializer(FitsOnTheLine) {}", 4130 getLLVMStyleWithColumns(43)); 4131 4132 verifyFormat("template <typename T>\n" 4133 "Constructor() : Initializer(FitsOnTheLine) {}", 4134 getLLVMStyleWithColumns(45)); 4135 4136 verifyFormat( 4137 "SomeClass::Constructor()\n" 4138 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}"); 4139 4140 verifyFormat( 4141 "SomeClass::Constructor()\n" 4142 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4143 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}"); 4144 verifyFormat( 4145 "SomeClass::Constructor()\n" 4146 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4147 " aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}"); 4148 verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4149 " aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 4150 " : aaaaaaaaaa(aaaaaa) {}"); 4151 4152 verifyFormat("Constructor()\n" 4153 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4154 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4155 " aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4156 " aaaaaaaaaaaaaaaaaaaaaaa() {}"); 4157 4158 verifyFormat("Constructor()\n" 4159 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4160 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); 4161 4162 verifyFormat("Constructor(int Parameter = 0)\n" 4163 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n" 4164 " aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}"); 4165 verifyFormat("Constructor()\n" 4166 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n" 4167 "}", 4168 getLLVMStyleWithColumns(60)); 4169 verifyFormat("Constructor()\n" 4170 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4171 " aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}"); 4172 4173 // Here a line could be saved by splitting the second initializer onto two 4174 // lines, but that is not desirable. 4175 verifyFormat("Constructor()\n" 4176 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n" 4177 " aaaaaaaaaaa(aaaaaaaaaaa),\n" 4178 " aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); 4179 4180 FormatStyle OnePerLine = getLLVMStyle(); 4181 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4182 OnePerLine.AllowAllParametersOfDeclarationOnNextLine = false; 4183 verifyFormat("SomeClass::Constructor()\n" 4184 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4185 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4186 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4187 OnePerLine); 4188 verifyFormat("SomeClass::Constructor()\n" 4189 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n" 4190 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4191 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4192 OnePerLine); 4193 verifyFormat("MyClass::MyClass(int var)\n" 4194 " : some_var_(var), // 4 space indent\n" 4195 " some_other_var_(var + 1) { // lined up\n" 4196 "}", 4197 OnePerLine); 4198 verifyFormat("Constructor()\n" 4199 " : aaaaa(aaaaaa),\n" 4200 " aaaaa(aaaaaa),\n" 4201 " aaaaa(aaaaaa),\n" 4202 " aaaaa(aaaaaa),\n" 4203 " aaaaa(aaaaaa) {}", 4204 OnePerLine); 4205 verifyFormat("Constructor()\n" 4206 " : aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n" 4207 " aaaaaaaaaaaaaaaaaaaaaa) {}", 4208 OnePerLine); 4209 OnePerLine.BinPackParameters = false; 4210 verifyFormat( 4211 "Constructor()\n" 4212 " : aaaaaaaaaaaaaaaaaaaaaaaa(\n" 4213 " aaaaaaaaaaa().aaa(),\n" 4214 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4215 OnePerLine); 4216 OnePerLine.ColumnLimit = 60; 4217 verifyFormat("Constructor()\n" 4218 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4219 " bbbbbbbbbbbbbbbbbbbbbbbb(b) {}", 4220 OnePerLine); 4221 4222 EXPECT_EQ("Constructor()\n" 4223 " : // Comment forcing unwanted break.\n" 4224 " aaaa(aaaa) {}", 4225 format("Constructor() :\n" 4226 " // Comment forcing unwanted break.\n" 4227 " aaaa(aaaa) {}")); 4228 } 4229 4230 TEST_F(FormatTest, AllowAllConstructorInitializersOnNextLine) { 4231 FormatStyle Style = getLLVMStyle(); 4232 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 4233 Style.ColumnLimit = 60; 4234 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4235 Style.AllowAllConstructorInitializersOnNextLine = true; 4236 Style.BinPackParameters = false; 4237 4238 for (int i = 0; i < 4; ++i) { 4239 // Test all combinations of parameters that should not have an effect. 4240 Style.AllowAllParametersOfDeclarationOnNextLine = i & 1; 4241 Style.AllowAllArgumentsOnNextLine = i & 2; 4242 4243 Style.AllowAllConstructorInitializersOnNextLine = true; 4244 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 4245 verifyFormat("Constructor()\n" 4246 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4247 Style); 4248 verifyFormat("Constructor() : a(a), b(b) {}", Style); 4249 4250 Style.AllowAllConstructorInitializersOnNextLine = false; 4251 verifyFormat("Constructor()\n" 4252 " : aaaaaaaaaaaaaaaaaaaa(a)\n" 4253 " , bbbbbbbbbbbbbbbbbbbbb(b) {}", 4254 Style); 4255 verifyFormat("Constructor() : a(a), b(b) {}", Style); 4256 4257 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon; 4258 Style.AllowAllConstructorInitializersOnNextLine = true; 4259 verifyFormat("Constructor()\n" 4260 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4261 Style); 4262 4263 Style.AllowAllConstructorInitializersOnNextLine = false; 4264 verifyFormat("Constructor()\n" 4265 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4266 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4267 Style); 4268 4269 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 4270 Style.AllowAllConstructorInitializersOnNextLine = true; 4271 verifyFormat("Constructor() :\n" 4272 " aaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4273 Style); 4274 4275 Style.AllowAllConstructorInitializersOnNextLine = false; 4276 verifyFormat("Constructor() :\n" 4277 " aaaaaaaaaaaaaaaaaa(a),\n" 4278 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4279 Style); 4280 } 4281 4282 // Test interactions between AllowAllParametersOfDeclarationOnNextLine and 4283 // AllowAllConstructorInitializersOnNextLine in all 4284 // BreakConstructorInitializers modes 4285 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 4286 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4287 Style.AllowAllConstructorInitializersOnNextLine = false; 4288 verifyFormat("SomeClassWithALongName::Constructor(\n" 4289 " int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb)\n" 4290 " : aaaaaaaaaaaaaaaaaaaa(a)\n" 4291 " , bbbbbbbbbbbbbbbbbbbbb(b) {}", 4292 Style); 4293 4294 Style.AllowAllConstructorInitializersOnNextLine = true; 4295 verifyFormat("SomeClassWithALongName::Constructor(\n" 4296 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4297 " int bbbbbbbbbbbbb,\n" 4298 " int cccccccccccccccc)\n" 4299 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4300 Style); 4301 4302 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4303 Style.AllowAllConstructorInitializersOnNextLine = false; 4304 verifyFormat("SomeClassWithALongName::Constructor(\n" 4305 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4306 " int bbbbbbbbbbbbb)\n" 4307 " : aaaaaaaaaaaaaaaaaaaa(a)\n" 4308 " , bbbbbbbbbbbbbbbbbbbbb(b) {}", 4309 Style); 4310 4311 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon; 4312 4313 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4314 verifyFormat("SomeClassWithALongName::Constructor(\n" 4315 " int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb)\n" 4316 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4317 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4318 Style); 4319 4320 Style.AllowAllConstructorInitializersOnNextLine = true; 4321 verifyFormat("SomeClassWithALongName::Constructor(\n" 4322 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4323 " int bbbbbbbbbbbbb,\n" 4324 " int cccccccccccccccc)\n" 4325 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4326 Style); 4327 4328 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4329 Style.AllowAllConstructorInitializersOnNextLine = false; 4330 verifyFormat("SomeClassWithALongName::Constructor(\n" 4331 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4332 " int bbbbbbbbbbbbb)\n" 4333 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4334 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4335 Style); 4336 4337 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 4338 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4339 verifyFormat("SomeClassWithALongName::Constructor(\n" 4340 " int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb) :\n" 4341 " aaaaaaaaaaaaaaaaaaaa(a),\n" 4342 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4343 Style); 4344 4345 Style.AllowAllConstructorInitializersOnNextLine = true; 4346 verifyFormat("SomeClassWithALongName::Constructor(\n" 4347 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4348 " int bbbbbbbbbbbbb,\n" 4349 " int cccccccccccccccc) :\n" 4350 " aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4351 Style); 4352 4353 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4354 Style.AllowAllConstructorInitializersOnNextLine = false; 4355 verifyFormat("SomeClassWithALongName::Constructor(\n" 4356 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4357 " int bbbbbbbbbbbbb) :\n" 4358 " aaaaaaaaaaaaaaaaaaaa(a),\n" 4359 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4360 Style); 4361 } 4362 4363 TEST_F(FormatTest, AllowAllArgumentsOnNextLine) { 4364 FormatStyle Style = getLLVMStyle(); 4365 Style.ColumnLimit = 60; 4366 Style.BinPackArguments = false; 4367 for (int i = 0; i < 4; ++i) { 4368 // Test all combinations of parameters that should not have an effect. 4369 Style.AllowAllParametersOfDeclarationOnNextLine = i & 1; 4370 Style.AllowAllConstructorInitializersOnNextLine = i & 2; 4371 4372 Style.AllowAllArgumentsOnNextLine = true; 4373 verifyFormat("void foo() {\n" 4374 " FunctionCallWithReallyLongName(\n" 4375 " aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbb);\n" 4376 "}", 4377 Style); 4378 Style.AllowAllArgumentsOnNextLine = false; 4379 verifyFormat("void foo() {\n" 4380 " FunctionCallWithReallyLongName(\n" 4381 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4382 " bbbbbbbbbbbb);\n" 4383 "}", 4384 Style); 4385 4386 Style.AllowAllArgumentsOnNextLine = true; 4387 verifyFormat("void foo() {\n" 4388 " auto VariableWithReallyLongName = {\n" 4389 " aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbb};\n" 4390 "}", 4391 Style); 4392 Style.AllowAllArgumentsOnNextLine = false; 4393 verifyFormat("void foo() {\n" 4394 " auto VariableWithReallyLongName = {\n" 4395 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4396 " bbbbbbbbbbbb};\n" 4397 "}", 4398 Style); 4399 } 4400 4401 // This parameter should not affect declarations. 4402 Style.BinPackParameters = false; 4403 Style.AllowAllArgumentsOnNextLine = false; 4404 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4405 verifyFormat("void FunctionCallWithReallyLongName(\n" 4406 " int aaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbb);", 4407 Style); 4408 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4409 verifyFormat("void FunctionCallWithReallyLongName(\n" 4410 " int aaaaaaaaaaaaaaaaaaaaaaa,\n" 4411 " int bbbbbbbbbbbb);", 4412 Style); 4413 } 4414 4415 TEST_F(FormatTest, BreakConstructorInitializersAfterColon) { 4416 FormatStyle Style = getLLVMStyle(); 4417 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 4418 4419 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}"); 4420 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}", 4421 getStyleWithColumns(Style, 45)); 4422 verifyFormat("Constructor() :\n" 4423 " Initializer(FitsOnTheLine) {}", 4424 getStyleWithColumns(Style, 44)); 4425 verifyFormat("Constructor() :\n" 4426 " Initializer(FitsOnTheLine) {}", 4427 getStyleWithColumns(Style, 43)); 4428 4429 verifyFormat("template <typename T>\n" 4430 "Constructor() : Initializer(FitsOnTheLine) {}", 4431 getStyleWithColumns(Style, 50)); 4432 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4433 verifyFormat( 4434 "SomeClass::Constructor() :\n" 4435 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}", 4436 Style); 4437 4438 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = false; 4439 verifyFormat( 4440 "SomeClass::Constructor() :\n" 4441 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}", 4442 Style); 4443 4444 verifyFormat( 4445 "SomeClass::Constructor() :\n" 4446 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4447 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4448 Style); 4449 verifyFormat( 4450 "SomeClass::Constructor() :\n" 4451 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4452 " aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}", 4453 Style); 4454 verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4455 " aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n" 4456 " aaaaaaaaaa(aaaaaa) {}", 4457 Style); 4458 4459 verifyFormat("Constructor() :\n" 4460 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4461 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4462 " aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4463 " aaaaaaaaaaaaaaaaaaaaaaa() {}", 4464 Style); 4465 4466 verifyFormat("Constructor() :\n" 4467 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4468 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4469 Style); 4470 4471 verifyFormat("Constructor(int Parameter = 0) :\n" 4472 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n" 4473 " aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}", 4474 Style); 4475 verifyFormat("Constructor() :\n" 4476 " aaaaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n" 4477 "}", 4478 getStyleWithColumns(Style, 60)); 4479 verifyFormat("Constructor() :\n" 4480 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4481 " aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}", 4482 Style); 4483 4484 // Here a line could be saved by splitting the second initializer onto two 4485 // lines, but that is not desirable. 4486 verifyFormat("Constructor() :\n" 4487 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n" 4488 " aaaaaaaaaaa(aaaaaaaaaaa),\n" 4489 " aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4490 Style); 4491 4492 FormatStyle OnePerLine = Style; 4493 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4494 OnePerLine.AllowAllConstructorInitializersOnNextLine = false; 4495 verifyFormat("SomeClass::Constructor() :\n" 4496 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4497 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4498 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4499 OnePerLine); 4500 verifyFormat("SomeClass::Constructor() :\n" 4501 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n" 4502 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4503 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4504 OnePerLine); 4505 verifyFormat("MyClass::MyClass(int var) :\n" 4506 " some_var_(var), // 4 space indent\n" 4507 " some_other_var_(var + 1) { // lined up\n" 4508 "}", 4509 OnePerLine); 4510 verifyFormat("Constructor() :\n" 4511 " aaaaa(aaaaaa),\n" 4512 " aaaaa(aaaaaa),\n" 4513 " aaaaa(aaaaaa),\n" 4514 " aaaaa(aaaaaa),\n" 4515 " aaaaa(aaaaaa) {}", 4516 OnePerLine); 4517 verifyFormat("Constructor() :\n" 4518 " aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n" 4519 " aaaaaaaaaaaaaaaaaaaaaa) {}", 4520 OnePerLine); 4521 OnePerLine.BinPackParameters = false; 4522 verifyFormat( 4523 "Constructor() :\n" 4524 " aaaaaaaaaaaaaaaaaaaaaaaa(\n" 4525 " aaaaaaaaaaa().aaa(),\n" 4526 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4527 OnePerLine); 4528 OnePerLine.ColumnLimit = 60; 4529 verifyFormat("Constructor() :\n" 4530 " aaaaaaaaaaaaaaaaaaaa(a),\n" 4531 " bbbbbbbbbbbbbbbbbbbbbbbb(b) {}", 4532 OnePerLine); 4533 4534 EXPECT_EQ("Constructor() :\n" 4535 " // Comment forcing unwanted break.\n" 4536 " aaaa(aaaa) {}", 4537 format("Constructor() :\n" 4538 " // Comment forcing unwanted break.\n" 4539 " aaaa(aaaa) {}", 4540 Style)); 4541 4542 Style.ColumnLimit = 0; 4543 verifyFormat("SomeClass::Constructor() :\n" 4544 " a(a) {}", 4545 Style); 4546 verifyFormat("SomeClass::Constructor() noexcept :\n" 4547 " a(a) {}", 4548 Style); 4549 verifyFormat("SomeClass::Constructor() :\n" 4550 " a(a), b(b), c(c) {}", 4551 Style); 4552 verifyFormat("SomeClass::Constructor() :\n" 4553 " a(a) {\n" 4554 " foo();\n" 4555 " bar();\n" 4556 "}", 4557 Style); 4558 4559 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 4560 verifyFormat("SomeClass::Constructor() :\n" 4561 " a(a), b(b), c(c) {\n" 4562 "}", 4563 Style); 4564 verifyFormat("SomeClass::Constructor() :\n" 4565 " a(a) {\n" 4566 "}", 4567 Style); 4568 4569 Style.ColumnLimit = 80; 4570 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 4571 Style.ConstructorInitializerIndentWidth = 2; 4572 verifyFormat("SomeClass::Constructor() : a(a), b(b), c(c) {}", 4573 Style); 4574 verifyFormat("SomeClass::Constructor() :\n" 4575 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4576 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {}", 4577 Style); 4578 4579 // `ConstructorInitializerIndentWidth` actually applies to InheritanceList as well 4580 Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon; 4581 verifyFormat("class SomeClass\n" 4582 " : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4583 " public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};", 4584 Style); 4585 Style.BreakInheritanceList = FormatStyle::BILS_BeforeComma; 4586 verifyFormat("class SomeClass\n" 4587 " : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4588 " , public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};", 4589 Style); 4590 Style.BreakInheritanceList = FormatStyle::BILS_AfterColon; 4591 verifyFormat("class SomeClass :\n" 4592 " public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4593 " public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};", 4594 Style); 4595 } 4596 4597 #ifndef EXPENSIVE_CHECKS 4598 // Expensive checks enables libstdc++ checking which includes validating the 4599 // state of ranges used in std::priority_queue - this blows out the 4600 // runtime/scalability of the function and makes this test unacceptably slow. 4601 TEST_F(FormatTest, MemoizationTests) { 4602 // This breaks if the memoization lookup does not take \c Indent and 4603 // \c LastSpace into account. 4604 verifyFormat( 4605 "extern CFRunLoopTimerRef\n" 4606 "CFRunLoopTimerCreate(CFAllocatorRef allocato, CFAbsoluteTime fireDate,\n" 4607 " CFTimeInterval interval, CFOptionFlags flags,\n" 4608 " CFIndex order, CFRunLoopTimerCallBack callout,\n" 4609 " CFRunLoopTimerContext *context) {}"); 4610 4611 // Deep nesting somewhat works around our memoization. 4612 verifyFormat( 4613 "aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 4614 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 4615 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 4616 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 4617 " aaaaa())))))))))))))))))))))))))))))))))))))));", 4618 getLLVMStyleWithColumns(65)); 4619 verifyFormat( 4620 "aaaaa(\n" 4621 " aaaaa,\n" 4622 " aaaaa(\n" 4623 " aaaaa,\n" 4624 " aaaaa(\n" 4625 " aaaaa,\n" 4626 " aaaaa(\n" 4627 " aaaaa,\n" 4628 " aaaaa(\n" 4629 " aaaaa,\n" 4630 " aaaaa(\n" 4631 " aaaaa,\n" 4632 " aaaaa(\n" 4633 " aaaaa,\n" 4634 " aaaaa(\n" 4635 " aaaaa,\n" 4636 " aaaaa(\n" 4637 " aaaaa,\n" 4638 " aaaaa(\n" 4639 " aaaaa,\n" 4640 " aaaaa(\n" 4641 " aaaaa,\n" 4642 " aaaaa(\n" 4643 " aaaaa,\n" 4644 " aaaaa))))))))))));", 4645 getLLVMStyleWithColumns(65)); 4646 verifyFormat( 4647 "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" 4648 " a),\n" 4649 " a),\n" 4650 " a),\n" 4651 " a),\n" 4652 " a),\n" 4653 " a),\n" 4654 " a),\n" 4655 " a),\n" 4656 " a),\n" 4657 " a),\n" 4658 " a),\n" 4659 " a),\n" 4660 " a),\n" 4661 " a),\n" 4662 " a),\n" 4663 " a),\n" 4664 " a)", 4665 getLLVMStyleWithColumns(65)); 4666 4667 // This test takes VERY long when memoization is broken. 4668 FormatStyle OnePerLine = getLLVMStyle(); 4669 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4670 OnePerLine.BinPackParameters = false; 4671 std::string input = "Constructor()\n" 4672 " : aaaa(a,\n"; 4673 for (unsigned i = 0, e = 80; i != e; ++i) { 4674 input += " a,\n"; 4675 } 4676 input += " a) {}"; 4677 verifyFormat(input, OnePerLine); 4678 } 4679 #endif 4680 4681 TEST_F(FormatTest, BreaksAsHighAsPossible) { 4682 verifyFormat( 4683 "void f() {\n" 4684 " if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaaaaaaaa) ||\n" 4685 " (bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb && bbbbbbbbbbbbbbbbbbbbbbbbbb))\n" 4686 " f();\n" 4687 "}"); 4688 verifyFormat("if (Intervals[i].getRange().getFirst() <\n" 4689 " Intervals[i - 1].getRange().getLast()) {\n}"); 4690 } 4691 4692 TEST_F(FormatTest, BreaksFunctionDeclarations) { 4693 // Principially, we break function declarations in a certain order: 4694 // 1) break amongst arguments. 4695 verifyFormat("Aaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccc,\n" 4696 " Cccccccccccccc cccccccccccccc);"); 4697 verifyFormat("template <class TemplateIt>\n" 4698 "SomeReturnType SomeFunction(TemplateIt begin, TemplateIt end,\n" 4699 " TemplateIt *stop) {}"); 4700 4701 // 2) break after return type. 4702 verifyFormat( 4703 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4704 "bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccccccccccccccc);", 4705 getGoogleStyle()); 4706 4707 // 3) break after (. 4708 verifyFormat( 4709 "Aaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbb(\n" 4710 " Cccccccccccccccccccccccccccccc cccccccccccccccccccccccccccccccc);", 4711 getGoogleStyle()); 4712 4713 // 4) break before after nested name specifiers. 4714 verifyFormat( 4715 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4716 "SomeClasssssssssssssssssssssssssssssssssssssss::\n" 4717 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc);", 4718 getGoogleStyle()); 4719 4720 // However, there are exceptions, if a sufficient amount of lines can be 4721 // saved. 4722 // FIXME: The precise cut-offs wrt. the number of saved lines might need some 4723 // more adjusting. 4724 verifyFormat("Aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n" 4725 " Cccccccccccccc cccccccccc,\n" 4726 " Cccccccccccccc cccccccccc,\n" 4727 " Cccccccccccccc cccccccccc,\n" 4728 " Cccccccccccccc cccccccccc);"); 4729 verifyFormat( 4730 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4731 "bbbbbbbbbbb(Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 4732 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 4733 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);", 4734 getGoogleStyle()); 4735 verifyFormat( 4736 "Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n" 4737 " Cccccccccccccc cccccccccc,\n" 4738 " Cccccccccccccc cccccccccc,\n" 4739 " Cccccccccccccc cccccccccc,\n" 4740 " Cccccccccccccc cccccccccc,\n" 4741 " Cccccccccccccc cccccccccc,\n" 4742 " Cccccccccccccc cccccccccc);"); 4743 verifyFormat("Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 4744 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 4745 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 4746 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 4747 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);"); 4748 4749 // Break after multi-line parameters. 4750 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4751 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4752 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4753 " bbbb bbbb);"); 4754 verifyFormat("void SomeLoooooooooooongFunction(\n" 4755 " std::unique_ptr<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n" 4756 " aaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4757 " int bbbbbbbbbbbbb);"); 4758 4759 // Treat overloaded operators like other functions. 4760 verifyFormat("SomeLoooooooooooooooooooooooooogType\n" 4761 "operator>(const SomeLoooooooooooooooooooooooooogType &other);"); 4762 verifyFormat("SomeLoooooooooooooooooooooooooogType\n" 4763 "operator>>(const SomeLooooooooooooooooooooooooogType &other);"); 4764 verifyFormat("SomeLoooooooooooooooooooooooooogType\n" 4765 "operator<<(const SomeLooooooooooooooooooooooooogType &other);"); 4766 verifyGoogleFormat( 4767 "SomeLoooooooooooooooooooooooooooooogType operator>>(\n" 4768 " const SomeLooooooooogType &a, const SomeLooooooooogType &b);"); 4769 verifyGoogleFormat( 4770 "SomeLoooooooooooooooooooooooooooooogType operator<<(\n" 4771 " const SomeLooooooooogType &a, const SomeLooooooooogType &b);"); 4772 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4773 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = 1);"); 4774 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa\n" 4775 "aaaaaaaaaaaaaaaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaa = 1);"); 4776 verifyGoogleFormat( 4777 "typename aaaaaaaaaa<aaaaaa>::aaaaaaaaaaa\n" 4778 "aaaaaaaaaa<aaaaaa>::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4779 " bool *aaaaaaaaaaaaaaaaaa, bool *aa) {}"); 4780 verifyGoogleFormat( 4781 "template <typename T>\n" 4782 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4783 "aaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaaaaa(\n" 4784 " aaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaa);"); 4785 4786 FormatStyle Style = getLLVMStyle(); 4787 Style.PointerAlignment = FormatStyle::PAS_Left; 4788 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4789 " aaaaaaaaaaaaaaaaaaaaaaaaa* const aaaaaaaaaaaa) {}", 4790 Style); 4791 verifyFormat("void aaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*\n" 4792 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4793 Style); 4794 } 4795 4796 TEST_F(FormatTest, DontBreakBeforeQualifiedOperator) { 4797 // Regression test for https://bugs.llvm.org/show_bug.cgi?id=40516: 4798 // Prefer keeping `::` followed by `operator` together. 4799 EXPECT_EQ("const aaaa::bbbbbbb &\n" 4800 "ccccccccc::operator++() {\n" 4801 " stuff();\n" 4802 "}", 4803 format("const aaaa::bbbbbbb\n" 4804 "&ccccccccc::operator++() { stuff(); }", 4805 getLLVMStyleWithColumns(40))); 4806 } 4807 4808 TEST_F(FormatTest, TrailingReturnType) { 4809 verifyFormat("auto foo() -> int;\n"); 4810 verifyFormat("struct S {\n" 4811 " auto bar() const -> int;\n" 4812 "};"); 4813 verifyFormat("template <size_t Order, typename T>\n" 4814 "auto load_img(const std::string &filename)\n" 4815 " -> alias::tensor<Order, T, mem::tag::cpu> {}"); 4816 verifyFormat("auto SomeFunction(A aaaaaaaaaaaaaaaaaaaaa) const\n" 4817 " -> decltype(f(aaaaaaaaaaaaaaaaaaaaa)) {}"); 4818 verifyFormat("auto doSomething(Aaaaaa *aaaaaa) -> decltype(aaaaaa->f()) {}"); 4819 verifyFormat("template <typename T>\n" 4820 "auto aaaaaaaaaaaaaaaaaaaaaa(T t)\n" 4821 " -> decltype(eaaaaaaaaaaaaaaa<T>(t.a).aaaaaaaa());"); 4822 4823 // Not trailing return types. 4824 verifyFormat("void f() { auto a = b->c(); }"); 4825 } 4826 4827 TEST_F(FormatTest, BreaksFunctionDeclarationsWithTrailingTokens) { 4828 // Avoid breaking before trailing 'const' or other trailing annotations, if 4829 // they are not function-like. 4830 FormatStyle Style = getGoogleStyle(); 4831 Style.ColumnLimit = 47; 4832 verifyFormat("void someLongFunction(\n" 4833 " int someLoooooooooooooongParameter) const {\n}", 4834 getLLVMStyleWithColumns(47)); 4835 verifyFormat("LoooooongReturnType\n" 4836 "someLoooooooongFunction() const {}", 4837 getLLVMStyleWithColumns(47)); 4838 verifyFormat("LoooooongReturnType someLoooooooongFunction()\n" 4839 " const {}", 4840 Style); 4841 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n" 4842 " aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE;"); 4843 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n" 4844 " aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE FINAL;"); 4845 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n" 4846 " aaaaa aaaaaaaaaaaaaaaaaaaa) override final;"); 4847 verifyFormat("virtual void aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa,\n" 4848 " aaaaaaaaaaa aaaaa) const override;"); 4849 verifyGoogleFormat( 4850 "virtual void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 4851 " const override;"); 4852 4853 // Even if the first parameter has to be wrapped. 4854 verifyFormat("void someLongFunction(\n" 4855 " int someLongParameter) const {}", 4856 getLLVMStyleWithColumns(46)); 4857 verifyFormat("void someLongFunction(\n" 4858 " int someLongParameter) const {}", 4859 Style); 4860 verifyFormat("void someLongFunction(\n" 4861 " int someLongParameter) override {}", 4862 Style); 4863 verifyFormat("void someLongFunction(\n" 4864 " int someLongParameter) OVERRIDE {}", 4865 Style); 4866 verifyFormat("void someLongFunction(\n" 4867 " int someLongParameter) final {}", 4868 Style); 4869 verifyFormat("void someLongFunction(\n" 4870 " int someLongParameter) FINAL {}", 4871 Style); 4872 verifyFormat("void someLongFunction(\n" 4873 " int parameter) const override {}", 4874 Style); 4875 4876 Style.BreakBeforeBraces = FormatStyle::BS_Allman; 4877 verifyFormat("void someLongFunction(\n" 4878 " int someLongParameter) const\n" 4879 "{\n" 4880 "}", 4881 Style); 4882 4883 // Unless these are unknown annotations. 4884 verifyFormat("void SomeFunction(aaaaaaaaaa aaaaaaaaaaaaaaa,\n" 4885 " aaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 4886 " LONG_AND_UGLY_ANNOTATION;"); 4887 4888 // Breaking before function-like trailing annotations is fine to keep them 4889 // close to their arguments. 4890 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 4891 " LOCKS_EXCLUDED(aaaaaaaaaaaaa);"); 4892 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n" 4893 " LOCKS_EXCLUDED(aaaaaaaaaaaaa);"); 4894 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n" 4895 " LOCKS_EXCLUDED(aaaaaaaaaaaaa) {}"); 4896 verifyGoogleFormat("void aaaaaaaaaaaaaa(aaaaaaaa aaa) override\n" 4897 " AAAAAAAAAAAAAAAAAAAAAAAA(aaaaaaaaaaaaaaa);"); 4898 verifyFormat("SomeFunction([](int i) LOCKS_EXCLUDED(a) {});"); 4899 4900 verifyFormat( 4901 "void aaaaaaaaaaaaaaaaaa()\n" 4902 " __attribute__((aaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaa,\n" 4903 " aaaaaaaaaaaaaaaaaaaaaaaaa));"); 4904 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4905 " __attribute__((unused));"); 4906 verifyGoogleFormat( 4907 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4908 " GUARDED_BY(aaaaaaaaaaaa);"); 4909 verifyGoogleFormat( 4910 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4911 " GUARDED_BY(aaaaaaaaaaaa);"); 4912 verifyGoogleFormat( 4913 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n" 4914 " aaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 4915 verifyGoogleFormat( 4916 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n" 4917 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 4918 } 4919 4920 TEST_F(FormatTest, FunctionAnnotations) { 4921 verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n" 4922 "int OldFunction(const string ¶meter) {}"); 4923 verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n" 4924 "string OldFunction(const string ¶meter) {}"); 4925 verifyFormat("template <typename T>\n" 4926 "DEPRECATED(\"Use NewClass::NewFunction instead.\")\n" 4927 "string OldFunction(const string ¶meter) {}"); 4928 4929 // Not function annotations. 4930 verifyFormat("ASSERT(\"aaaaa\") << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4931 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"); 4932 verifyFormat("TEST_F(ThisIsATestFixtureeeeeeeeeeeee,\n" 4933 " ThisIsATestWithAReallyReallyReallyReallyLongName) {}"); 4934 verifyFormat("MACRO(abc).function() // wrap\n" 4935 " << abc;"); 4936 verifyFormat("MACRO(abc)->function() // wrap\n" 4937 " << abc;"); 4938 verifyFormat("MACRO(abc)::function() // wrap\n" 4939 " << abc;"); 4940 } 4941 4942 TEST_F(FormatTest, BreaksDesireably) { 4943 verifyFormat("if (aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n" 4944 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n" 4945 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa)) {\n}"); 4946 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4947 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n" 4948 "}"); 4949 4950 verifyFormat( 4951 "aaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4952 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); 4953 4954 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4955 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4956 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 4957 4958 verifyFormat( 4959 "aaaaaaaa(aaaaaaaaaaaaa,\n" 4960 " aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4961 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n" 4962 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4963 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));"); 4964 4965 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 4966 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 4967 4968 verifyFormat( 4969 "void f() {\n" 4970 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&\n" 4971 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 4972 "}"); 4973 verifyFormat( 4974 "aaaaaa(new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4975 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 4976 verifyFormat( 4977 "aaaaaa(aaa, new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4978 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 4979 verifyFormat( 4980 "aaaaaa(aaa,\n" 4981 " new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4982 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4983 " aaaa);"); 4984 verifyFormat("aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4985 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4986 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 4987 4988 // Indent consistently independent of call expression and unary operator. 4989 verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 4990 " dddddddddddddddddddddddddddddd));"); 4991 verifyFormat("aaaaaaaaaaa(!bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 4992 " dddddddddddddddddddddddddddddd));"); 4993 verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbb.ccccccccccccccccc(\n" 4994 " dddddddddddddddddddddddddddddd));"); 4995 4996 // This test case breaks on an incorrect memoization, i.e. an optimization not 4997 // taking into account the StopAt value. 4998 verifyFormat( 4999 "return aaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 5000 " aaaaaaaaaaa(aaaaaaaaa) || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 5001 " aaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 5002 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5003 5004 verifyFormat("{\n {\n {\n" 5005 " Annotation.SpaceRequiredBefore =\n" 5006 " Line.Tokens[i - 1].Tok.isNot(tok::l_paren) &&\n" 5007 " Line.Tokens[i - 1].Tok.isNot(tok::l_square);\n" 5008 " }\n }\n}"); 5009 5010 // Break on an outer level if there was a break on an inner level. 5011 EXPECT_EQ("f(g(h(a, // comment\n" 5012 " b, c),\n" 5013 " d, e),\n" 5014 " x, y);", 5015 format("f(g(h(a, // comment\n" 5016 " b, c), d, e), x, y);")); 5017 5018 // Prefer breaking similar line breaks. 5019 verifyFormat( 5020 "const int kTrackingOptions = NSTrackingMouseMoved |\n" 5021 " NSTrackingMouseEnteredAndExited |\n" 5022 " NSTrackingActiveAlways;"); 5023 } 5024 5025 TEST_F(FormatTest, FormatsDeclarationsOnePerLine) { 5026 FormatStyle NoBinPacking = getGoogleStyle(); 5027 NoBinPacking.BinPackParameters = false; 5028 NoBinPacking.BinPackArguments = true; 5029 verifyFormat("void f() {\n" 5030 " f(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa,\n" 5031 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 5032 "}", 5033 NoBinPacking); 5034 verifyFormat("void f(int aaaaaaaaaaaaaaaaaaaa,\n" 5035 " int aaaaaaaaaaaaaaaaaaaa,\n" 5036 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 5037 NoBinPacking); 5038 5039 NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false; 5040 verifyFormat("void aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5041 " vector<int> bbbbbbbbbbbbbbb);", 5042 NoBinPacking); 5043 // FIXME: This behavior difference is probably not wanted. However, currently 5044 // we cannot distinguish BreakBeforeParameter being set because of the wrapped 5045 // template arguments from BreakBeforeParameter being set because of the 5046 // one-per-line formatting. 5047 verifyFormat( 5048 "void fffffffffff(aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa,\n" 5049 " aaaaaaaaaa> aaaaaaaaaa);", 5050 NoBinPacking); 5051 verifyFormat( 5052 "void fffffffffff(\n" 5053 " aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaa>\n" 5054 " aaaaaaaaaa);"); 5055 } 5056 5057 TEST_F(FormatTest, FormatsOneParameterPerLineIfNecessary) { 5058 FormatStyle NoBinPacking = getGoogleStyle(); 5059 NoBinPacking.BinPackParameters = false; 5060 NoBinPacking.BinPackArguments = false; 5061 verifyFormat("f(aaaaaaaaaaaaaaaaaaaa,\n" 5062 " aaaaaaaaaaaaaaaaaaaa,\n" 5063 " aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaa);", 5064 NoBinPacking); 5065 verifyFormat("aaaaaaa(aaaaaaaaaaaaa,\n" 5066 " aaaaaaaaaaaaa,\n" 5067 " aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));", 5068 NoBinPacking); 5069 verifyFormat( 5070 "aaaaaaaa(aaaaaaaaaaaaa,\n" 5071 " aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5072 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n" 5073 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5074 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));", 5075 NoBinPacking); 5076 verifyFormat("aaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n" 5077 " .aaaaaaaaaaaaaaaaaa();", 5078 NoBinPacking); 5079 verifyFormat("void f() {\n" 5080 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5081 " aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaa);\n" 5082 "}", 5083 NoBinPacking); 5084 5085 verifyFormat( 5086 "aaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5087 " aaaaaaaaaaaa,\n" 5088 " aaaaaaaaaaaa);", 5089 NoBinPacking); 5090 verifyFormat( 5091 "somefunction(someotherFunction(ddddddddddddddddddddddddddddddddddd,\n" 5092 " ddddddddddddddddddddddddddddd),\n" 5093 " test);", 5094 NoBinPacking); 5095 5096 verifyFormat("std::vector<aaaaaaaaaaaaaaaaaaaaaaa,\n" 5097 " aaaaaaaaaaaaaaaaaaaaaaa,\n" 5098 " aaaaaaaaaaaaaaaaaaaaaaa>\n" 5099 " aaaaaaaaaaaaaaaaaa;", 5100 NoBinPacking); 5101 verifyFormat("a(\"a\"\n" 5102 " \"a\",\n" 5103 " a);"); 5104 5105 NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false; 5106 verifyFormat("void aaaaaaaaaa(aaaaaaaaa,\n" 5107 " aaaaaaaaa,\n" 5108 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5109 NoBinPacking); 5110 verifyFormat( 5111 "void f() {\n" 5112 " aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n" 5113 " .aaaaaaa();\n" 5114 "}", 5115 NoBinPacking); 5116 verifyFormat( 5117 "template <class SomeType, class SomeOtherType>\n" 5118 "SomeType SomeFunction(SomeType Type, SomeOtherType OtherType) {}", 5119 NoBinPacking); 5120 } 5121 5122 TEST_F(FormatTest, AdaptiveOnePerLineFormatting) { 5123 FormatStyle Style = getLLVMStyleWithColumns(15); 5124 Style.ExperimentalAutoDetectBinPacking = true; 5125 EXPECT_EQ("aaa(aaaa,\n" 5126 " aaaa,\n" 5127 " aaaa);\n" 5128 "aaa(aaaa,\n" 5129 " aaaa,\n" 5130 " aaaa);", 5131 format("aaa(aaaa,\n" // one-per-line 5132 " aaaa,\n" 5133 " aaaa );\n" 5134 "aaa(aaaa, aaaa, aaaa);", // inconclusive 5135 Style)); 5136 EXPECT_EQ("aaa(aaaa, aaaa,\n" 5137 " aaaa);\n" 5138 "aaa(aaaa, aaaa,\n" 5139 " aaaa);", 5140 format("aaa(aaaa, aaaa,\n" // bin-packed 5141 " aaaa );\n" 5142 "aaa(aaaa, aaaa, aaaa);", // inconclusive 5143 Style)); 5144 } 5145 5146 TEST_F(FormatTest, FormatsBuilderPattern) { 5147 verifyFormat("return llvm::StringSwitch<Reference::Kind>(name)\n" 5148 " .StartsWith(\".eh_frame_hdr\", ORDER_EH_FRAMEHDR)\n" 5149 " .StartsWith(\".eh_frame\", ORDER_EH_FRAME)\n" 5150 " .StartsWith(\".init\", ORDER_INIT)\n" 5151 " .StartsWith(\".fini\", ORDER_FINI)\n" 5152 " .StartsWith(\".hash\", ORDER_HASH)\n" 5153 " .Default(ORDER_TEXT);\n"); 5154 5155 verifyFormat("return aaaaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa() <\n" 5156 " aaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa();"); 5157 verifyFormat( 5158 "aaaaaaa->aaaaaaa\n" 5159 " ->aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5160 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5161 " ->aaaaaaaa(aaaaaaaaaaaaaaa);"); 5162 verifyFormat( 5163 "aaaaaaa->aaaaaaa\n" 5164 " ->aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5165 " ->aaaaaaaa(aaaaaaaaaaaaaaa);"); 5166 verifyFormat( 5167 "aaaaaaaaaaaaaaaaaaa()->aaaaaa(bbbbb)->aaaaaaaaaaaaaaaaaaa( // break\n" 5168 " aaaaaaaaaaaaaa);"); 5169 verifyFormat( 5170 "aaaaaaaaaaaaaaaaaaaaaaa *aaaaaaaaa =\n" 5171 " aaaaaa->aaaaaaaaaaaa()\n" 5172 " ->aaaaaaaaaaaaaaaa(\n" 5173 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5174 " ->aaaaaaaaaaaaaaaaa();"); 5175 verifyGoogleFormat( 5176 "void f() {\n" 5177 " someo->Add((new util::filetools::Handler(dir))\n" 5178 " ->OnEvent1(NewPermanentCallback(\n" 5179 " this, &HandlerHolderClass::EventHandlerCBA))\n" 5180 " ->OnEvent2(NewPermanentCallback(\n" 5181 " this, &HandlerHolderClass::EventHandlerCBB))\n" 5182 " ->OnEvent3(NewPermanentCallback(\n" 5183 " this, &HandlerHolderClass::EventHandlerCBC))\n" 5184 " ->OnEvent5(NewPermanentCallback(\n" 5185 " this, &HandlerHolderClass::EventHandlerCBD))\n" 5186 " ->OnEvent6(NewPermanentCallback(\n" 5187 " this, &HandlerHolderClass::EventHandlerCBE)));\n" 5188 "}"); 5189 5190 verifyFormat( 5191 "aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa();"); 5192 verifyFormat("aaaaaaaaaaaaaaa()\n" 5193 " .aaaaaaaaaaaaaaa()\n" 5194 " .aaaaaaaaaaaaaaa()\n" 5195 " .aaaaaaaaaaaaaaa()\n" 5196 " .aaaaaaaaaaaaaaa();"); 5197 verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n" 5198 " .aaaaaaaaaaaaaaa()\n" 5199 " .aaaaaaaaaaaaaaa()\n" 5200 " .aaaaaaaaaaaaaaa();"); 5201 verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n" 5202 " .aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n" 5203 " .aaaaaaaaaaaaaaa();"); 5204 verifyFormat("aaaaaaaaaaaaa->aaaaaaaaaaaaaaaaaaaaaaaa()\n" 5205 " ->aaaaaaaaaaaaaae(0)\n" 5206 " ->aaaaaaaaaaaaaaa();"); 5207 5208 // Don't linewrap after very short segments. 5209 verifyFormat("a().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5210 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5211 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 5212 verifyFormat("aa().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5213 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5214 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 5215 verifyFormat("aaa()\n" 5216 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5217 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5218 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 5219 5220 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n" 5221 " .aaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5222 " .has<bbbbbbbbbbbbbbbbbbbbb>();"); 5223 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n" 5224 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n" 5225 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>();"); 5226 5227 // Prefer not to break after empty parentheses. 5228 verifyFormat("FirstToken->WhitespaceRange.getBegin().getLocWithOffset(\n" 5229 " First->LastNewlineOffset);"); 5230 5231 // Prefer not to create "hanging" indents. 5232 verifyFormat( 5233 "return !soooooooooooooome_map\n" 5234 " .insert(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5235 " .second;"); 5236 verifyFormat( 5237 "return aaaaaaaaaaaaaaaa\n" 5238 " .aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa)\n" 5239 " .aaaa(aaaaaaaaaaaaaa);"); 5240 // No hanging indent here. 5241 verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa.aaaaaaaaaaaaaaa(\n" 5242 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5243 verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa().aaaaaaaaaaaaaaa(\n" 5244 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5245 verifyFormat("aaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n" 5246 " .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5247 getLLVMStyleWithColumns(60)); 5248 verifyFormat("aaaaaaaaaaaaaaaaaa\n" 5249 " .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n" 5250 " .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5251 getLLVMStyleWithColumns(59)); 5252 verifyFormat("aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5253 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5254 " .aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5255 5256 // Dont break if only closing statements before member call 5257 verifyFormat("test() {\n" 5258 " ([]() -> {\n" 5259 " int b = 32;\n" 5260 " return 3;\n" 5261 " }).foo();\n" 5262 "}"); 5263 verifyFormat("test() {\n" 5264 " (\n" 5265 " []() -> {\n" 5266 " int b = 32;\n" 5267 " return 3;\n" 5268 " },\n" 5269 " foo, bar)\n" 5270 " .foo();\n" 5271 "}"); 5272 verifyFormat("test() {\n" 5273 " ([]() -> {\n" 5274 " int b = 32;\n" 5275 " return 3;\n" 5276 " })\n" 5277 " .foo()\n" 5278 " .bar();\n" 5279 "}"); 5280 verifyFormat("test() {\n" 5281 " ([]() -> {\n" 5282 " int b = 32;\n" 5283 " return 3;\n" 5284 " })\n" 5285 " .foo(\"aaaaaaaaaaaaaaaaa\"\n" 5286 " \"bbbb\");\n" 5287 "}", 5288 getLLVMStyleWithColumns(30)); 5289 } 5290 5291 TEST_F(FormatTest, BreaksAccordingToOperatorPrecedence) { 5292 verifyFormat( 5293 "if (aaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 5294 " bbbbbbbbbbbbbbbbbbbbbbbbb && ccccccccccccccccccccccccc) {\n}"); 5295 verifyFormat( 5296 "if (aaaaaaaaaaaaaaaaaaaaaaaaa or\n" 5297 " bbbbbbbbbbbbbbbbbbbbbbbbb and cccccccccccccccccccccccc) {\n}"); 5298 5299 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa && bbbbbbbbbbbbbbbbbbbbbbbbb ||\n" 5300 " ccccccccccccccccccccccccc) {\n}"); 5301 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa and bbbbbbbbbbbbbbbbbbbbbbbb or\n" 5302 " ccccccccccccccccccccccccc) {\n}"); 5303 5304 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb ||\n" 5305 " ccccccccccccccccccccccccc) {\n}"); 5306 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb or\n" 5307 " ccccccccccccccccccccccccc) {\n}"); 5308 5309 verifyFormat( 5310 "if ((aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb) &&\n" 5311 " ccccccccccccccccccccccccc) {\n}"); 5312 verifyFormat( 5313 "if ((aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb) and\n" 5314 " ccccccccccccccccccccccccc) {\n}"); 5315 5316 verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA ||\n" 5317 " bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB ||\n" 5318 " cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC ||\n" 5319 " dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;"); 5320 verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA or\n" 5321 " bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB or\n" 5322 " cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC or\n" 5323 " dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;"); 5324 5325 verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa ||\n" 5326 " aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) &&\n" 5327 " aaaaaaaaaaaaaaa != aa) {\n}"); 5328 verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa or\n" 5329 " aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) and\n" 5330 " aaaaaaaaaaaaaaa != aa) {\n}"); 5331 } 5332 5333 TEST_F(FormatTest, BreaksAfterAssignments) { 5334 verifyFormat( 5335 "unsigned Cost =\n" 5336 " TTI.getMemoryOpCost(I->getOpcode(), VectorTy, SI->getAlignment(),\n" 5337 " SI->getPointerAddressSpaceee());\n"); 5338 verifyFormat( 5339 "CharSourceRange LineRange = CharSourceRange::getTokenRange(\n" 5340 " Line.Tokens.front().Tok.getLo(), Line.Tokens.back().Tok.getLoc());"); 5341 5342 verifyFormat( 5343 "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa = aaaaaaaaaaaaaa(0).aaaa().aaaaaaaaa(\n" 5344 " aaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaa);"); 5345 verifyFormat("unsigned OriginalStartColumn =\n" 5346 " SourceMgr.getSpellingColumnNumber(\n" 5347 " Current.FormatTok.getStartOfNonWhitespace()) -\n" 5348 " 1;"); 5349 } 5350 5351 TEST_F(FormatTest, ConfigurableBreakAssignmentPenalty) { 5352 FormatStyle Style = getLLVMStyle(); 5353 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 5354 " bbbbbbbbbbbbbbbbbbbbbbbbbb + cccccccccccccccccccccccccc;", 5355 Style); 5356 5357 Style.PenaltyBreakAssignment = 20; 5358 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa = bbbbbbbbbbbbbbbbbbbbbbbbbb +\n" 5359 " cccccccccccccccccccccccccc;", 5360 Style); 5361 } 5362 5363 TEST_F(FormatTest, AlignsAfterAssignments) { 5364 verifyFormat( 5365 "int Result = aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5366 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5367 verifyFormat( 5368 "Result += aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5369 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5370 verifyFormat( 5371 "Result >>= aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5372 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5373 verifyFormat( 5374 "int Result = (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5375 " aaaaaaaaaaaaaaaaaaaaaaaaa);"); 5376 verifyFormat( 5377 "double LooooooooooooooooooooooooongResult = aaaaaaaaaaaaaaaaaaaaaaaa +\n" 5378 " aaaaaaaaaaaaaaaaaaaaaaaa +\n" 5379 " aaaaaaaaaaaaaaaaaaaaaaaa;"); 5380 } 5381 5382 TEST_F(FormatTest, AlignsAfterReturn) { 5383 verifyFormat( 5384 "return aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5385 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5386 verifyFormat( 5387 "return (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5388 " aaaaaaaaaaaaaaaaaaaaaaaaa);"); 5389 verifyFormat( 5390 "return aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n" 5391 " aaaaaaaaaaaaaaaaaaaaaa();"); 5392 verifyFormat( 5393 "return (aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n" 5394 " aaaaaaaaaaaaaaaaaaaaaa());"); 5395 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5396 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5397 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5398 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) &&\n" 5399 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5400 verifyFormat("return\n" 5401 " // true if code is one of a or b.\n" 5402 " code == a || code == b;"); 5403 } 5404 5405 TEST_F(FormatTest, AlignsAfterOpenBracket) { 5406 verifyFormat( 5407 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n" 5408 " aaaaaaaaa aaaaaaa) {}"); 5409 verifyFormat( 5410 "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n" 5411 " aaaaaaaaaaa aaaaaaaaa);"); 5412 verifyFormat( 5413 "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n" 5414 " aaaaaaaaaaaaaaaaaaaaa));"); 5415 FormatStyle Style = getLLVMStyle(); 5416 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 5417 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5418 " aaaaaaaaaaa aaaaaaaa, aaaaaaaaa aaaaaaa) {}", 5419 Style); 5420 verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n" 5421 " aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaa aaaaaaaaa);", 5422 Style); 5423 verifyFormat("SomeLongVariableName->someFunction(\n" 5424 " foooooooo(aaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa));", 5425 Style); 5426 verifyFormat( 5427 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n" 5428 " aaaaaaaaa aaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 5429 Style); 5430 verifyFormat( 5431 "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n" 5432 " aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5433 Style); 5434 verifyFormat( 5435 "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n" 5436 " aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));", 5437 Style); 5438 5439 verifyFormat("bbbbbbbbbbbb(aaaaaaaaaaaaaaaaaaaaaaaa, //\n" 5440 " ccccccc(aaaaaaaaaaaaaaaaa, //\n" 5441 " b));", 5442 Style); 5443 5444 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 5445 Style.BinPackArguments = false; 5446 Style.BinPackParameters = false; 5447 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5448 " aaaaaaaaaaa aaaaaaaa,\n" 5449 " aaaaaaaaa aaaaaaa,\n" 5450 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 5451 Style); 5452 verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n" 5453 " aaaaaaaaaaa aaaaaaaaa,\n" 5454 " aaaaaaaaaaa aaaaaaaaa,\n" 5455 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5456 Style); 5457 verifyFormat("SomeLongVariableName->someFunction(foooooooo(\n" 5458 " aaaaaaaaaaaaaaa,\n" 5459 " aaaaaaaaaaaaaaaaaaaaa,\n" 5460 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));", 5461 Style); 5462 verifyFormat( 5463 "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa(\n" 5464 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));", 5465 Style); 5466 verifyFormat( 5467 "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaa.aaaaaaaaaa(\n" 5468 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));", 5469 Style); 5470 verifyFormat( 5471 "aaaaaaaaaaaaaaaaaaaaaaaa(\n" 5472 " aaaaaaaaaaaaaaaaaaaaa(\n" 5473 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)),\n" 5474 " aaaaaaaaaaaaaaaa);", 5475 Style); 5476 verifyFormat( 5477 "aaaaaaaaaaaaaaaaaaaaaaaa(\n" 5478 " aaaaaaaaaaaaaaaaaaaaa(\n" 5479 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)) &&\n" 5480 " aaaaaaaaaaaaaaaa);", 5481 Style); 5482 } 5483 5484 TEST_F(FormatTest, ParenthesesAndOperandAlignment) { 5485 FormatStyle Style = getLLVMStyleWithColumns(40); 5486 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5487 " bbbbbbbbbbbbbbbbbbbbbb);", 5488 Style); 5489 Style.AlignAfterOpenBracket = FormatStyle::BAS_Align; 5490 Style.AlignOperands = false; 5491 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5492 " bbbbbbbbbbbbbbbbbbbbbb);", 5493 Style); 5494 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 5495 Style.AlignOperands = true; 5496 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5497 " bbbbbbbbbbbbbbbbbbbbbb);", 5498 Style); 5499 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 5500 Style.AlignOperands = false; 5501 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5502 " bbbbbbbbbbbbbbbbbbbbbb);", 5503 Style); 5504 } 5505 5506 TEST_F(FormatTest, BreaksConditionalExpressions) { 5507 verifyFormat( 5508 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5509 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5510 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5511 verifyFormat( 5512 "aaaa(aaaaaaaaaa, aaaaaaaa,\n" 5513 " aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5514 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5515 verifyFormat( 5516 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5517 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5518 verifyFormat( 5519 "aaaa(aaaaaaaaa, aaaaaaaaa,\n" 5520 " aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5521 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5522 verifyFormat( 5523 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa)\n" 5524 " : aaaaaaaaaaaaa);"); 5525 verifyFormat( 5526 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5527 " aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5528 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5529 " aaaaaaaaaaaaa);"); 5530 verifyFormat( 5531 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5532 " aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5533 " aaaaaaaaaaaaa);"); 5534 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5535 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5536 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5537 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5538 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5539 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5540 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5541 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5542 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5543 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5544 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5545 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5546 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5547 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5548 " ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5549 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5550 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5551 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5552 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5553 " : aaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5554 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n" 5555 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5556 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5557 " : aaaaaaaaaaaaaaaa;"); 5558 verifyFormat( 5559 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5560 " ? aaaaaaaaaaaaaaa\n" 5561 " : aaaaaaaaaaaaaaa;"); 5562 verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n" 5563 " aaaaaaaaa\n" 5564 " ? b\n" 5565 " : c);"); 5566 verifyFormat("return aaaa == bbbb\n" 5567 " // comment\n" 5568 " ? aaaa\n" 5569 " : bbbb;"); 5570 verifyFormat("unsigned Indent =\n" 5571 " format(TheLine.First,\n" 5572 " IndentForLevel[TheLine.Level] >= 0\n" 5573 " ? IndentForLevel[TheLine.Level]\n" 5574 " : TheLine * 2,\n" 5575 " TheLine.InPPDirective, PreviousEndOfLineColumn);", 5576 getLLVMStyleWithColumns(60)); 5577 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n" 5578 " ? aaaaaaaaaaaaaaa\n" 5579 " : bbbbbbbbbbbbbbb //\n" 5580 " ? ccccccccccccccc\n" 5581 " : ddddddddddddddd;"); 5582 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n" 5583 " ? aaaaaaaaaaaaaaa\n" 5584 " : (bbbbbbbbbbbbbbb //\n" 5585 " ? ccccccccccccccc\n" 5586 " : ddddddddddddddd);"); 5587 verifyFormat( 5588 "int aaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5589 " ? aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5590 " aaaaaaaaaaaaaaaaaaaaa +\n" 5591 " aaaaaaaaaaaaaaaaaaaaa\n" 5592 " : aaaaaaaaaa;"); 5593 verifyFormat( 5594 "aaaaaa = aaaaaaaaaaaa ? aaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5595 " : aaaaaaaaaaaaaaaaaaaaaa\n" 5596 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5597 5598 FormatStyle NoBinPacking = getLLVMStyle(); 5599 NoBinPacking.BinPackArguments = false; 5600 verifyFormat( 5601 "void f() {\n" 5602 " g(aaa,\n" 5603 " aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n" 5604 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5605 " ? aaaaaaaaaaaaaaa\n" 5606 " : aaaaaaaaaaaaaaa);\n" 5607 "}", 5608 NoBinPacking); 5609 verifyFormat( 5610 "void f() {\n" 5611 " g(aaa,\n" 5612 " aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n" 5613 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5614 " ?: aaaaaaaaaaaaaaa);\n" 5615 "}", 5616 NoBinPacking); 5617 5618 verifyFormat("SomeFunction(aaaaaaaaaaaaaaaaa,\n" 5619 " // comment.\n" 5620 " ccccccccccccccccccccccccccccccccccccccc\n" 5621 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5622 " : bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);"); 5623 5624 // Assignments in conditional expressions. Apparently not uncommon :-(. 5625 verifyFormat("return a != b\n" 5626 " // comment\n" 5627 " ? a = b\n" 5628 " : a = b;"); 5629 verifyFormat("return a != b\n" 5630 " // comment\n" 5631 " ? a = a != b\n" 5632 " // comment\n" 5633 " ? a = b\n" 5634 " : a\n" 5635 " : a;\n"); 5636 verifyFormat("return a != b\n" 5637 " // comment\n" 5638 " ? a\n" 5639 " : a = a != b\n" 5640 " // comment\n" 5641 " ? a = b\n" 5642 " : a;"); 5643 } 5644 5645 TEST_F(FormatTest, BreaksConditionalExpressionsAfterOperator) { 5646 FormatStyle Style = getLLVMStyle(); 5647 Style.BreakBeforeTernaryOperators = false; 5648 Style.ColumnLimit = 70; 5649 verifyFormat( 5650 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5651 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5652 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5653 Style); 5654 verifyFormat( 5655 "aaaa(aaaaaaaaaa, aaaaaaaa,\n" 5656 " aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5657 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5658 Style); 5659 verifyFormat( 5660 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5661 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5662 Style); 5663 verifyFormat( 5664 "aaaa(aaaaaaaa, aaaaaaaaaa,\n" 5665 " aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5666 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5667 Style); 5668 verifyFormat( 5669 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa) :\n" 5670 " aaaaaaaaaaaaa);", 5671 Style); 5672 verifyFormat( 5673 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5674 " aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5675 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5676 " aaaaaaaaaaaaa);", 5677 Style); 5678 verifyFormat( 5679 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5680 " aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5681 " aaaaaaaaaaaaa);", 5682 Style); 5683 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5684 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5685 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n" 5686 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5687 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5688 Style); 5689 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5690 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5691 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5692 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n" 5693 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5694 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5695 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5696 Style); 5697 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5698 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?:\n" 5699 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5700 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5701 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5702 Style); 5703 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5704 " aaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5705 " aaaaaaaaaaaaaaaaaaaaaaaaaaa;", 5706 Style); 5707 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n" 5708 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5709 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5710 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 5711 Style); 5712 verifyFormat( 5713 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5714 " aaaaaaaaaaaaaaa :\n" 5715 " aaaaaaaaaaaaaaa;", 5716 Style); 5717 verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n" 5718 " aaaaaaaaa ?\n" 5719 " b :\n" 5720 " c);", 5721 Style); 5722 verifyFormat("unsigned Indent =\n" 5723 " format(TheLine.First,\n" 5724 " IndentForLevel[TheLine.Level] >= 0 ?\n" 5725 " IndentForLevel[TheLine.Level] :\n" 5726 " TheLine * 2,\n" 5727 " TheLine.InPPDirective, PreviousEndOfLineColumn);", 5728 Style); 5729 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n" 5730 " aaaaaaaaaaaaaaa :\n" 5731 " bbbbbbbbbbbbbbb ? //\n" 5732 " ccccccccccccccc :\n" 5733 " ddddddddddddddd;", 5734 Style); 5735 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n" 5736 " aaaaaaaaaaaaaaa :\n" 5737 " (bbbbbbbbbbbbbbb ? //\n" 5738 " ccccccccccccccc :\n" 5739 " ddddddddddddddd);", 5740 Style); 5741 verifyFormat("int i = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5742 " /*bbbbbbbbbbbbbbb=*/bbbbbbbbbbbbbbbbbbbbbbbbb :\n" 5743 " ccccccccccccccccccccccccccc;", 5744 Style); 5745 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5746 " aaaaa :\n" 5747 " bbbbbbbbbbbbbbb + cccccccccccccccc;", 5748 Style); 5749 } 5750 5751 TEST_F(FormatTest, DeclarationsOfMultipleVariables) { 5752 verifyFormat("bool aaaaaaaaaaaaaaaaa = aaaaaa->aaaaaaaaaaaaaaaaa(),\n" 5753 " aaaaaaaaaaa = aaaaaa->aaaaaaaaaaa();"); 5754 verifyFormat("bool a = true, b = false;"); 5755 5756 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaa =\n" 5757 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa),\n" 5758 " bbbbbbbbbbbbbbbbbbbbbbbbb =\n" 5759 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(bbbbbbbbbbbbbbbb);"); 5760 verifyFormat( 5761 "bool aaaaaaaaaaaaaaaaaaaaa =\n" 5762 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb && cccccccccccccccccccccccccccc,\n" 5763 " d = e && f;"); 5764 verifyFormat("aaaaaaaaa a = aaaaaaaaaaaaaaaaaaaa, b = bbbbbbbbbbbbbbbbbbbb,\n" 5765 " c = cccccccccccccccccccc, d = dddddddddddddddddddd;"); 5766 verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n" 5767 " *c = ccccccccccccccccccc, *d = ddddddddddddddddddd;"); 5768 verifyFormat("aaaaaaaaa ***a = aaaaaaaaaaaaaaaaaaa, ***b = bbbbbbbbbbbbbbb,\n" 5769 " ***c = ccccccccccccccccccc, ***d = ddddddddddddddd;"); 5770 5771 FormatStyle Style = getGoogleStyle(); 5772 Style.PointerAlignment = FormatStyle::PAS_Left; 5773 Style.DerivePointerAlignment = false; 5774 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5775 " *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaa,\n" 5776 " *b = bbbbbbbbbbbbbbbbbbb;", 5777 Style); 5778 verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n" 5779 " *b = bbbbbbbbbbbbbbbbbbb, *d = ddddddddddddddddddd;", 5780 Style); 5781 verifyFormat("vector<int*> a, b;", Style); 5782 verifyFormat("for (int *p, *q; p != q; p = p->next) {\n}", Style); 5783 } 5784 5785 TEST_F(FormatTest, ConditionalExpressionsInBrackets) { 5786 verifyFormat("arr[foo ? bar : baz];"); 5787 verifyFormat("f()[foo ? bar : baz];"); 5788 verifyFormat("(a + b)[foo ? bar : baz];"); 5789 verifyFormat("arr[foo ? (4 > 5 ? 4 : 5) : 5 < 5 ? 5 : 7];"); 5790 } 5791 5792 TEST_F(FormatTest, AlignsStringLiterals) { 5793 verifyFormat("loooooooooooooooooooooooooongFunction(\"short literal \"\n" 5794 " \"short literal\");"); 5795 verifyFormat( 5796 "looooooooooooooooooooooooongFunction(\n" 5797 " \"short literal\"\n" 5798 " \"looooooooooooooooooooooooooooooooooooooooooooooooong literal\");"); 5799 verifyFormat("someFunction(\"Always break between multi-line\"\n" 5800 " \" string literals\",\n" 5801 " and, other, parameters);"); 5802 EXPECT_EQ("fun + \"1243\" /* comment */\n" 5803 " \"5678\";", 5804 format("fun + \"1243\" /* comment */\n" 5805 " \"5678\";", 5806 getLLVMStyleWithColumns(28))); 5807 EXPECT_EQ( 5808 "aaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 5809 " \"aaaaaaaaaaaaaaaaaaaaa\"\n" 5810 " \"aaaaaaaaaaaaaaaa\";", 5811 format("aaaaaa =" 5812 "\"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa " 5813 "aaaaaaaaaaaaaaaaaaaaa\" " 5814 "\"aaaaaaaaaaaaaaaa\";")); 5815 verifyFormat("a = a + \"a\"\n" 5816 " \"a\"\n" 5817 " \"a\";"); 5818 verifyFormat("f(\"a\", \"b\"\n" 5819 " \"c\");"); 5820 5821 verifyFormat( 5822 "#define LL_FORMAT \"ll\"\n" 5823 "printf(\"aaaaa: %d, bbbbbb: %\" LL_FORMAT \"d, cccccccc: %\" LL_FORMAT\n" 5824 " \"d, ddddddddd: %\" LL_FORMAT \"d\");"); 5825 5826 verifyFormat("#define A(X) \\\n" 5827 " \"aaaaa\" #X \"bbbbbb\" \\\n" 5828 " \"ccccc\"", 5829 getLLVMStyleWithColumns(23)); 5830 verifyFormat("#define A \"def\"\n" 5831 "f(\"abc\" A \"ghi\"\n" 5832 " \"jkl\");"); 5833 5834 verifyFormat("f(L\"a\"\n" 5835 " L\"b\");"); 5836 verifyFormat("#define A(X) \\\n" 5837 " L\"aaaaa\" #X L\"bbbbbb\" \\\n" 5838 " L\"ccccc\"", 5839 getLLVMStyleWithColumns(25)); 5840 5841 verifyFormat("f(@\"a\"\n" 5842 " @\"b\");"); 5843 verifyFormat("NSString s = @\"a\"\n" 5844 " @\"b\"\n" 5845 " @\"c\";"); 5846 verifyFormat("NSString s = @\"a\"\n" 5847 " \"b\"\n" 5848 " \"c\";"); 5849 } 5850 5851 TEST_F(FormatTest, ReturnTypeBreakingStyle) { 5852 FormatStyle Style = getLLVMStyle(); 5853 // No declarations or definitions should be moved to own line. 5854 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_None; 5855 verifyFormat("class A {\n" 5856 " int f() { return 1; }\n" 5857 " int g();\n" 5858 "};\n" 5859 "int f() { return 1; }\n" 5860 "int g();\n", 5861 Style); 5862 5863 // All declarations and definitions should have the return type moved to its 5864 // own 5865 // line. 5866 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All; 5867 verifyFormat("class E {\n" 5868 " int\n" 5869 " f() {\n" 5870 " return 1;\n" 5871 " }\n" 5872 " int\n" 5873 " g();\n" 5874 "};\n" 5875 "int\n" 5876 "f() {\n" 5877 " return 1;\n" 5878 "}\n" 5879 "int\n" 5880 "g();\n", 5881 Style); 5882 5883 // Top-level definitions, and no kinds of declarations should have the 5884 // return type moved to its own line. 5885 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevelDefinitions; 5886 verifyFormat("class B {\n" 5887 " int f() { return 1; }\n" 5888 " int g();\n" 5889 "};\n" 5890 "int\n" 5891 "f() {\n" 5892 " return 1;\n" 5893 "}\n" 5894 "int g();\n", 5895 Style); 5896 5897 // Top-level definitions and declarations should have the return type moved 5898 // to its own line. 5899 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevel; 5900 verifyFormat("class C {\n" 5901 " int f() { return 1; }\n" 5902 " int g();\n" 5903 "};\n" 5904 "int\n" 5905 "f() {\n" 5906 " return 1;\n" 5907 "}\n" 5908 "int\n" 5909 "g();\n", 5910 Style); 5911 5912 // All definitions should have the return type moved to its own line, but no 5913 // kinds of declarations. 5914 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions; 5915 verifyFormat("class D {\n" 5916 " int\n" 5917 " f() {\n" 5918 " return 1;\n" 5919 " }\n" 5920 " int g();\n" 5921 "};\n" 5922 "int\n" 5923 "f() {\n" 5924 " return 1;\n" 5925 "}\n" 5926 "int g();\n", 5927 Style); 5928 verifyFormat("const char *\n" 5929 "f(void) {\n" // Break here. 5930 " return \"\";\n" 5931 "}\n" 5932 "const char *bar(void);\n", // No break here. 5933 Style); 5934 verifyFormat("template <class T>\n" 5935 "T *\n" 5936 "f(T &c) {\n" // Break here. 5937 " return NULL;\n" 5938 "}\n" 5939 "template <class T> T *f(T &c);\n", // No break here. 5940 Style); 5941 verifyFormat("class C {\n" 5942 " int\n" 5943 " operator+() {\n" 5944 " return 1;\n" 5945 " }\n" 5946 " int\n" 5947 " operator()() {\n" 5948 " return 1;\n" 5949 " }\n" 5950 "};\n", 5951 Style); 5952 verifyFormat("void\n" 5953 "A::operator()() {}\n" 5954 "void\n" 5955 "A::operator>>() {}\n" 5956 "void\n" 5957 "A::operator+() {}\n", 5958 Style); 5959 verifyFormat("void *operator new(std::size_t s);", // No break here. 5960 Style); 5961 verifyFormat("void *\n" 5962 "operator new(std::size_t s) {}", 5963 Style); 5964 verifyFormat("void *\n" 5965 "operator delete[](void *ptr) {}", 5966 Style); 5967 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 5968 verifyFormat("const char *\n" 5969 "f(void)\n" // Break here. 5970 "{\n" 5971 " return \"\";\n" 5972 "}\n" 5973 "const char *bar(void);\n", // No break here. 5974 Style); 5975 verifyFormat("template <class T>\n" 5976 "T *\n" // Problem here: no line break 5977 "f(T &c)\n" // Break here. 5978 "{\n" 5979 " return NULL;\n" 5980 "}\n" 5981 "template <class T> T *f(T &c);\n", // No break here. 5982 Style); 5983 verifyFormat("int\n" 5984 "foo(A<bool> a)\n" 5985 "{\n" 5986 " return a;\n" 5987 "}\n", 5988 Style); 5989 verifyFormat("int\n" 5990 "foo(A<8> a)\n" 5991 "{\n" 5992 " return a;\n" 5993 "}\n", 5994 Style); 5995 verifyFormat("int\n" 5996 "foo(A<B<bool>, 8> a)\n" 5997 "{\n" 5998 " return a;\n" 5999 "}\n", 6000 Style); 6001 verifyFormat("int\n" 6002 "foo(A<B<8>, bool> a)\n" 6003 "{\n" 6004 " return a;\n" 6005 "}\n", 6006 Style); 6007 verifyFormat("int\n" 6008 "foo(A<B<bool>, bool> a)\n" 6009 "{\n" 6010 " return a;\n" 6011 "}\n", 6012 Style); 6013 verifyFormat("int\n" 6014 "foo(A<B<8>, 8> a)\n" 6015 "{\n" 6016 " return a;\n" 6017 "}\n", 6018 Style); 6019 6020 Style = getGNUStyle(); 6021 6022 // Test for comments at the end of function declarations. 6023 verifyFormat("void\n" 6024 "foo (int a, /*abc*/ int b) // def\n" 6025 "{\n" 6026 "}\n", 6027 Style); 6028 6029 verifyFormat("void\n" 6030 "foo (int a, /* abc */ int b) /* def */\n" 6031 "{\n" 6032 "}\n", 6033 Style); 6034 6035 // Definitions that should not break after return type 6036 verifyFormat("void foo (int a, int b); // def\n", Style); 6037 verifyFormat("void foo (int a, int b); /* def */\n", Style); 6038 verifyFormat("void foo (int a, int b);\n", Style); 6039 } 6040 6041 TEST_F(FormatTest, AlwaysBreakBeforeMultilineStrings) { 6042 FormatStyle NoBreak = getLLVMStyle(); 6043 NoBreak.AlwaysBreakBeforeMultilineStrings = false; 6044 FormatStyle Break = getLLVMStyle(); 6045 Break.AlwaysBreakBeforeMultilineStrings = true; 6046 verifyFormat("aaaa = \"bbbb\"\n" 6047 " \"cccc\";", 6048 NoBreak); 6049 verifyFormat("aaaa =\n" 6050 " \"bbbb\"\n" 6051 " \"cccc\";", 6052 Break); 6053 verifyFormat("aaaa(\"bbbb\"\n" 6054 " \"cccc\");", 6055 NoBreak); 6056 verifyFormat("aaaa(\n" 6057 " \"bbbb\"\n" 6058 " \"cccc\");", 6059 Break); 6060 verifyFormat("aaaa(qqq, \"bbbb\"\n" 6061 " \"cccc\");", 6062 NoBreak); 6063 verifyFormat("aaaa(qqq,\n" 6064 " \"bbbb\"\n" 6065 " \"cccc\");", 6066 Break); 6067 verifyFormat("aaaa(qqq,\n" 6068 " L\"bbbb\"\n" 6069 " L\"cccc\");", 6070 Break); 6071 verifyFormat("aaaaa(aaaaaa, aaaaaaa(\"aaaa\"\n" 6072 " \"bbbb\"));", 6073 Break); 6074 verifyFormat("string s = someFunction(\n" 6075 " \"abc\"\n" 6076 " \"abc\");", 6077 Break); 6078 6079 // As we break before unary operators, breaking right after them is bad. 6080 verifyFormat("string foo = abc ? \"x\"\n" 6081 " \"blah blah blah blah blah blah\"\n" 6082 " : \"y\";", 6083 Break); 6084 6085 // Don't break if there is no column gain. 6086 verifyFormat("f(\"aaaa\"\n" 6087 " \"bbbb\");", 6088 Break); 6089 6090 // Treat literals with escaped newlines like multi-line string literals. 6091 EXPECT_EQ("x = \"a\\\n" 6092 "b\\\n" 6093 "c\";", 6094 format("x = \"a\\\n" 6095 "b\\\n" 6096 "c\";", 6097 NoBreak)); 6098 EXPECT_EQ("xxxx =\n" 6099 " \"a\\\n" 6100 "b\\\n" 6101 "c\";", 6102 format("xxxx = \"a\\\n" 6103 "b\\\n" 6104 "c\";", 6105 Break)); 6106 6107 EXPECT_EQ("NSString *const kString =\n" 6108 " @\"aaaa\"\n" 6109 " @\"bbbb\";", 6110 format("NSString *const kString = @\"aaaa\"\n" 6111 "@\"bbbb\";", 6112 Break)); 6113 6114 Break.ColumnLimit = 0; 6115 verifyFormat("const char *hello = \"hello llvm\";", Break); 6116 } 6117 6118 TEST_F(FormatTest, AlignsPipes) { 6119 verifyFormat( 6120 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6121 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6122 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6123 verifyFormat( 6124 "aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa\n" 6125 " << aaaaaaaaaaaaaaaaaaaa;"); 6126 verifyFormat( 6127 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6128 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6129 verifyFormat( 6130 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 6131 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6132 verifyFormat( 6133 "llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"\n" 6134 " \"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\"\n" 6135 " << \"ccccccccccccccccccccccccccccccccccccccccccccccccc\";"); 6136 verifyFormat( 6137 "aaaaaaaa << (aaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6138 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6139 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6140 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6141 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6142 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6143 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 6144 verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaaaaaa: \"\n" 6145 " << aaaaaaaaaaaaaaaaa(aaaaaaaa, aaaaaaaaaaa);"); 6146 verifyFormat( 6147 "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6148 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6149 verifyFormat( 6150 "auto Diag = diag() << aaaaaaaaaaaaaaaa(aaaaaaaaaaaa, aaaaaaaaaaaaa,\n" 6151 " aaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6152 6153 verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \"\n" 6154 " << aaaaaaaa.aaaaaaaaaaaa(aaa)->aaaaaaaaaaaaaa();"); 6155 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6156 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6157 " aaaaaaaaaaaaaaaaaaaaa)\n" 6158 " << aaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6159 verifyFormat("LOG_IF(aaa == //\n" 6160 " bbb)\n" 6161 " << a << b;"); 6162 6163 // But sometimes, breaking before the first "<<" is desirable. 6164 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n" 6165 " << aaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaa);"); 6166 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbb)\n" 6167 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6168 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6169 verifyFormat("SemaRef.Diag(Loc, diag::note_for_range_begin_end)\n" 6170 " << BEF << IsTemplate << Description << E->getType();"); 6171 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n" 6172 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6173 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6174 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n" 6175 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6176 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6177 " << aaa;"); 6178 6179 verifyFormat( 6180 "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6181 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6182 6183 // Incomplete string literal. 6184 EXPECT_EQ("llvm::errs() << \"\n" 6185 " << a;", 6186 format("llvm::errs() << \"\n<<a;")); 6187 6188 verifyFormat("void f() {\n" 6189 " CHECK_EQ(aaaa, (*bbbbbbbbb)->cccccc)\n" 6190 " << \"qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\";\n" 6191 "}"); 6192 6193 // Handle 'endl'. 6194 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << endl\n" 6195 " << bbbbbbbbbbbbbbbbbbbbbb << endl;"); 6196 verifyFormat("llvm::errs() << endl << bbbbbbbbbbbbbbbbbbbbbb << endl;"); 6197 6198 // Handle '\n'. 6199 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \"\\n\"\n" 6200 " << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";"); 6201 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \'\\n\'\n" 6202 " << bbbbbbbbbbbbbbbbbbbbbb << \'\\n\';"); 6203 verifyFormat("llvm::errs() << aaaa << \"aaaaaaaaaaaaaaaaaa\\n\"\n" 6204 " << bbbb << \"bbbbbbbbbbbbbbbbbb\\n\";"); 6205 verifyFormat("llvm::errs() << \"\\n\" << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";"); 6206 } 6207 6208 TEST_F(FormatTest, KeepStringLabelValuePairsOnALine) { 6209 verifyFormat("return out << \"somepacket = {\\n\"\n" 6210 " << \" aaaaaa = \" << pkt.aaaaaa << \"\\n\"\n" 6211 " << \" bbbb = \" << pkt.bbbb << \"\\n\"\n" 6212 " << \" cccccc = \" << pkt.cccccc << \"\\n\"\n" 6213 " << \" ddd = [\" << pkt.ddd << \"]\\n\"\n" 6214 " << \"}\";"); 6215 6216 verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n" 6217 " << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n" 6218 " << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa;"); 6219 verifyFormat( 6220 "llvm::outs() << \"aaaaaaaaaaaaaaaaa = \" << aaaaaaaaaaaaaaaaa\n" 6221 " << \"bbbbbbbbbbbbbbbbb = \" << bbbbbbbbbbbbbbbbb\n" 6222 " << \"ccccccccccccccccc = \" << ccccccccccccccccc\n" 6223 " << \"ddddddddddddddddd = \" << ddddddddddddddddd\n" 6224 " << \"eeeeeeeeeeeeeeeee = \" << eeeeeeeeeeeeeeeee;"); 6225 verifyFormat("llvm::outs() << aaaaaaaaaaaaaaaaaaaaaaaa << \"=\"\n" 6226 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 6227 verifyFormat( 6228 "void f() {\n" 6229 " llvm::outs() << \"aaaaaaaaaaaaaaaaaaaa: \"\n" 6230 " << aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 6231 "}"); 6232 6233 // Breaking before the first "<<" is generally not desirable. 6234 verifyFormat( 6235 "llvm::errs()\n" 6236 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6237 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6238 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6239 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 6240 getLLVMStyleWithColumns(70)); 6241 verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaa: \"\n" 6242 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6243 " << \"aaaaaaaaaaaaaaaaaaa: \"\n" 6244 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6245 " << \"aaaaaaaaaaaaaaaaaaa: \"\n" 6246 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 6247 getLLVMStyleWithColumns(70)); 6248 6249 verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n" 6250 " \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n" 6251 " \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa;"); 6252 verifyFormat("string v = StrCat(\"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n" 6253 " \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n" 6254 " \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa);"); 6255 verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" +\n" 6256 " (aaaa + aaaa);", 6257 getLLVMStyleWithColumns(40)); 6258 verifyFormat("string v = StrCat(\"aaaaaaaaaaaa: \" +\n" 6259 " (aaaaaaa + aaaaa));", 6260 getLLVMStyleWithColumns(40)); 6261 verifyFormat( 6262 "string v = StrCat(\"aaaaaaaaaaaaaaaaaaaaaaaaaaa: \",\n" 6263 " SomeFunction(aaaaaaaaaaaa, aaaaaaaa.aaaaaaa),\n" 6264 " bbbbbbbbbbbbbbbbbbbbbbb);"); 6265 } 6266 6267 TEST_F(FormatTest, UnderstandsEquals) { 6268 verifyFormat( 6269 "aaaaaaaaaaaaaaaaa =\n" 6270 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6271 verifyFormat( 6272 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 6273 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 6274 verifyFormat( 6275 "if (a) {\n" 6276 " f();\n" 6277 "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 6278 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 6279 "}"); 6280 6281 verifyFormat("if (int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 6282 " 100000000 + 10000000) {\n}"); 6283 } 6284 6285 TEST_F(FormatTest, WrapsAtFunctionCallsIfNecessary) { 6286 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n" 6287 " .looooooooooooooooooooooooooooooooooooooongFunction();"); 6288 6289 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n" 6290 " ->looooooooooooooooooooooooooooooooooooooongFunction();"); 6291 6292 verifyFormat( 6293 "LooooooooooooooooooooooooooooooooongObject->shortFunction(Parameter1,\n" 6294 " Parameter2);"); 6295 6296 verifyFormat( 6297 "ShortObject->shortFunction(\n" 6298 " LooooooooooooooooooooooooooooooooooooooooooooooongParameter1,\n" 6299 " LooooooooooooooooooooooooooooooooooooooooooooooongParameter2);"); 6300 6301 verifyFormat("loooooooooooooongFunction(\n" 6302 " LoooooooooooooongObject->looooooooooooooooongFunction());"); 6303 6304 verifyFormat( 6305 "function(LoooooooooooooooooooooooooooooooooooongObject\n" 6306 " ->loooooooooooooooooooooooooooooooooooooooongFunction());"); 6307 6308 verifyFormat("EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n" 6309 " .WillRepeatedly(Return(SomeValue));"); 6310 verifyFormat("void f() {\n" 6311 " EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n" 6312 " .Times(2)\n" 6313 " .WillRepeatedly(Return(SomeValue));\n" 6314 "}"); 6315 verifyFormat("SomeMap[std::pair(aaaaaaaaaaaa, bbbbbbbbbbbbbbb)].insert(\n" 6316 " ccccccccccccccccccccccc);"); 6317 verifyFormat("aaaaa(aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6318 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6319 " .aaaaa(aaaaa),\n" 6320 " aaaaaaaaaaaaaaaaaaaaa);"); 6321 verifyFormat("void f() {\n" 6322 " aaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6323 " aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa)->aaaaaaaaa());\n" 6324 "}"); 6325 verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6326 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6327 " .aaaaaaaaaaaaaaa(aa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6328 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6329 " aaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 6330 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6331 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6332 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6333 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()) {\n" 6334 "}"); 6335 6336 // Here, it is not necessary to wrap at "." or "->". 6337 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaa) ||\n" 6338 " aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 6339 verifyFormat( 6340 "aaaaaaaaaaa->aaaaaaaaa(\n" 6341 " aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6342 " aaaaaaaaaaaaaaaaaa->aaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa));\n"); 6343 6344 verifyFormat( 6345 "aaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6346 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa().aaaaaaaaaaaaaaaaa());"); 6347 verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() *\n" 6348 " aaaaaaaaa()->aaaaaa()->aaaaa());"); 6349 verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() ||\n" 6350 " aaaaaaaaa()->aaaaaa()->aaaaa());"); 6351 6352 verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6353 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6354 " .a();"); 6355 6356 FormatStyle NoBinPacking = getLLVMStyle(); 6357 NoBinPacking.BinPackParameters = false; 6358 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n" 6359 " .aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n" 6360 " .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa,\n" 6361 " aaaaaaaaaaaaaaaaaaa,\n" 6362 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 6363 NoBinPacking); 6364 6365 // If there is a subsequent call, change to hanging indentation. 6366 verifyFormat( 6367 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6368 " aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa))\n" 6369 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6370 verifyFormat( 6371 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6372 " aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa));"); 6373 verifyFormat("aaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6374 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6375 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6376 verifyFormat("aaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6377 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6378 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());"); 6379 } 6380 6381 TEST_F(FormatTest, WrapsTemplateDeclarations) { 6382 verifyFormat("template <typename T>\n" 6383 "virtual void loooooooooooongFunction(int Param1, int Param2);"); 6384 verifyFormat("template <typename T>\n" 6385 "// T should be one of {A, B}.\n" 6386 "virtual void loooooooooooongFunction(int Param1, int Param2);"); 6387 verifyFormat( 6388 "template <typename T>\n" 6389 "using comment_to_xml_conversion = comment_to_xml_conversion<T, int>;"); 6390 verifyFormat("template <typename T>\n" 6391 "void f(int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram1,\n" 6392 " int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram2);"); 6393 verifyFormat( 6394 "template <typename T>\n" 6395 "void looooooooooooooooooooongFunction(int Paaaaaaaaaaaaaaaaaaaaram1,\n" 6396 " int Paaaaaaaaaaaaaaaaaaaaram2);"); 6397 verifyFormat( 6398 "template <typename T>\n" 6399 "aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaa,\n" 6400 " aaaaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaa,\n" 6401 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6402 verifyFormat("template <typename T>\n" 6403 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6404 " int aaaaaaaaaaaaaaaaaaaaaa);"); 6405 verifyFormat( 6406 "template <typename T1, typename T2 = char, typename T3 = char,\n" 6407 " typename T4 = char>\n" 6408 "void f();"); 6409 verifyFormat("template <typename aaaaaaaaaaa, typename bbbbbbbbbbbbb,\n" 6410 " template <typename> class cccccccccccccccccccccc,\n" 6411 " typename ddddddddddddd>\n" 6412 "class C {};"); 6413 verifyFormat( 6414 "aaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>(\n" 6415 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6416 6417 verifyFormat("void f() {\n" 6418 " a<aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaa>(\n" 6419 " a(aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));\n" 6420 "}"); 6421 6422 verifyFormat("template <typename T> class C {};"); 6423 verifyFormat("template <typename T> void f();"); 6424 verifyFormat("template <typename T> void f() {}"); 6425 verifyFormat( 6426 "aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n" 6427 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6428 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> *aaaa =\n" 6429 " new aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n" 6430 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6431 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>(\n" 6432 " bbbbbbbbbbbbbbbbbbbbbbbb);", 6433 getLLVMStyleWithColumns(72)); 6434 EXPECT_EQ("static_cast<A< //\n" 6435 " B> *>(\n" 6436 "\n" 6437 ");", 6438 format("static_cast<A<//\n" 6439 " B>*>(\n" 6440 "\n" 6441 " );")); 6442 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6443 " const typename aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaa);"); 6444 6445 FormatStyle AlwaysBreak = getLLVMStyle(); 6446 AlwaysBreak.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes; 6447 verifyFormat("template <typename T>\nclass C {};", AlwaysBreak); 6448 verifyFormat("template <typename T>\nvoid f();", AlwaysBreak); 6449 verifyFormat("template <typename T>\nvoid f() {}", AlwaysBreak); 6450 verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6451 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n" 6452 " ccccccccccccccccccccccccccccccccccccccccccccccc);"); 6453 verifyFormat("template <template <typename> class Fooooooo,\n" 6454 " template <typename> class Baaaaaaar>\n" 6455 "struct C {};", 6456 AlwaysBreak); 6457 verifyFormat("template <typename T> // T can be A, B or C.\n" 6458 "struct C {};", 6459 AlwaysBreak); 6460 verifyFormat("template <enum E> class A {\n" 6461 "public:\n" 6462 " E *f();\n" 6463 "};"); 6464 6465 FormatStyle NeverBreak = getLLVMStyle(); 6466 NeverBreak.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_No; 6467 verifyFormat("template <typename T> class C {};", NeverBreak); 6468 verifyFormat("template <typename T> void f();", NeverBreak); 6469 verifyFormat("template <typename T> void f() {}", NeverBreak); 6470 verifyFormat("template <typename T>\nvoid foo(aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbbbb) {}", 6471 NeverBreak); 6472 verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6473 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n" 6474 " ccccccccccccccccccccccccccccccccccccccccccccccc);", 6475 NeverBreak); 6476 verifyFormat("template <template <typename> class Fooooooo,\n" 6477 " template <typename> class Baaaaaaar>\n" 6478 "struct C {};", 6479 NeverBreak); 6480 verifyFormat("template <typename T> // T can be A, B or C.\n" 6481 "struct C {};", 6482 NeverBreak); 6483 verifyFormat("template <enum E> class A {\n" 6484 "public:\n" 6485 " E *f();\n" 6486 "};", NeverBreak); 6487 NeverBreak.PenaltyBreakTemplateDeclaration = 100; 6488 verifyFormat("template <typename T> void\nfoo(aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbbbb) {}", 6489 NeverBreak); 6490 } 6491 6492 TEST_F(FormatTest, WrapsTemplateDeclarationsWithComments) { 6493 FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp); 6494 Style.ColumnLimit = 60; 6495 EXPECT_EQ("// Baseline - no comments.\n" 6496 "template <\n" 6497 " typename aaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbbb>::value>\n" 6498 "void f() {}", 6499 format("// Baseline - no comments.\n" 6500 "template <\n" 6501 " typename aaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbbb>::value>\n" 6502 "void f() {}", 6503 Style)); 6504 6505 EXPECT_EQ("template <\n" 6506 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 6507 "void f() {}", 6508 format("template <\n" 6509 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 6510 "void f() {}", 6511 Style)); 6512 6513 EXPECT_EQ( 6514 "template <\n" 6515 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> /* line */\n" 6516 "void f() {}", 6517 format("template <typename aaaaaaaaaa<bbbbbbbbbbbb>::value> /* line */\n" 6518 "void f() {}", 6519 Style)); 6520 6521 EXPECT_EQ( 6522 "template <\n" 6523 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 6524 " // multiline\n" 6525 "void f() {}", 6526 format("template <\n" 6527 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 6528 " // multiline\n" 6529 "void f() {}", 6530 Style)); 6531 6532 EXPECT_EQ( 6533 "template <typename aaaaaaaaaa<\n" 6534 " bbbbbbbbbbbb>::value> // trailing loooong\n" 6535 "void f() {}", 6536 format( 6537 "template <\n" 6538 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing loooong\n" 6539 "void f() {}", 6540 Style)); 6541 } 6542 6543 TEST_F(FormatTest, WrapsTemplateParameters) { 6544 FormatStyle Style = getLLVMStyle(); 6545 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 6546 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 6547 verifyFormat( 6548 "template <typename... a> struct q {};\n" 6549 "extern q<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n" 6550 " aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n" 6551 " y;", 6552 Style); 6553 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 6554 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 6555 verifyFormat( 6556 "template <typename... a> struct r {};\n" 6557 "extern r<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n" 6558 " aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n" 6559 " y;", 6560 Style); 6561 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 6562 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 6563 verifyFormat( 6564 "template <typename... a> struct s {};\n" 6565 "extern s<\n" 6566 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n" 6567 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa>\n" 6568 " y;", 6569 Style); 6570 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 6571 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 6572 verifyFormat( 6573 "template <typename... a> struct t {};\n" 6574 "extern t<\n" 6575 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n" 6576 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa>\n" 6577 " y;", 6578 Style); 6579 } 6580 6581 TEST_F(FormatTest, WrapsAtNestedNameSpecifiers) { 6582 verifyFormat( 6583 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6584 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6585 verifyFormat( 6586 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6587 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6588 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());"); 6589 6590 // FIXME: Should we have the extra indent after the second break? 6591 verifyFormat( 6592 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6593 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6594 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6595 6596 verifyFormat( 6597 "aaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb::\n" 6598 " cccccccccccccccccccccccccccccccccccccccccccccc());"); 6599 6600 // Breaking at nested name specifiers is generally not desirable. 6601 verifyFormat( 6602 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6603 " aaaaaaaaaaaaaaaaaaaaaaa);"); 6604 6605 verifyFormat( 6606 "aaaaaaaaaaaaaaaaaa(aaaaaaaa,\n" 6607 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6608 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6609 " aaaaaaaaaaaaaaaaaaaaa);", 6610 getLLVMStyleWithColumns(74)); 6611 6612 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6613 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6614 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6615 } 6616 6617 TEST_F(FormatTest, UnderstandsTemplateParameters) { 6618 verifyFormat("A<int> a;"); 6619 verifyFormat("A<A<A<int>>> a;"); 6620 verifyFormat("A<A<A<int, 2>, 3>, 4> a;"); 6621 verifyFormat("bool x = a < 1 || 2 > a;"); 6622 verifyFormat("bool x = 5 < f<int>();"); 6623 verifyFormat("bool x = f<int>() > 5;"); 6624 verifyFormat("bool x = 5 < a<int>::x;"); 6625 verifyFormat("bool x = a < 4 ? a > 2 : false;"); 6626 verifyFormat("bool x = f() ? a < 2 : a > 2;"); 6627 6628 verifyGoogleFormat("A<A<int>> a;"); 6629 verifyGoogleFormat("A<A<A<int>>> a;"); 6630 verifyGoogleFormat("A<A<A<A<int>>>> a;"); 6631 verifyGoogleFormat("A<A<int> > a;"); 6632 verifyGoogleFormat("A<A<A<int> > > a;"); 6633 verifyGoogleFormat("A<A<A<A<int> > > > a;"); 6634 verifyGoogleFormat("A<::A<int>> a;"); 6635 verifyGoogleFormat("A<::A> a;"); 6636 verifyGoogleFormat("A< ::A> a;"); 6637 verifyGoogleFormat("A< ::A<int> > a;"); 6638 EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A> >> a;", getGoogleStyle())); 6639 EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A>> > a;", getGoogleStyle())); 6640 EXPECT_EQ("A<::A<int>> a;", format("A< ::A<int>> a;", getGoogleStyle())); 6641 EXPECT_EQ("A<::A<int>> a;", format("A<::A<int> > a;", getGoogleStyle())); 6642 EXPECT_EQ("auto x = [] { A<A<A<A>>> a; };", 6643 format("auto x=[]{A<A<A<A> >> a;};", getGoogleStyle())); 6644 6645 verifyFormat("A<A<int>> a;", getChromiumStyle(FormatStyle::LK_Cpp)); 6646 6647 // template closer followed by a token that starts with > or = 6648 verifyFormat("bool b = a<1> > 1;"); 6649 verifyFormat("bool b = a<1> >= 1;"); 6650 verifyFormat("int i = a<1> >> 1;"); 6651 FormatStyle Style = getLLVMStyle(); 6652 Style.SpaceBeforeAssignmentOperators = false; 6653 verifyFormat("bool b= a<1> == 1;", Style); 6654 verifyFormat("a<int> = 1;", Style); 6655 verifyFormat("a<int> >>= 1;", Style); 6656 6657 verifyFormat("test >> a >> b;"); 6658 verifyFormat("test << a >> b;"); 6659 6660 verifyFormat("f<int>();"); 6661 verifyFormat("template <typename T> void f() {}"); 6662 verifyFormat("struct A<std::enable_if<sizeof(T2) < sizeof(int32)>::type>;"); 6663 verifyFormat("struct A<std::enable_if<sizeof(T2) ? sizeof(int32) : " 6664 "sizeof(char)>::type>;"); 6665 verifyFormat("template <class T> struct S<std::is_arithmetic<T>{}> {};"); 6666 verifyFormat("f(a.operator()<A>());"); 6667 verifyFormat("f(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6668 " .template operator()<A>());", 6669 getLLVMStyleWithColumns(35)); 6670 6671 // Not template parameters. 6672 verifyFormat("return a < b && c > d;"); 6673 verifyFormat("void f() {\n" 6674 " while (a < b && c > d) {\n" 6675 " }\n" 6676 "}"); 6677 verifyFormat("template <typename... Types>\n" 6678 "typename enable_if<0 < sizeof...(Types)>::type Foo() {}"); 6679 6680 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6681 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa >> aaaaa);", 6682 getLLVMStyleWithColumns(60)); 6683 verifyFormat("static_assert(is_convertible<A &&, B>::value, \"AAA\");"); 6684 verifyFormat("Constructor(A... a) : a_(X<A>{std::forward<A>(a)}...) {}"); 6685 verifyFormat("< < < < < < < < < < < < < < < < < < < < < < < < < < < < < <"); 6686 } 6687 6688 TEST_F(FormatTest, BitshiftOperatorWidth) { 6689 EXPECT_EQ("int a = 1 << 2; /* foo\n" 6690 " bar */", 6691 format("int a=1<<2; /* foo\n" 6692 " bar */")); 6693 6694 EXPECT_EQ("int b = 256 >> 1; /* foo\n" 6695 " bar */", 6696 format("int b =256>>1 ; /* foo\n" 6697 " bar */")); 6698 } 6699 6700 TEST_F(FormatTest, UnderstandsBinaryOperators) { 6701 verifyFormat("COMPARE(a, ==, b);"); 6702 verifyFormat("auto s = sizeof...(Ts) - 1;"); 6703 } 6704 6705 TEST_F(FormatTest, UnderstandsPointersToMembers) { 6706 verifyFormat("int A::*x;"); 6707 verifyFormat("int (S::*func)(void *);"); 6708 verifyFormat("void f() { int (S::*func)(void *); }"); 6709 verifyFormat("typedef bool *(Class::*Member)() const;"); 6710 verifyFormat("void f() {\n" 6711 " (a->*f)();\n" 6712 " a->*x;\n" 6713 " (a.*f)();\n" 6714 " ((*a).*f)();\n" 6715 " a.*x;\n" 6716 "}"); 6717 verifyFormat("void f() {\n" 6718 " (a->*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n" 6719 " aaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);\n" 6720 "}"); 6721 verifyFormat( 6722 "(aaaaaaaaaa->*bbbbbbb)(\n" 6723 " aaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 6724 FormatStyle Style = getLLVMStyle(); 6725 Style.PointerAlignment = FormatStyle::PAS_Left; 6726 verifyFormat("typedef bool* (Class::*Member)() const;", Style); 6727 } 6728 6729 TEST_F(FormatTest, UnderstandsUnaryOperators) { 6730 verifyFormat("int a = -2;"); 6731 verifyFormat("f(-1, -2, -3);"); 6732 verifyFormat("a[-1] = 5;"); 6733 verifyFormat("int a = 5 + -2;"); 6734 verifyFormat("if (i == -1) {\n}"); 6735 verifyFormat("if (i != -1) {\n}"); 6736 verifyFormat("if (i > -1) {\n}"); 6737 verifyFormat("if (i < -1) {\n}"); 6738 verifyFormat("++(a->f());"); 6739 verifyFormat("--(a->f());"); 6740 verifyFormat("(a->f())++;"); 6741 verifyFormat("a[42]++;"); 6742 verifyFormat("if (!(a->f())) {\n}"); 6743 verifyFormat("if (!+i) {\n}"); 6744 verifyFormat("~&a;"); 6745 6746 verifyFormat("a-- > b;"); 6747 verifyFormat("b ? -a : c;"); 6748 verifyFormat("n * sizeof char16;"); 6749 verifyFormat("n * alignof char16;", getGoogleStyle()); 6750 verifyFormat("sizeof(char);"); 6751 verifyFormat("alignof(char);", getGoogleStyle()); 6752 6753 verifyFormat("return -1;"); 6754 verifyFormat("switch (a) {\n" 6755 "case -1:\n" 6756 " break;\n" 6757 "}"); 6758 verifyFormat("#define X -1"); 6759 verifyFormat("#define X -kConstant"); 6760 6761 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {-5, +3};"); 6762 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {+5, -3};"); 6763 6764 verifyFormat("int a = /* confusing comment */ -1;"); 6765 // FIXME: The space after 'i' is wrong, but hopefully, this is a rare case. 6766 verifyFormat("int a = i /* confusing comment */++;"); 6767 } 6768 6769 TEST_F(FormatTest, DoesNotIndentRelativeToUnaryOperators) { 6770 verifyFormat("if (!aaaaaaaaaa( // break\n" 6771 " aaaaa)) {\n" 6772 "}"); 6773 verifyFormat("aaaaaaaaaa(!aaaaaaaaaa( // break\n" 6774 " aaaaa));"); 6775 verifyFormat("*aaa = aaaaaaa( // break\n" 6776 " bbbbbb);"); 6777 } 6778 6779 TEST_F(FormatTest, UnderstandsOverloadedOperators) { 6780 verifyFormat("bool operator<();"); 6781 verifyFormat("bool operator>();"); 6782 verifyFormat("bool operator=();"); 6783 verifyFormat("bool operator==();"); 6784 verifyFormat("bool operator!=();"); 6785 verifyFormat("int operator+();"); 6786 verifyFormat("int operator++();"); 6787 verifyFormat("int operator++(int) volatile noexcept;"); 6788 verifyFormat("bool operator,();"); 6789 verifyFormat("bool operator();"); 6790 verifyFormat("bool operator()();"); 6791 verifyFormat("bool operator[]();"); 6792 verifyFormat("operator bool();"); 6793 verifyFormat("operator int();"); 6794 verifyFormat("operator void *();"); 6795 verifyFormat("operator SomeType<int>();"); 6796 verifyFormat("operator SomeType<int, int>();"); 6797 verifyFormat("operator SomeType<SomeType<int>>();"); 6798 verifyFormat("void *operator new(std::size_t size);"); 6799 verifyFormat("void *operator new[](std::size_t size);"); 6800 verifyFormat("void operator delete(void *ptr);"); 6801 verifyFormat("void operator delete[](void *ptr);"); 6802 verifyFormat("template <typename AAAAAAA, typename BBBBBBB>\n" 6803 "AAAAAAA operator/(const AAAAAAA &a, BBBBBBB &b);"); 6804 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa operator,(\n" 6805 " aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaaaaaaaaaaaaaaaaaaa) const;"); 6806 6807 verifyFormat( 6808 "ostream &operator<<(ostream &OutputStream,\n" 6809 " SomeReallyLongType WithSomeReallyLongValue);"); 6810 verifyFormat("bool operator<(const aaaaaaaaaaaaaaaaaaaaa &left,\n" 6811 " const aaaaaaaaaaaaaaaaaaaaa &right) {\n" 6812 " return left.group < right.group;\n" 6813 "}"); 6814 verifyFormat("SomeType &operator=(const SomeType &S);"); 6815 verifyFormat("f.template operator()<int>();"); 6816 6817 verifyGoogleFormat("operator void*();"); 6818 verifyGoogleFormat("operator SomeType<SomeType<int>>();"); 6819 verifyGoogleFormat("operator ::A();"); 6820 6821 verifyFormat("using A::operator+;"); 6822 verifyFormat("inline A operator^(const A &lhs, const A &rhs) {}\n" 6823 "int i;"); 6824 } 6825 6826 TEST_F(FormatTest, UnderstandsFunctionRefQualification) { 6827 verifyFormat("Deleted &operator=(const Deleted &) & = default;"); 6828 verifyFormat("Deleted &operator=(const Deleted &) && = delete;"); 6829 verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;"); 6830 verifyFormat("SomeType MemberFunction(const Deleted &) && = delete;"); 6831 verifyFormat("Deleted &operator=(const Deleted &) &;"); 6832 verifyFormat("Deleted &operator=(const Deleted &) &&;"); 6833 verifyFormat("SomeType MemberFunction(const Deleted &) &;"); 6834 verifyFormat("SomeType MemberFunction(const Deleted &) &&;"); 6835 verifyFormat("SomeType MemberFunction(const Deleted &) && {}"); 6836 verifyFormat("SomeType MemberFunction(const Deleted &) && final {}"); 6837 verifyFormat("SomeType MemberFunction(const Deleted &) && override {}"); 6838 verifyFormat("void Fn(T const &) const &;"); 6839 verifyFormat("void Fn(T const volatile &&) const volatile &&;"); 6840 verifyFormat("template <typename T>\n" 6841 "void F(T) && = delete;", 6842 getGoogleStyle()); 6843 6844 FormatStyle AlignLeft = getLLVMStyle(); 6845 AlignLeft.PointerAlignment = FormatStyle::PAS_Left; 6846 verifyFormat("void A::b() && {}", AlignLeft); 6847 verifyFormat("Deleted& operator=(const Deleted&) & = default;", AlignLeft); 6848 verifyFormat("SomeType MemberFunction(const Deleted&) & = delete;", 6849 AlignLeft); 6850 verifyFormat("Deleted& operator=(const Deleted&) &;", AlignLeft); 6851 verifyFormat("SomeType MemberFunction(const Deleted&) &;", AlignLeft); 6852 verifyFormat("auto Function(T t) & -> void {}", AlignLeft); 6853 verifyFormat("auto Function(T... t) & -> void {}", AlignLeft); 6854 verifyFormat("auto Function(T) & -> void {}", AlignLeft); 6855 verifyFormat("auto Function(T) & -> void;", AlignLeft); 6856 verifyFormat("void Fn(T const&) const&;", AlignLeft); 6857 verifyFormat("void Fn(T const volatile&&) const volatile&&;", AlignLeft); 6858 6859 FormatStyle Spaces = getLLVMStyle(); 6860 Spaces.SpacesInCStyleCastParentheses = true; 6861 verifyFormat("Deleted &operator=(const Deleted &) & = default;", Spaces); 6862 verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;", Spaces); 6863 verifyFormat("Deleted &operator=(const Deleted &) &;", Spaces); 6864 verifyFormat("SomeType MemberFunction(const Deleted &) &;", Spaces); 6865 6866 Spaces.SpacesInCStyleCastParentheses = false; 6867 Spaces.SpacesInParentheses = true; 6868 verifyFormat("Deleted &operator=( const Deleted & ) & = default;", Spaces); 6869 verifyFormat("SomeType MemberFunction( const Deleted & ) & = delete;", Spaces); 6870 verifyFormat("Deleted &operator=( const Deleted & ) &;", Spaces); 6871 verifyFormat("SomeType MemberFunction( const Deleted & ) &;", Spaces); 6872 } 6873 6874 TEST_F(FormatTest, UnderstandsNewAndDelete) { 6875 verifyFormat("void f() {\n" 6876 " A *a = new A;\n" 6877 " A *a = new (placement) A;\n" 6878 " delete a;\n" 6879 " delete (A *)a;\n" 6880 "}"); 6881 verifyFormat("new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n" 6882 " typename aaaaaaaaaaaaaaaaaaaaaaaa();"); 6883 verifyFormat("auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 6884 " new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n" 6885 " typename aaaaaaaaaaaaaaaaaaaaaaaa();"); 6886 verifyFormat("delete[] h->p;"); 6887 } 6888 6889 TEST_F(FormatTest, UnderstandsUsesOfStarAndAmp) { 6890 verifyFormat("int *f(int *a) {}"); 6891 verifyFormat("int main(int argc, char **argv) {}"); 6892 verifyFormat("Test::Test(int b) : a(b * b) {}"); 6893 verifyIndependentOfContext("f(a, *a);"); 6894 verifyFormat("void g() { f(*a); }"); 6895 verifyIndependentOfContext("int a = b * 10;"); 6896 verifyIndependentOfContext("int a = 10 * b;"); 6897 verifyIndependentOfContext("int a = b * c;"); 6898 verifyIndependentOfContext("int a += b * c;"); 6899 verifyIndependentOfContext("int a -= b * c;"); 6900 verifyIndependentOfContext("int a *= b * c;"); 6901 verifyIndependentOfContext("int a /= b * c;"); 6902 verifyIndependentOfContext("int a = *b;"); 6903 verifyIndependentOfContext("int a = *b * c;"); 6904 verifyIndependentOfContext("int a = b * *c;"); 6905 verifyIndependentOfContext("int a = b * (10);"); 6906 verifyIndependentOfContext("S << b * (10);"); 6907 verifyIndependentOfContext("return 10 * b;"); 6908 verifyIndependentOfContext("return *b * *c;"); 6909 verifyIndependentOfContext("return a & ~b;"); 6910 verifyIndependentOfContext("f(b ? *c : *d);"); 6911 verifyIndependentOfContext("int a = b ? *c : *d;"); 6912 verifyIndependentOfContext("*b = a;"); 6913 verifyIndependentOfContext("a * ~b;"); 6914 verifyIndependentOfContext("a * !b;"); 6915 verifyIndependentOfContext("a * +b;"); 6916 verifyIndependentOfContext("a * -b;"); 6917 verifyIndependentOfContext("a * ++b;"); 6918 verifyIndependentOfContext("a * --b;"); 6919 verifyIndependentOfContext("a[4] * b;"); 6920 verifyIndependentOfContext("a[a * a] = 1;"); 6921 verifyIndependentOfContext("f() * b;"); 6922 verifyIndependentOfContext("a * [self dostuff];"); 6923 verifyIndependentOfContext("int x = a * (a + b);"); 6924 verifyIndependentOfContext("(a *)(a + b);"); 6925 verifyIndependentOfContext("*(int *)(p & ~3UL) = 0;"); 6926 verifyIndependentOfContext("int *pa = (int *)&a;"); 6927 verifyIndependentOfContext("return sizeof(int **);"); 6928 verifyIndependentOfContext("return sizeof(int ******);"); 6929 verifyIndependentOfContext("return (int **&)a;"); 6930 verifyIndependentOfContext("f((*PointerToArray)[10]);"); 6931 verifyFormat("void f(Type (*parameter)[10]) {}"); 6932 verifyFormat("void f(Type (¶meter)[10]) {}"); 6933 verifyGoogleFormat("return sizeof(int**);"); 6934 verifyIndependentOfContext("Type **A = static_cast<Type **>(P);"); 6935 verifyGoogleFormat("Type** A = static_cast<Type**>(P);"); 6936 verifyFormat("auto a = [](int **&, int ***) {};"); 6937 verifyFormat("auto PointerBinding = [](const char *S) {};"); 6938 verifyFormat("typedef typeof(int(int, int)) *MyFunc;"); 6939 verifyFormat("[](const decltype(*a) &value) {}"); 6940 verifyFormat("decltype(a * b) F();"); 6941 verifyFormat("#define MACRO() [](A *a) { return 1; }"); 6942 verifyFormat("Constructor() : member([](A *a, B *b) {}) {}"); 6943 verifyIndependentOfContext("typedef void (*f)(int *a);"); 6944 verifyIndependentOfContext("int i{a * b};"); 6945 verifyIndependentOfContext("aaa && aaa->f();"); 6946 verifyIndependentOfContext("int x = ~*p;"); 6947 verifyFormat("Constructor() : a(a), area(width * height) {}"); 6948 verifyFormat("Constructor() : a(a), area(a, width * height) {}"); 6949 verifyGoogleFormat("MACRO Constructor(const int& i) : a(a), b(b) {}"); 6950 verifyFormat("void f() { f(a, c * d); }"); 6951 verifyFormat("void f() { f(new a(), c * d); }"); 6952 verifyFormat("void f(const MyOverride &override);"); 6953 verifyFormat("void f(const MyFinal &final);"); 6954 verifyIndependentOfContext("bool a = f() && override.f();"); 6955 verifyIndependentOfContext("bool a = f() && final.f();"); 6956 6957 verifyIndependentOfContext("InvalidRegions[*R] = 0;"); 6958 6959 verifyIndependentOfContext("A<int *> a;"); 6960 verifyIndependentOfContext("A<int **> a;"); 6961 verifyIndependentOfContext("A<int *, int *> a;"); 6962 verifyIndependentOfContext("A<int *[]> a;"); 6963 verifyIndependentOfContext( 6964 "const char *const p = reinterpret_cast<const char *const>(q);"); 6965 verifyIndependentOfContext("A<int **, int **> a;"); 6966 verifyIndependentOfContext("void f(int *a = d * e, int *b = c * d);"); 6967 verifyFormat("for (char **a = b; *a; ++a) {\n}"); 6968 verifyFormat("for (; a && b;) {\n}"); 6969 verifyFormat("bool foo = true && [] { return false; }();"); 6970 6971 verifyFormat( 6972 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6973 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa, *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6974 6975 verifyGoogleFormat("int const* a = &b;"); 6976 verifyGoogleFormat("**outparam = 1;"); 6977 verifyGoogleFormat("*outparam = a * b;"); 6978 verifyGoogleFormat("int main(int argc, char** argv) {}"); 6979 verifyGoogleFormat("A<int*> a;"); 6980 verifyGoogleFormat("A<int**> a;"); 6981 verifyGoogleFormat("A<int*, int*> a;"); 6982 verifyGoogleFormat("A<int**, int**> a;"); 6983 verifyGoogleFormat("f(b ? *c : *d);"); 6984 verifyGoogleFormat("int a = b ? *c : *d;"); 6985 verifyGoogleFormat("Type* t = **x;"); 6986 verifyGoogleFormat("Type* t = *++*x;"); 6987 verifyGoogleFormat("*++*x;"); 6988 verifyGoogleFormat("Type* t = const_cast<T*>(&*x);"); 6989 verifyGoogleFormat("Type* t = x++ * y;"); 6990 verifyGoogleFormat( 6991 "const char* const p = reinterpret_cast<const char* const>(q);"); 6992 verifyGoogleFormat("void f(int i = 0, SomeType** temps = NULL);"); 6993 verifyGoogleFormat("void f(Bar* a = nullptr, Bar* b);"); 6994 verifyGoogleFormat("template <typename T>\n" 6995 "void f(int i = 0, SomeType** temps = NULL);"); 6996 6997 FormatStyle Left = getLLVMStyle(); 6998 Left.PointerAlignment = FormatStyle::PAS_Left; 6999 verifyFormat("x = *a(x) = *a(y);", Left); 7000 verifyFormat("for (;; *a = b) {\n}", Left); 7001 verifyFormat("return *this += 1;", Left); 7002 verifyFormat("throw *x;", Left); 7003 verifyFormat("delete *x;", Left); 7004 verifyFormat("typedef typeof(int(int, int))* MyFuncPtr;", Left); 7005 verifyFormat("[](const decltype(*a)* ptr) {}", Left); 7006 verifyFormat("typedef typeof /*comment*/ (int(int, int))* MyFuncPtr;", Left); 7007 7008 verifyIndependentOfContext("a = *(x + y);"); 7009 verifyIndependentOfContext("a = &(x + y);"); 7010 verifyIndependentOfContext("*(x + y).call();"); 7011 verifyIndependentOfContext("&(x + y)->call();"); 7012 verifyFormat("void f() { &(*I).first; }"); 7013 7014 verifyIndependentOfContext("f(b * /* confusing comment */ ++c);"); 7015 verifyFormat( 7016 "int *MyValues = {\n" 7017 " *A, // Operator detection might be confused by the '{'\n" 7018 " *BB // Operator detection might be confused by previous comment\n" 7019 "};"); 7020 7021 verifyIndependentOfContext("if (int *a = &b)"); 7022 verifyIndependentOfContext("if (int &a = *b)"); 7023 verifyIndependentOfContext("if (a & b[i])"); 7024 verifyIndependentOfContext("if constexpr (a & b[i])"); 7025 verifyIndependentOfContext("if CONSTEXPR (a & b[i])"); 7026 verifyIndependentOfContext("if (a * (b * c))"); 7027 verifyIndependentOfContext("if constexpr (a * (b * c))"); 7028 verifyIndependentOfContext("if CONSTEXPR (a * (b * c))"); 7029 verifyIndependentOfContext("if (a::b::c::d & b[i])"); 7030 verifyIndependentOfContext("if (*b[i])"); 7031 verifyIndependentOfContext("if (int *a = (&b))"); 7032 verifyIndependentOfContext("while (int *a = &b)"); 7033 verifyIndependentOfContext("while (a * (b * c))"); 7034 verifyIndependentOfContext("size = sizeof *a;"); 7035 verifyIndependentOfContext("if (a && (b = c))"); 7036 verifyFormat("void f() {\n" 7037 " for (const int &v : Values) {\n" 7038 " }\n" 7039 "}"); 7040 verifyFormat("for (int i = a * a; i < 10; ++i) {\n}"); 7041 verifyFormat("for (int i = 0; i < a * a; ++i) {\n}"); 7042 verifyGoogleFormat("for (int i = 0; i * 2 < z; i *= 2) {\n}"); 7043 7044 verifyFormat("#define A (!a * b)"); 7045 verifyFormat("#define MACRO \\\n" 7046 " int *i = a * b; \\\n" 7047 " void f(a *b);", 7048 getLLVMStyleWithColumns(19)); 7049 7050 verifyIndependentOfContext("A = new SomeType *[Length];"); 7051 verifyIndependentOfContext("A = new SomeType *[Length]();"); 7052 verifyIndependentOfContext("T **t = new T *;"); 7053 verifyIndependentOfContext("T **t = new T *();"); 7054 verifyGoogleFormat("A = new SomeType*[Length]();"); 7055 verifyGoogleFormat("A = new SomeType*[Length];"); 7056 verifyGoogleFormat("T** t = new T*;"); 7057 verifyGoogleFormat("T** t = new T*();"); 7058 7059 verifyFormat("STATIC_ASSERT((a & b) == 0);"); 7060 verifyFormat("STATIC_ASSERT(0 == (a & b));"); 7061 verifyFormat("template <bool a, bool b> " 7062 "typename t::if<x && y>::type f() {}"); 7063 verifyFormat("template <int *y> f() {}"); 7064 verifyFormat("vector<int *> v;"); 7065 verifyFormat("vector<int *const> v;"); 7066 verifyFormat("vector<int *const **const *> v;"); 7067 verifyFormat("vector<int *volatile> v;"); 7068 verifyFormat("vector<a * b> v;"); 7069 verifyFormat("foo<b && false>();"); 7070 verifyFormat("foo<b & 1>();"); 7071 verifyFormat("decltype(*::std::declval<const T &>()) void F();"); 7072 verifyFormat( 7073 "template <class T, class = typename std::enable_if<\n" 7074 " std::is_integral<T>::value &&\n" 7075 " (sizeof(T) > 1 || sizeof(T) < 8)>::type>\n" 7076 "void F();", 7077 getLLVMStyleWithColumns(70)); 7078 verifyFormat( 7079 "template <class T,\n" 7080 " class = typename std::enable_if<\n" 7081 " std::is_integral<T>::value &&\n" 7082 " (sizeof(T) > 1 || sizeof(T) < 8)>::type,\n" 7083 " class U>\n" 7084 "void F();", 7085 getLLVMStyleWithColumns(70)); 7086 verifyFormat( 7087 "template <class T,\n" 7088 " class = typename ::std::enable_if<\n" 7089 " ::std::is_array<T>{} && ::std::is_array<T>{}>::type>\n" 7090 "void F();", 7091 getGoogleStyleWithColumns(68)); 7092 7093 verifyIndependentOfContext("MACRO(int *i);"); 7094 verifyIndependentOfContext("MACRO(auto *a);"); 7095 verifyIndependentOfContext("MACRO(const A *a);"); 7096 verifyIndependentOfContext("MACRO(A *const a);"); 7097 verifyIndependentOfContext("MACRO('0' <= c && c <= '9');"); 7098 verifyFormat("void f() { f(float{1}, a * a); }"); 7099 // FIXME: Is there a way to make this work? 7100 // verifyIndependentOfContext("MACRO(A *a);"); 7101 7102 verifyFormat("DatumHandle const *operator->() const { return input_; }"); 7103 verifyFormat("return options != nullptr && operator==(*options);"); 7104 7105 EXPECT_EQ("#define OP(x) \\\n" 7106 " ostream &operator<<(ostream &s, const A &a) { \\\n" 7107 " return s << a.DebugString(); \\\n" 7108 " }", 7109 format("#define OP(x) \\\n" 7110 " ostream &operator<<(ostream &s, const A &a) { \\\n" 7111 " return s << a.DebugString(); \\\n" 7112 " }", 7113 getLLVMStyleWithColumns(50))); 7114 7115 // FIXME: We cannot handle this case yet; we might be able to figure out that 7116 // foo<x> d > v; doesn't make sense. 7117 verifyFormat("foo<a<b && c> d> v;"); 7118 7119 FormatStyle PointerMiddle = getLLVMStyle(); 7120 PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle; 7121 verifyFormat("delete *x;", PointerMiddle); 7122 verifyFormat("int * x;", PointerMiddle); 7123 verifyFormat("int *[] x;", PointerMiddle); 7124 verifyFormat("template <int * y> f() {}", PointerMiddle); 7125 verifyFormat("int * f(int * a) {}", PointerMiddle); 7126 verifyFormat("int main(int argc, char ** argv) {}", PointerMiddle); 7127 verifyFormat("Test::Test(int b) : a(b * b) {}", PointerMiddle); 7128 verifyFormat("A<int *> a;", PointerMiddle); 7129 verifyFormat("A<int **> a;", PointerMiddle); 7130 verifyFormat("A<int *, int *> a;", PointerMiddle); 7131 verifyFormat("A<int *[]> a;", PointerMiddle); 7132 verifyFormat("A = new SomeType *[Length]();", PointerMiddle); 7133 verifyFormat("A = new SomeType *[Length];", PointerMiddle); 7134 verifyFormat("T ** t = new T *;", PointerMiddle); 7135 7136 // Member function reference qualifiers aren't binary operators. 7137 verifyFormat("string // break\n" 7138 "operator()() & {}"); 7139 verifyFormat("string // break\n" 7140 "operator()() && {}"); 7141 verifyGoogleFormat("template <typename T>\n" 7142 "auto x() & -> int {}"); 7143 } 7144 7145 TEST_F(FormatTest, UnderstandsAttributes) { 7146 verifyFormat("SomeType s __attribute__((unused)) (InitValue);"); 7147 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa __attribute__((unused))\n" 7148 "aaaaaaaaaaaaaaaaaaaaaaa(int i);"); 7149 FormatStyle AfterType = getLLVMStyle(); 7150 AfterType.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions; 7151 verifyFormat("__attribute__((nodebug)) void\n" 7152 "foo() {}\n", 7153 AfterType); 7154 } 7155 7156 TEST_F(FormatTest, UnderstandsSquareAttributes) { 7157 verifyFormat("SomeType s [[unused]] (InitValue);"); 7158 verifyFormat("SomeType s [[gnu::unused]] (InitValue);"); 7159 verifyFormat("SomeType s [[using gnu: unused]] (InitValue);"); 7160 verifyFormat("[[gsl::suppress(\"clang-tidy-check-name\")]] void f() {}"); 7161 verifyFormat("void f() [[deprecated(\"so sorry\")]];"); 7162 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7163 " [[unused]] aaaaaaaaaaaaaaaaaaaaaaa(int i);"); 7164 7165 // Make sure we do not mistake attributes for array subscripts. 7166 verifyFormat("int a() {}\n" 7167 "[[unused]] int b() {}\n"); 7168 verifyFormat("NSArray *arr;\n" 7169 "arr[[Foo() bar]];"); 7170 7171 // On the other hand, we still need to correctly find array subscripts. 7172 verifyFormat("int a = std::vector<int>{1, 2, 3}[0];"); 7173 7174 // Make sure that we do not mistake Objective-C method inside array literals 7175 // as attributes, even if those method names are also keywords. 7176 verifyFormat("@[ [foo bar] ];"); 7177 verifyFormat("@[ [NSArray class] ];"); 7178 verifyFormat("@[ [foo enum] ];"); 7179 7180 // Make sure we do not parse attributes as lambda introducers. 7181 FormatStyle MultiLineFunctions = getLLVMStyle(); 7182 MultiLineFunctions.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 7183 verifyFormat("[[unused]] int b() {\n" 7184 " return 42;\n" 7185 "}\n", 7186 MultiLineFunctions); 7187 } 7188 7189 TEST_F(FormatTest, UnderstandsEllipsis) { 7190 verifyFormat("int printf(const char *fmt, ...);"); 7191 verifyFormat("template <class... Ts> void Foo(Ts... ts) { Foo(ts...); }"); 7192 verifyFormat("template <class... Ts> void Foo(Ts *... ts) {}"); 7193 7194 FormatStyle PointersLeft = getLLVMStyle(); 7195 PointersLeft.PointerAlignment = FormatStyle::PAS_Left; 7196 verifyFormat("template <class... Ts> void Foo(Ts*... ts) {}", PointersLeft); 7197 } 7198 7199 TEST_F(FormatTest, AdaptivelyFormatsPointersAndReferences) { 7200 EXPECT_EQ("int *a;\n" 7201 "int *a;\n" 7202 "int *a;", 7203 format("int *a;\n" 7204 "int* a;\n" 7205 "int *a;", 7206 getGoogleStyle())); 7207 EXPECT_EQ("int* a;\n" 7208 "int* a;\n" 7209 "int* a;", 7210 format("int* a;\n" 7211 "int* a;\n" 7212 "int *a;", 7213 getGoogleStyle())); 7214 EXPECT_EQ("int *a;\n" 7215 "int *a;\n" 7216 "int *a;", 7217 format("int *a;\n" 7218 "int * a;\n" 7219 "int * a;", 7220 getGoogleStyle())); 7221 EXPECT_EQ("auto x = [] {\n" 7222 " int *a;\n" 7223 " int *a;\n" 7224 " int *a;\n" 7225 "};", 7226 format("auto x=[]{int *a;\n" 7227 "int * a;\n" 7228 "int * a;};", 7229 getGoogleStyle())); 7230 } 7231 7232 TEST_F(FormatTest, UnderstandsRvalueReferences) { 7233 verifyFormat("int f(int &&a) {}"); 7234 verifyFormat("int f(int a, char &&b) {}"); 7235 verifyFormat("void f() { int &&a = b; }"); 7236 verifyGoogleFormat("int f(int a, char&& b) {}"); 7237 verifyGoogleFormat("void f() { int&& a = b; }"); 7238 7239 verifyIndependentOfContext("A<int &&> a;"); 7240 verifyIndependentOfContext("A<int &&, int &&> a;"); 7241 verifyGoogleFormat("A<int&&> a;"); 7242 verifyGoogleFormat("A<int&&, int&&> a;"); 7243 7244 // Not rvalue references: 7245 verifyFormat("template <bool B, bool C> class A {\n" 7246 " static_assert(B && C, \"Something is wrong\");\n" 7247 "};"); 7248 verifyGoogleFormat("#define IF(a, b, c) if (a && (b == c))"); 7249 verifyGoogleFormat("#define WHILE(a, b, c) while (a && (b == c))"); 7250 verifyFormat("#define A(a, b) (a && b)"); 7251 } 7252 7253 TEST_F(FormatTest, FormatsBinaryOperatorsPrecedingEquals) { 7254 verifyFormat("void f() {\n" 7255 " x[aaaaaaaaa -\n" 7256 " b] = 23;\n" 7257 "}", 7258 getLLVMStyleWithColumns(15)); 7259 } 7260 7261 TEST_F(FormatTest, FormatsCasts) { 7262 verifyFormat("Type *A = static_cast<Type *>(P);"); 7263 verifyFormat("Type *A = (Type *)P;"); 7264 verifyFormat("Type *A = (vector<Type *, int *>)P;"); 7265 verifyFormat("int a = (int)(2.0f);"); 7266 verifyFormat("int a = (int)2.0f;"); 7267 verifyFormat("x[(int32)y];"); 7268 verifyFormat("x = (int32)y;"); 7269 verifyFormat("#define AA(X) sizeof(((X *)NULL)->a)"); 7270 verifyFormat("int a = (int)*b;"); 7271 verifyFormat("int a = (int)2.0f;"); 7272 verifyFormat("int a = (int)~0;"); 7273 verifyFormat("int a = (int)++a;"); 7274 verifyFormat("int a = (int)sizeof(int);"); 7275 verifyFormat("int a = (int)+2;"); 7276 verifyFormat("my_int a = (my_int)2.0f;"); 7277 verifyFormat("my_int a = (my_int)sizeof(int);"); 7278 verifyFormat("return (my_int)aaa;"); 7279 verifyFormat("#define x ((int)-1)"); 7280 verifyFormat("#define LENGTH(x, y) (x) - (y) + 1"); 7281 verifyFormat("#define p(q) ((int *)&q)"); 7282 verifyFormat("fn(a)(b) + 1;"); 7283 7284 verifyFormat("void f() { my_int a = (my_int)*b; }"); 7285 verifyFormat("void f() { return P ? (my_int)*P : (my_int)0; }"); 7286 verifyFormat("my_int a = (my_int)~0;"); 7287 verifyFormat("my_int a = (my_int)++a;"); 7288 verifyFormat("my_int a = (my_int)-2;"); 7289 verifyFormat("my_int a = (my_int)1;"); 7290 verifyFormat("my_int a = (my_int *)1;"); 7291 verifyFormat("my_int a = (const my_int)-1;"); 7292 verifyFormat("my_int a = (const my_int *)-1;"); 7293 verifyFormat("my_int a = (my_int)(my_int)-1;"); 7294 verifyFormat("my_int a = (ns::my_int)-2;"); 7295 verifyFormat("case (my_int)ONE:"); 7296 verifyFormat("auto x = (X)this;"); 7297 7298 // FIXME: single value wrapped with paren will be treated as cast. 7299 verifyFormat("void f(int i = (kValue)*kMask) {}"); 7300 7301 verifyFormat("{ (void)F; }"); 7302 7303 // Don't break after a cast's 7304 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 7305 " (aaaaaaaaaaaaaaaaaaaaaaaaaa *)(aaaaaaaaaaaaaaaaaaaaaa +\n" 7306 " bbbbbbbbbbbbbbbbbbbbbb);"); 7307 7308 // These are not casts. 7309 verifyFormat("void f(int *) {}"); 7310 verifyFormat("f(foo)->b;"); 7311 verifyFormat("f(foo).b;"); 7312 verifyFormat("f(foo)(b);"); 7313 verifyFormat("f(foo)[b];"); 7314 verifyFormat("[](foo) { return 4; }(bar);"); 7315 verifyFormat("(*funptr)(foo)[4];"); 7316 verifyFormat("funptrs[4](foo)[4];"); 7317 verifyFormat("void f(int *);"); 7318 verifyFormat("void f(int *) = 0;"); 7319 verifyFormat("void f(SmallVector<int>) {}"); 7320 verifyFormat("void f(SmallVector<int>);"); 7321 verifyFormat("void f(SmallVector<int>) = 0;"); 7322 verifyFormat("void f(int i = (kA * kB) & kMask) {}"); 7323 verifyFormat("int a = sizeof(int) * b;"); 7324 verifyFormat("int a = alignof(int) * b;", getGoogleStyle()); 7325 verifyFormat("template <> void f<int>(int i) SOME_ANNOTATION;"); 7326 verifyFormat("f(\"%\" SOME_MACRO(ll) \"d\");"); 7327 verifyFormat("aaaaa &operator=(const aaaaa &) LLVM_DELETED_FUNCTION;"); 7328 7329 // These are not casts, but at some point were confused with casts. 7330 verifyFormat("virtual void foo(int *) override;"); 7331 verifyFormat("virtual void foo(char &) const;"); 7332 verifyFormat("virtual void foo(int *a, char *) const;"); 7333 verifyFormat("int a = sizeof(int *) + b;"); 7334 verifyFormat("int a = alignof(int *) + b;", getGoogleStyle()); 7335 verifyFormat("bool b = f(g<int>) && c;"); 7336 verifyFormat("typedef void (*f)(int i) func;"); 7337 7338 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *foo = (aaaaaaaaaaaaaaaaa *)\n" 7339 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 7340 // FIXME: The indentation here is not ideal. 7341 verifyFormat( 7342 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7343 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = (*cccccccccccccccc)\n" 7344 " [dddddddddddddddddddddddddddddddddddddddddddddddddddddddd];"); 7345 } 7346 7347 TEST_F(FormatTest, FormatsFunctionTypes) { 7348 verifyFormat("A<bool()> a;"); 7349 verifyFormat("A<SomeType()> a;"); 7350 verifyFormat("A<void (*)(int, std::string)> a;"); 7351 verifyFormat("A<void *(int)>;"); 7352 verifyFormat("void *(*a)(int *, SomeType *);"); 7353 verifyFormat("int (*func)(void *);"); 7354 verifyFormat("void f() { int (*func)(void *); }"); 7355 verifyFormat("template <class CallbackClass>\n" 7356 "using MyCallback = void (CallbackClass::*)(SomeObject *Data);"); 7357 7358 verifyGoogleFormat("A<void*(int*, SomeType*)>;"); 7359 verifyGoogleFormat("void* (*a)(int);"); 7360 verifyGoogleFormat( 7361 "template <class CallbackClass>\n" 7362 "using MyCallback = void (CallbackClass::*)(SomeObject* Data);"); 7363 7364 // Other constructs can look somewhat like function types: 7365 verifyFormat("A<sizeof(*x)> a;"); 7366 verifyFormat("#define DEREF_AND_CALL_F(x) f(*x)"); 7367 verifyFormat("some_var = function(*some_pointer_var)[0];"); 7368 verifyFormat("void f() { function(*some_pointer_var)[0] = 10; }"); 7369 verifyFormat("int x = f(&h)();"); 7370 verifyFormat("returnsFunction(¶m1, ¶m2)(param);"); 7371 verifyFormat("std::function<\n" 7372 " LooooooooooongTemplatedType<\n" 7373 " SomeType>*(\n" 7374 " LooooooooooooooooongType type)>\n" 7375 " function;", 7376 getGoogleStyleWithColumns(40)); 7377 } 7378 7379 TEST_F(FormatTest, FormatsPointersToArrayTypes) { 7380 verifyFormat("A (*foo_)[6];"); 7381 verifyFormat("vector<int> (*foo_)[6];"); 7382 } 7383 7384 TEST_F(FormatTest, BreaksLongVariableDeclarations) { 7385 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7386 " LoooooooooooooooooooooooooooooooooooooooongVariable;"); 7387 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType const\n" 7388 " LoooooooooooooooooooooooooooooooooooooooongVariable;"); 7389 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7390 " *LoooooooooooooooooooooooooooooooooooooooongVariable;"); 7391 7392 // Different ways of ()-initializiation. 7393 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7394 " LoooooooooooooooooooooooooooooooooooooooongVariable(1);"); 7395 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7396 " LoooooooooooooooooooooooooooooooooooooooongVariable(a);"); 7397 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7398 " LoooooooooooooooooooooooooooooooooooooooongVariable({});"); 7399 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7400 " LoooooooooooooooooooooooooooooooooooooongVariable([A a]);"); 7401 7402 // Lambdas should not confuse the variable declaration heuristic. 7403 verifyFormat("LooooooooooooooooongType\n" 7404 " variable(nullptr, [](A *a) {});", 7405 getLLVMStyleWithColumns(40)); 7406 } 7407 7408 TEST_F(FormatTest, BreaksLongDeclarations) { 7409 verifyFormat("typedef LoooooooooooooooooooooooooooooooooooooooongType\n" 7410 " AnotherNameForTheLongType;"); 7411 verifyFormat("typedef LongTemplateType<aaaaaaaaaaaaaaaaaaa()>\n" 7412 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 7413 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7414 "LoooooooooooooooooooooooooooooooongFunctionDeclaration();"); 7415 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType *\n" 7416 "LoooooooooooooooooooooooooooooooongFunctionDeclaration();"); 7417 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7418 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7419 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType MACRO\n" 7420 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7421 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType const\n" 7422 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7423 verifyFormat("decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n" 7424 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7425 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7426 "LooooooooooooooooooooooooooongFunctionDeclaration(T... t);"); 7427 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7428 "LooooooooooooooooooooooooooongFunctionDeclaration(T /*t*/) {}"); 7429 FormatStyle Indented = getLLVMStyle(); 7430 Indented.IndentWrappedFunctionNames = true; 7431 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7432 " LoooooooooooooooooooooooooooooooongFunctionDeclaration();", 7433 Indented); 7434 verifyFormat( 7435 "LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7436 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}", 7437 Indented); 7438 verifyFormat( 7439 "LoooooooooooooooooooooooooooooooooooooooongReturnType const\n" 7440 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}", 7441 Indented); 7442 verifyFormat( 7443 "decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n" 7444 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}", 7445 Indented); 7446 7447 // FIXME: Without the comment, this breaks after "(". 7448 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType // break\n" 7449 " (*LoooooooooooooooooooooooooooongFunctionTypeVarialbe)();", 7450 getGoogleStyle()); 7451 7452 verifyFormat("int *someFunction(int LoooooooooooooooooooongParam1,\n" 7453 " int LoooooooooooooooooooongParam2) {}"); 7454 verifyFormat( 7455 "TypeSpecDecl *TypeSpecDecl::Create(ASTContext &C, DeclContext *DC,\n" 7456 " SourceLocation L, IdentifierIn *II,\n" 7457 " Type *T) {}"); 7458 verifyFormat("ReallyLongReturnType<TemplateParam1, TemplateParam2>\n" 7459 "ReallyReaaallyLongFunctionName(\n" 7460 " const std::string &SomeParameter,\n" 7461 " const SomeType<string, SomeOtherTemplateParameter>\n" 7462 " &ReallyReallyLongParameterName,\n" 7463 " const SomeType<string, SomeOtherTemplateParameter>\n" 7464 " &AnotherLongParameterName) {}"); 7465 verifyFormat("template <typename A>\n" 7466 "SomeLoooooooooooooooooooooongType<\n" 7467 " typename some_namespace::SomeOtherType<A>::Type>\n" 7468 "Function() {}"); 7469 7470 verifyGoogleFormat( 7471 "aaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaa<aaaaaaaaaaaaa, aaaaaaaaaaaa>\n" 7472 " aaaaaaaaaaaaaaaaaaaaaaa;"); 7473 verifyGoogleFormat( 7474 "TypeSpecDecl* TypeSpecDecl::Create(ASTContext& C, DeclContext* DC,\n" 7475 " SourceLocation L) {}"); 7476 verifyGoogleFormat( 7477 "some_namespace::LongReturnType\n" 7478 "long_namespace::SomeVeryLongClass::SomeVeryLongFunction(\n" 7479 " int first_long_parameter, int second_parameter) {}"); 7480 7481 verifyGoogleFormat("template <typename T>\n" 7482 "aaaaaaaa::aaaaa::aaaaaa<T, aaaaaaaaaaaaaaaaaaaaaaaaa>\n" 7483 "aaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaa() {}"); 7484 verifyGoogleFormat("A<A<A>> aaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 7485 " int aaaaaaaaaaaaaaaaaaaaaaa);"); 7486 7487 verifyFormat("typedef size_t (*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n" 7488 " const aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7489 " *aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 7490 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7491 " vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n" 7492 " aaaaaaaaaaaaaaaaaaaaaaaa);"); 7493 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7494 " vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n" 7495 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>>\n" 7496 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 7497 7498 verifyFormat("template <typename T> // Templates on own line.\n" 7499 "static int // Some comment.\n" 7500 "MyFunction(int a);", 7501 getLLVMStyle()); 7502 } 7503 7504 TEST_F(FormatTest, FormatsArrays) { 7505 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaaaaaaaaaa]\n" 7506 " [bbbbbbbbbbbbbbbbbbbbbbbbb] = c;"); 7507 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaa(aaaaaaaaaaaa)]\n" 7508 " [bbbbbbbbbbb(bbbbbbbbbbbb)] = c;"); 7509 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaa &&\n" 7510 " aaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaa][aaaaaaaaaaaaa]) {\n}"); 7511 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7512 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;"); 7513 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7514 " [a][bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = cccccccc;"); 7515 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7516 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n" 7517 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;"); 7518 verifyFormat( 7519 "llvm::outs() << \"aaaaaaaaaaaa: \"\n" 7520 " << (*aaaaaaaiaaaaaaa)[aaaaaaaaaaaaaaaaaaaaaaaaa]\n" 7521 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa];"); 7522 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaa][a]\n" 7523 " .aaaaaaaaaaaaaaaaaaaaaa();"); 7524 7525 verifyGoogleFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<int>\n" 7526 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaa];"); 7527 verifyFormat( 7528 "aaaaaaaaaaa aaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaa->aaaaaaaaa[0]\n" 7529 " .aaaaaaa[0]\n" 7530 " .aaaaaaaaaaaaaaaaaaaaaa();"); 7531 verifyFormat("a[::b::c];"); 7532 7533 verifyNoCrash("a[,Y?)]", getLLVMStyleWithColumns(10)); 7534 7535 FormatStyle NoColumnLimit = getLLVMStyleWithColumns(0); 7536 verifyFormat("aaaaa[bbbbbb].cccccc()", NoColumnLimit); 7537 } 7538 7539 TEST_F(FormatTest, LineStartsWithSpecialCharacter) { 7540 verifyFormat("(a)->b();"); 7541 verifyFormat("--a;"); 7542 } 7543 7544 TEST_F(FormatTest, HandlesIncludeDirectives) { 7545 verifyFormat("#include <string>\n" 7546 "#include <a/b/c.h>\n" 7547 "#include \"a/b/string\"\n" 7548 "#include \"string.h\"\n" 7549 "#include \"string.h\"\n" 7550 "#include <a-a>\n" 7551 "#include < path with space >\n" 7552 "#include_next <test.h>" 7553 "#include \"abc.h\" // this is included for ABC\n" 7554 "#include \"some long include\" // with a comment\n" 7555 "#include \"some very long include path\"\n" 7556 "#include <some/very/long/include/path>\n", 7557 getLLVMStyleWithColumns(35)); 7558 EXPECT_EQ("#include \"a.h\"", format("#include \"a.h\"")); 7559 EXPECT_EQ("#include <a>", format("#include<a>")); 7560 7561 verifyFormat("#import <string>"); 7562 verifyFormat("#import <a/b/c.h>"); 7563 verifyFormat("#import \"a/b/string\""); 7564 verifyFormat("#import \"string.h\""); 7565 verifyFormat("#import \"string.h\""); 7566 verifyFormat("#if __has_include(<strstream>)\n" 7567 "#include <strstream>\n" 7568 "#endif"); 7569 7570 verifyFormat("#define MY_IMPORT <a/b>"); 7571 7572 verifyFormat("#if __has_include(<a/b>)"); 7573 verifyFormat("#if __has_include_next(<a/b>)"); 7574 verifyFormat("#define F __has_include(<a/b>)"); 7575 verifyFormat("#define F __has_include_next(<a/b>)"); 7576 7577 // Protocol buffer definition or missing "#". 7578 verifyFormat("import \"aaaaaaaaaaaaaaaaa/aaaaaaaaaaaaaaa\";", 7579 getLLVMStyleWithColumns(30)); 7580 7581 FormatStyle Style = getLLVMStyle(); 7582 Style.AlwaysBreakBeforeMultilineStrings = true; 7583 Style.ColumnLimit = 0; 7584 verifyFormat("#import \"abc.h\"", Style); 7585 7586 // But 'import' might also be a regular C++ namespace. 7587 verifyFormat("import::SomeFunction(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 7588 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 7589 } 7590 7591 //===----------------------------------------------------------------------===// 7592 // Error recovery tests. 7593 //===----------------------------------------------------------------------===// 7594 7595 TEST_F(FormatTest, IncompleteParameterLists) { 7596 FormatStyle NoBinPacking = getLLVMStyle(); 7597 NoBinPacking.BinPackParameters = false; 7598 verifyFormat("void aaaaaaaaaaaaaaaaaa(int level,\n" 7599 " double *min_x,\n" 7600 " double *max_x,\n" 7601 " double *min_y,\n" 7602 " double *max_y,\n" 7603 " double *min_z,\n" 7604 " double *max_z, ) {}", 7605 NoBinPacking); 7606 } 7607 7608 TEST_F(FormatTest, IncorrectCodeTrailingStuff) { 7609 verifyFormat("void f() { return; }\n42"); 7610 verifyFormat("void f() {\n" 7611 " if (0)\n" 7612 " return;\n" 7613 "}\n" 7614 "42"); 7615 verifyFormat("void f() { return }\n42"); 7616 verifyFormat("void f() {\n" 7617 " if (0)\n" 7618 " return\n" 7619 "}\n" 7620 "42"); 7621 } 7622 7623 TEST_F(FormatTest, IncorrectCodeMissingSemicolon) { 7624 EXPECT_EQ("void f() { return }", format("void f ( ) { return }")); 7625 EXPECT_EQ("void f() {\n" 7626 " if (a)\n" 7627 " return\n" 7628 "}", 7629 format("void f ( ) { if ( a ) return }")); 7630 EXPECT_EQ("namespace N {\n" 7631 "void f()\n" 7632 "}", 7633 format("namespace N { void f() }")); 7634 EXPECT_EQ("namespace N {\n" 7635 "void f() {}\n" 7636 "void g()\n" 7637 "} // namespace N", 7638 format("namespace N { void f( ) { } void g( ) }")); 7639 } 7640 7641 TEST_F(FormatTest, IndentationWithinColumnLimitNotPossible) { 7642 verifyFormat("int aaaaaaaa =\n" 7643 " // Overlylongcomment\n" 7644 " b;", 7645 getLLVMStyleWithColumns(20)); 7646 verifyFormat("function(\n" 7647 " ShortArgument,\n" 7648 " LoooooooooooongArgument);\n", 7649 getLLVMStyleWithColumns(20)); 7650 } 7651 7652 TEST_F(FormatTest, IncorrectAccessSpecifier) { 7653 verifyFormat("public:"); 7654 verifyFormat("class A {\n" 7655 "public\n" 7656 " void f() {}\n" 7657 "};"); 7658 verifyFormat("public\n" 7659 "int qwerty;"); 7660 verifyFormat("public\n" 7661 "B {}"); 7662 verifyFormat("public\n" 7663 "{}"); 7664 verifyFormat("public\n" 7665 "B { int x; }"); 7666 } 7667 7668 TEST_F(FormatTest, IncorrectCodeUnbalancedBraces) { 7669 verifyFormat("{"); 7670 verifyFormat("#})"); 7671 verifyNoCrash("(/**/[:!] ?[)."); 7672 } 7673 7674 TEST_F(FormatTest, IncorrectUnbalancedBracesInMacrosWithUnicode) { 7675 // Found by oss-fuzz: 7676 // https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=8212 7677 FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp); 7678 Style.ColumnLimit = 60; 7679 verifyNoCrash( 7680 "\x23\x47\xff\x20\x28\xff\x3c\xff\x3f\xff\x20\x2f\x7b\x7a\xff\x20" 7681 "\xff\xff\xff\xca\xb5\xff\xff\xff\xff\x3a\x7b\x7d\xff\x20\xff\x20" 7682 "\xff\x74\xff\x20\x7d\x7d\xff\x7b\x3a\xff\x20\x71\xff\x20\xff\x0a", 7683 Style); 7684 } 7685 7686 TEST_F(FormatTest, IncorrectCodeDoNoWhile) { 7687 verifyFormat("do {\n}"); 7688 verifyFormat("do {\n}\n" 7689 "f();"); 7690 verifyFormat("do {\n}\n" 7691 "wheeee(fun);"); 7692 verifyFormat("do {\n" 7693 " f();\n" 7694 "}"); 7695 } 7696 7697 TEST_F(FormatTest, IncorrectCodeMissingParens) { 7698 verifyFormat("if {\n foo;\n foo();\n}"); 7699 verifyFormat("switch {\n foo;\n foo();\n}"); 7700 verifyIncompleteFormat("for {\n foo;\n foo();\n}"); 7701 verifyFormat("while {\n foo;\n foo();\n}"); 7702 verifyFormat("do {\n foo;\n foo();\n} while;"); 7703 } 7704 7705 TEST_F(FormatTest, DoesNotTouchUnwrappedLinesWithErrors) { 7706 verifyIncompleteFormat("namespace {\n" 7707 "class Foo { Foo (\n" 7708 "};\n" 7709 "} // namespace"); 7710 } 7711 7712 TEST_F(FormatTest, IncorrectCodeErrorDetection) { 7713 EXPECT_EQ("{\n {}\n", format("{\n{\n}\n")); 7714 EXPECT_EQ("{\n {}\n", format("{\n {\n}\n")); 7715 EXPECT_EQ("{\n {}\n", format("{\n {\n }\n")); 7716 EXPECT_EQ("{\n {}\n}\n}\n", format("{\n {\n }\n }\n}\n")); 7717 7718 EXPECT_EQ("{\n" 7719 " {\n" 7720 " breakme(\n" 7721 " qwe);\n" 7722 " }\n", 7723 format("{\n" 7724 " {\n" 7725 " breakme(qwe);\n" 7726 "}\n", 7727 getLLVMStyleWithColumns(10))); 7728 } 7729 7730 TEST_F(FormatTest, LayoutCallsInsideBraceInitializers) { 7731 verifyFormat("int x = {\n" 7732 " avariable,\n" 7733 " b(alongervariable)};", 7734 getLLVMStyleWithColumns(25)); 7735 } 7736 7737 TEST_F(FormatTest, LayoutBraceInitializersInReturnStatement) { 7738 verifyFormat("return (a)(b){1, 2, 3};"); 7739 } 7740 7741 TEST_F(FormatTest, LayoutCxx11BraceInitializers) { 7742 verifyFormat("vector<int> x{1, 2, 3, 4};"); 7743 verifyFormat("vector<int> x{\n" 7744 " 1,\n" 7745 " 2,\n" 7746 " 3,\n" 7747 " 4,\n" 7748 "};"); 7749 verifyFormat("vector<T> x{{}, {}, {}, {}};"); 7750 verifyFormat("f({1, 2});"); 7751 verifyFormat("auto v = Foo{-1};"); 7752 verifyFormat("f({1, 2}, {{2, 3}, {4, 5}}, c, {d});"); 7753 verifyFormat("Class::Class : member{1, 2, 3} {}"); 7754 verifyFormat("new vector<int>{1, 2, 3};"); 7755 verifyFormat("new int[3]{1, 2, 3};"); 7756 verifyFormat("new int{1};"); 7757 verifyFormat("return {arg1, arg2};"); 7758 verifyFormat("return {arg1, SomeType{parameter}};"); 7759 verifyFormat("int count = set<int>{f(), g(), h()}.size();"); 7760 verifyFormat("new T{arg1, arg2};"); 7761 verifyFormat("f(MyMap[{composite, key}]);"); 7762 verifyFormat("class Class {\n" 7763 " T member = {arg1, arg2};\n" 7764 "};"); 7765 verifyFormat("vector<int> foo = {::SomeGlobalFunction()};"); 7766 verifyFormat("const struct A a = {.a = 1, .b = 2};"); 7767 verifyFormat("const struct A a = {[0] = 1, [1] = 2};"); 7768 verifyFormat("static_assert(std::is_integral<int>{} + 0, \"\");"); 7769 verifyFormat("int a = std::is_integral<int>{} + 0;"); 7770 7771 verifyFormat("int foo(int i) { return fo1{}(i); }"); 7772 verifyFormat("int foo(int i) { return fo1{}(i); }"); 7773 verifyFormat("auto i = decltype(x){};"); 7774 verifyFormat("std::vector<int> v = {1, 0 /* comment */};"); 7775 verifyFormat("Node n{1, Node{1000}, //\n" 7776 " 2};"); 7777 verifyFormat("Aaaa aaaaaaa{\n" 7778 " {\n" 7779 " aaaa,\n" 7780 " },\n" 7781 "};"); 7782 verifyFormat("class C : public D {\n" 7783 " SomeClass SC{2};\n" 7784 "};"); 7785 verifyFormat("class C : public A {\n" 7786 " class D : public B {\n" 7787 " void f() { int i{2}; }\n" 7788 " };\n" 7789 "};"); 7790 verifyFormat("#define A {a, a},"); 7791 7792 // Avoid breaking between equal sign and opening brace 7793 FormatStyle AvoidBreakingFirstArgument = getLLVMStyle(); 7794 AvoidBreakingFirstArgument.PenaltyBreakBeforeFirstCallParameter = 200; 7795 verifyFormat("const std::unordered_map<std::string, int> MyHashTable =\n" 7796 " {{\"aaaaaaaaaaaaaaaaaaaaa\", 0},\n" 7797 " {\"bbbbbbbbbbbbbbbbbbbbb\", 1},\n" 7798 " {\"ccccccccccccccccccccc\", 2}};", 7799 AvoidBreakingFirstArgument); 7800 7801 // Binpacking only if there is no trailing comma 7802 verifyFormat("const Aaaaaa aaaaa = {aaaaaaaaaa, bbbbbbbbbb,\n" 7803 " cccccccccc, dddddddddd};", 7804 getLLVMStyleWithColumns(50)); 7805 verifyFormat("const Aaaaaa aaaaa = {\n" 7806 " aaaaaaaaaaa,\n" 7807 " bbbbbbbbbbb,\n" 7808 " ccccccccccc,\n" 7809 " ddddddddddd,\n" 7810 "};", getLLVMStyleWithColumns(50)); 7811 7812 // Cases where distinguising braced lists and blocks is hard. 7813 verifyFormat("vector<int> v{12} GUARDED_BY(mutex);"); 7814 verifyFormat("void f() {\n" 7815 " return; // comment\n" 7816 "}\n" 7817 "SomeType t;"); 7818 verifyFormat("void f() {\n" 7819 " if (a) {\n" 7820 " f();\n" 7821 " }\n" 7822 "}\n" 7823 "SomeType t;"); 7824 7825 // In combination with BinPackArguments = false. 7826 FormatStyle NoBinPacking = getLLVMStyle(); 7827 NoBinPacking.BinPackArguments = false; 7828 verifyFormat("const Aaaaaa aaaaa = {aaaaa,\n" 7829 " bbbbb,\n" 7830 " ccccc,\n" 7831 " ddddd,\n" 7832 " eeeee,\n" 7833 " ffffff,\n" 7834 " ggggg,\n" 7835 " hhhhhh,\n" 7836 " iiiiii,\n" 7837 " jjjjjj,\n" 7838 " kkkkkk};", 7839 NoBinPacking); 7840 verifyFormat("const Aaaaaa aaaaa = {\n" 7841 " aaaaa,\n" 7842 " bbbbb,\n" 7843 " ccccc,\n" 7844 " ddddd,\n" 7845 " eeeee,\n" 7846 " ffffff,\n" 7847 " ggggg,\n" 7848 " hhhhhh,\n" 7849 " iiiiii,\n" 7850 " jjjjjj,\n" 7851 " kkkkkk,\n" 7852 "};", 7853 NoBinPacking); 7854 verifyFormat( 7855 "const Aaaaaa aaaaa = {\n" 7856 " aaaaa, bbbbb, ccccc, ddddd, eeeee, ffffff, ggggg, hhhhhh,\n" 7857 " iiiiii, jjjjjj, kkkkkk, aaaaa, bbbbb, ccccc, ddddd, eeeee,\n" 7858 " ffffff, ggggg, hhhhhh, iiiiii, jjjjjj, kkkkkk,\n" 7859 "};", 7860 NoBinPacking); 7861 7862 NoBinPacking.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 7863 EXPECT_EQ("static uint8 CddDp83848Reg[] = {\n" 7864 " CDDDP83848_BMCR_REGISTER,\n" 7865 " CDDDP83848_BMSR_REGISTER,\n" 7866 " CDDDP83848_RBR_REGISTER};", 7867 format("static uint8 CddDp83848Reg[] = {CDDDP83848_BMCR_REGISTER,\n" 7868 " CDDDP83848_BMSR_REGISTER,\n" 7869 " CDDDP83848_RBR_REGISTER};", 7870 NoBinPacking)); 7871 7872 // FIXME: The alignment of these trailing comments might be bad. Then again, 7873 // this might be utterly useless in real code. 7874 verifyFormat("Constructor::Constructor()\n" 7875 " : some_value{ //\n" 7876 " aaaaaaa, //\n" 7877 " bbbbbbb} {}"); 7878 7879 // In braced lists, the first comment is always assumed to belong to the 7880 // first element. Thus, it can be moved to the next or previous line as 7881 // appropriate. 7882 EXPECT_EQ("function({// First element:\n" 7883 " 1,\n" 7884 " // Second element:\n" 7885 " 2});", 7886 format("function({\n" 7887 " // First element:\n" 7888 " 1,\n" 7889 " // Second element:\n" 7890 " 2});")); 7891 EXPECT_EQ("std::vector<int> MyNumbers{\n" 7892 " // First element:\n" 7893 " 1,\n" 7894 " // Second element:\n" 7895 " 2};", 7896 format("std::vector<int> MyNumbers{// First element:\n" 7897 " 1,\n" 7898 " // Second element:\n" 7899 " 2};", 7900 getLLVMStyleWithColumns(30))); 7901 // A trailing comma should still lead to an enforced line break and no 7902 // binpacking. 7903 EXPECT_EQ("vector<int> SomeVector = {\n" 7904 " // aaa\n" 7905 " 1,\n" 7906 " 2,\n" 7907 "};", 7908 format("vector<int> SomeVector = { // aaa\n" 7909 " 1, 2, };")); 7910 7911 FormatStyle ExtraSpaces = getLLVMStyle(); 7912 ExtraSpaces.Cpp11BracedListStyle = false; 7913 ExtraSpaces.ColumnLimit = 75; 7914 verifyFormat("vector<int> x{ 1, 2, 3, 4 };", ExtraSpaces); 7915 verifyFormat("vector<T> x{ {}, {}, {}, {} };", ExtraSpaces); 7916 verifyFormat("f({ 1, 2 });", ExtraSpaces); 7917 verifyFormat("auto v = Foo{ 1 };", ExtraSpaces); 7918 verifyFormat("f({ 1, 2 }, { { 2, 3 }, { 4, 5 } }, c, { d });", ExtraSpaces); 7919 verifyFormat("Class::Class : member{ 1, 2, 3 } {}", ExtraSpaces); 7920 verifyFormat("new vector<int>{ 1, 2, 3 };", ExtraSpaces); 7921 verifyFormat("new int[3]{ 1, 2, 3 };", ExtraSpaces); 7922 verifyFormat("return { arg1, arg2 };", ExtraSpaces); 7923 verifyFormat("return { arg1, SomeType{ parameter } };", ExtraSpaces); 7924 verifyFormat("int count = set<int>{ f(), g(), h() }.size();", ExtraSpaces); 7925 verifyFormat("new T{ arg1, arg2 };", ExtraSpaces); 7926 verifyFormat("f(MyMap[{ composite, key }]);", ExtraSpaces); 7927 verifyFormat("class Class {\n" 7928 " T member = { arg1, arg2 };\n" 7929 "};", 7930 ExtraSpaces); 7931 verifyFormat( 7932 "foo = aaaaaaaaaaa ? vector<int>{ aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 7933 " aaaaaaaaaaaaaaaaaaaa, aaaaa }\n" 7934 " : vector<int>{ bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" 7935 " bbbbbbbbbbbbbbbbbbbb, bbbbb };", 7936 ExtraSpaces); 7937 verifyFormat("DoSomethingWithVector({} /* No data */);", ExtraSpaces); 7938 verifyFormat("DoSomethingWithVector({ {} /* No data */ }, { { 1, 2 } });", 7939 ExtraSpaces); 7940 verifyFormat( 7941 "someFunction(OtherParam,\n" 7942 " BracedList{ // comment 1 (Forcing interesting break)\n" 7943 " param1, param2,\n" 7944 " // comment 2\n" 7945 " param3, param4 });", 7946 ExtraSpaces); 7947 verifyFormat( 7948 "std::this_thread::sleep_for(\n" 7949 " std::chrono::nanoseconds{ std::chrono::seconds{ 1 } } / 5);", 7950 ExtraSpaces); 7951 verifyFormat("std::vector<MyValues> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa{\n" 7952 " aaaaaaa,\n" 7953 " aaaaaaaaaa,\n" 7954 " aaaaa,\n" 7955 " aaaaaaaaaaaaaaa,\n" 7956 " aaa,\n" 7957 " aaaaaaaaaa,\n" 7958 " a,\n" 7959 " aaaaaaaaaaaaaaaaaaaaa,\n" 7960 " aaaaaaaaaaaa,\n" 7961 " aaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaa,\n" 7962 " aaaaaaa,\n" 7963 " a};"); 7964 verifyFormat("vector<int> foo = { ::SomeGlobalFunction() };", ExtraSpaces); 7965 verifyFormat("const struct A a = { .a = 1, .b = 2 };", ExtraSpaces); 7966 verifyFormat("const struct A a = { [0] = 1, [1] = 2 };", ExtraSpaces); 7967 7968 // Avoid breaking between initializer/equal sign and opening brace 7969 ExtraSpaces.PenaltyBreakBeforeFirstCallParameter = 200; 7970 verifyFormat("const std::unordered_map<std::string, int> MyHashTable = {\n" 7971 " { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n" 7972 " { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n" 7973 " { \"ccccccccccccccccccccc\", 2 }\n" 7974 "};", 7975 ExtraSpaces); 7976 verifyFormat("const std::unordered_map<std::string, int> MyHashTable{\n" 7977 " { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n" 7978 " { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n" 7979 " { \"ccccccccccccccccccccc\", 2 }\n" 7980 "};", 7981 ExtraSpaces); 7982 7983 FormatStyle SpaceBeforeBrace = getLLVMStyle(); 7984 SpaceBeforeBrace.SpaceBeforeCpp11BracedList = true; 7985 verifyFormat("vector<int> x {1, 2, 3, 4};", SpaceBeforeBrace); 7986 verifyFormat("f({}, {{}, {}}, MyMap[{k, v}]);", SpaceBeforeBrace); 7987 } 7988 7989 TEST_F(FormatTest, FormatsBracedListsInColumnLayout) { 7990 verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n" 7991 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 7992 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 7993 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 7994 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 7995 " 1, 22, 333, 4444, 55555, 666666, 7777777};"); 7996 verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777, //\n" 7997 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 7998 " 1, 22, 333, 4444, 55555, //\n" 7999 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8000 " 1, 22, 333, 4444, 55555, 666666, 7777777};"); 8001 verifyFormat( 8002 "vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8003 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8004 " 1, 22, 333, 4444, 55555, 666666, // comment\n" 8005 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 8006 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 8007 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 8008 " 7777777};"); 8009 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n" 8010 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n" 8011 " X86::R8, X86::R9, X86::R10, X86::R11, 0};"); 8012 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n" 8013 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n" 8014 " // Separating comment.\n" 8015 " X86::R8, X86::R9, X86::R10, X86::R11, 0};"); 8016 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n" 8017 " // Leading comment\n" 8018 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n" 8019 " X86::R8, X86::R9, X86::R10, X86::R11, 0};"); 8020 verifyFormat("vector<int> x = {1, 1, 1, 1,\n" 8021 " 1, 1, 1, 1};", 8022 getLLVMStyleWithColumns(39)); 8023 verifyFormat("vector<int> x = {1, 1, 1, 1,\n" 8024 " 1, 1, 1, 1};", 8025 getLLVMStyleWithColumns(38)); 8026 verifyFormat("vector<int> aaaaaaaaaaaaaaaaaaaaaa = {\n" 8027 " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};", 8028 getLLVMStyleWithColumns(43)); 8029 verifyFormat( 8030 "static unsigned SomeValues[10][3] = {\n" 8031 " {1, 4, 0}, {4, 9, 0}, {4, 5, 9}, {8, 5, 4}, {1, 8, 4},\n" 8032 " {10, 1, 6}, {11, 0, 9}, {2, 11, 9}, {5, 2, 9}, {11, 2, 7}};"); 8033 verifyFormat("static auto fields = new vector<string>{\n" 8034 " \"aaaaaaaaaaaaa\",\n" 8035 " \"aaaaaaaaaaaaa\",\n" 8036 " \"aaaaaaaaaaaa\",\n" 8037 " \"aaaaaaaaaaaaaa\",\n" 8038 " \"aaaaaaaaaaaaaaaaaaaaaaaaa\",\n" 8039 " \"aaaaaaaaaaaa\",\n" 8040 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",\n" 8041 "};"); 8042 verifyFormat("vector<int> x = {1, 2, 3, 4, aaaaaaaaaaaaaaaaa, 6};"); 8043 verifyFormat("vector<int> x = {1, aaaaaaaaaaaaaaaaaaaaaa,\n" 8044 " 2, bbbbbbbbbbbbbbbbbbbbbb,\n" 8045 " 3, cccccccccccccccccccccc};", 8046 getLLVMStyleWithColumns(60)); 8047 8048 // Trailing commas. 8049 verifyFormat("vector<int> x = {\n" 8050 " 1, 1, 1, 1, 1, 1, 1, 1,\n" 8051 "};", 8052 getLLVMStyleWithColumns(39)); 8053 verifyFormat("vector<int> x = {\n" 8054 " 1, 1, 1, 1, 1, 1, 1, 1, //\n" 8055 "};", 8056 getLLVMStyleWithColumns(39)); 8057 verifyFormat("vector<int> x = {1, 1, 1, 1,\n" 8058 " 1, 1, 1, 1,\n" 8059 " /**/ /**/};", 8060 getLLVMStyleWithColumns(39)); 8061 8062 // Trailing comment in the first line. 8063 verifyFormat("vector<int> iiiiiiiiiiiiiii = { //\n" 8064 " 1111111111, 2222222222, 33333333333, 4444444444, //\n" 8065 " 111111111, 222222222, 3333333333, 444444444, //\n" 8066 " 11111111, 22222222, 333333333, 44444444};"); 8067 // Trailing comment in the last line. 8068 verifyFormat("int aaaaa[] = {\n" 8069 " 1, 2, 3, // comment\n" 8070 " 4, 5, 6 // comment\n" 8071 "};"); 8072 8073 // With nested lists, we should either format one item per line or all nested 8074 // lists one on line. 8075 // FIXME: For some nested lists, we can do better. 8076 verifyFormat("return {{aaaaaaaaaaaaaaaaaaaaa},\n" 8077 " {aaaaaaaaaaaaaaaaaaa},\n" 8078 " {aaaaaaaaaaaaaaaaaaaaa},\n" 8079 " {aaaaaaaaaaaaaaaaa}};", 8080 getLLVMStyleWithColumns(60)); 8081 verifyFormat( 8082 "SomeStruct my_struct_array = {\n" 8083 " {aaaaaa, aaaaaaaa, aaaaaaaaaa, aaaaaaaaa, aaaaaaaaa, aaaaaaaaaa,\n" 8084 " aaaaaaaaaaaaa, aaaaaaa, aaa},\n" 8085 " {aaa, aaa},\n" 8086 " {aaa, aaa},\n" 8087 " {aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaa},\n" 8088 " {aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaa,\n" 8089 " aaaaaaaaaaaa, a, aaaaaaaaaa, aaaaaaaaa, aaa}};"); 8090 8091 // No column layout should be used here. 8092 verifyFormat("aaaaaaaaaaaaaaa = {aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0, 0,\n" 8093 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb};"); 8094 8095 verifyNoCrash("a<,"); 8096 8097 // No braced initializer here. 8098 verifyFormat("void f() {\n" 8099 " struct Dummy {};\n" 8100 " f(v);\n" 8101 "}"); 8102 8103 // Long lists should be formatted in columns even if they are nested. 8104 verifyFormat( 8105 "vector<int> x = function({1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8106 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8107 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8108 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8109 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8110 " 1, 22, 333, 4444, 55555, 666666, 7777777});"); 8111 8112 // Allow "single-column" layout even if that violates the column limit. There 8113 // isn't going to be a better way. 8114 verifyFormat("std::vector<int> a = {\n" 8115 " aaaaaaaa,\n" 8116 " aaaaaaaa,\n" 8117 " aaaaaaaa,\n" 8118 " aaaaaaaa,\n" 8119 " aaaaaaaaaa,\n" 8120 " aaaaaaaa,\n" 8121 " aaaaaaaaaaaaaaaaaaaaaaaaaaa};", 8122 getLLVMStyleWithColumns(30)); 8123 verifyFormat("vector<int> aaaa = {\n" 8124 " aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 8125 " aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 8126 " aaaaaa.aaaaaaa,\n" 8127 " aaaaaa.aaaaaaa,\n" 8128 " aaaaaa.aaaaaaa,\n" 8129 " aaaaaa.aaaaaaa,\n" 8130 "};"); 8131 8132 // Don't create hanging lists. 8133 verifyFormat("someFunction(Param, {List1, List2,\n" 8134 " List3});", 8135 getLLVMStyleWithColumns(35)); 8136 verifyFormat("someFunction(Param, Param,\n" 8137 " {List1, List2,\n" 8138 " List3});", 8139 getLLVMStyleWithColumns(35)); 8140 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa, {},\n" 8141 " aaaaaaaaaaaaaaaaaaaaaaa);"); 8142 } 8143 8144 TEST_F(FormatTest, PullTrivialFunctionDefinitionsIntoSingleLine) { 8145 FormatStyle DoNotMerge = getLLVMStyle(); 8146 DoNotMerge.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 8147 8148 verifyFormat("void f() { return 42; }"); 8149 verifyFormat("void f() {\n" 8150 " return 42;\n" 8151 "}", 8152 DoNotMerge); 8153 verifyFormat("void f() {\n" 8154 " // Comment\n" 8155 "}"); 8156 verifyFormat("{\n" 8157 "#error {\n" 8158 " int a;\n" 8159 "}"); 8160 verifyFormat("{\n" 8161 " int a;\n" 8162 "#error {\n" 8163 "}"); 8164 verifyFormat("void f() {} // comment"); 8165 verifyFormat("void f() { int a; } // comment"); 8166 verifyFormat("void f() {\n" 8167 "} // comment", 8168 DoNotMerge); 8169 verifyFormat("void f() {\n" 8170 " int a;\n" 8171 "} // comment", 8172 DoNotMerge); 8173 verifyFormat("void f() {\n" 8174 "} // comment", 8175 getLLVMStyleWithColumns(15)); 8176 8177 verifyFormat("void f() { return 42; }", getLLVMStyleWithColumns(23)); 8178 verifyFormat("void f() {\n return 42;\n}", getLLVMStyleWithColumns(22)); 8179 8180 verifyFormat("void f() {}", getLLVMStyleWithColumns(11)); 8181 verifyFormat("void f() {\n}", getLLVMStyleWithColumns(10)); 8182 verifyFormat("class C {\n" 8183 " C()\n" 8184 " : iiiiiiii(nullptr),\n" 8185 " kkkkkkk(nullptr),\n" 8186 " mmmmmmm(nullptr),\n" 8187 " nnnnnnn(nullptr) {}\n" 8188 "};", 8189 getGoogleStyle()); 8190 8191 FormatStyle NoColumnLimit = getLLVMStyle(); 8192 NoColumnLimit.ColumnLimit = 0; 8193 EXPECT_EQ("A() : b(0) {}", format("A():b(0){}", NoColumnLimit)); 8194 EXPECT_EQ("class C {\n" 8195 " A() : b(0) {}\n" 8196 "};", 8197 format("class C{A():b(0){}};", NoColumnLimit)); 8198 EXPECT_EQ("A()\n" 8199 " : b(0) {\n" 8200 "}", 8201 format("A()\n:b(0)\n{\n}", NoColumnLimit)); 8202 8203 FormatStyle DoNotMergeNoColumnLimit = NoColumnLimit; 8204 DoNotMergeNoColumnLimit.AllowShortFunctionsOnASingleLine = 8205 FormatStyle::SFS_None; 8206 EXPECT_EQ("A()\n" 8207 " : b(0) {\n" 8208 "}", 8209 format("A():b(0){}", DoNotMergeNoColumnLimit)); 8210 EXPECT_EQ("A()\n" 8211 " : b(0) {\n" 8212 "}", 8213 format("A()\n:b(0)\n{\n}", DoNotMergeNoColumnLimit)); 8214 8215 verifyFormat("#define A \\\n" 8216 " void f() { \\\n" 8217 " int i; \\\n" 8218 " }", 8219 getLLVMStyleWithColumns(20)); 8220 verifyFormat("#define A \\\n" 8221 " void f() { int i; }", 8222 getLLVMStyleWithColumns(21)); 8223 verifyFormat("#define A \\\n" 8224 " void f() { \\\n" 8225 " int i; \\\n" 8226 " } \\\n" 8227 " int j;", 8228 getLLVMStyleWithColumns(22)); 8229 verifyFormat("#define A \\\n" 8230 " void f() { int i; } \\\n" 8231 " int j;", 8232 getLLVMStyleWithColumns(23)); 8233 } 8234 8235 TEST_F(FormatTest, PullEmptyFunctionDefinitionsIntoSingleLine) { 8236 FormatStyle MergeEmptyOnly = getLLVMStyle(); 8237 MergeEmptyOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty; 8238 verifyFormat("class C {\n" 8239 " int f() {}\n" 8240 "};", 8241 MergeEmptyOnly); 8242 verifyFormat("class C {\n" 8243 " int f() {\n" 8244 " return 42;\n" 8245 " }\n" 8246 "};", 8247 MergeEmptyOnly); 8248 verifyFormat("int f() {}", MergeEmptyOnly); 8249 verifyFormat("int f() {\n" 8250 " return 42;\n" 8251 "}", 8252 MergeEmptyOnly); 8253 8254 // Also verify behavior when BraceWrapping.AfterFunction = true 8255 MergeEmptyOnly.BreakBeforeBraces = FormatStyle::BS_Custom; 8256 MergeEmptyOnly.BraceWrapping.AfterFunction = true; 8257 verifyFormat("int f() {}", MergeEmptyOnly); 8258 verifyFormat("class C {\n" 8259 " int f() {}\n" 8260 "};", 8261 MergeEmptyOnly); 8262 } 8263 8264 TEST_F(FormatTest, PullInlineFunctionDefinitionsIntoSingleLine) { 8265 FormatStyle MergeInlineOnly = getLLVMStyle(); 8266 MergeInlineOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; 8267 verifyFormat("class C {\n" 8268 " int f() { return 42; }\n" 8269 "};", 8270 MergeInlineOnly); 8271 verifyFormat("int f() {\n" 8272 " return 42;\n" 8273 "}", 8274 MergeInlineOnly); 8275 8276 // SFS_Inline implies SFS_Empty 8277 verifyFormat("class C {\n" 8278 " int f() {}\n" 8279 "};", 8280 MergeInlineOnly); 8281 verifyFormat("int f() {}", MergeInlineOnly); 8282 8283 // Also verify behavior when BraceWrapping.AfterFunction = true 8284 MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom; 8285 MergeInlineOnly.BraceWrapping.AfterFunction = true; 8286 verifyFormat("class C {\n" 8287 " int f() { return 42; }\n" 8288 "};", 8289 MergeInlineOnly); 8290 verifyFormat("int f()\n" 8291 "{\n" 8292 " return 42;\n" 8293 "}", 8294 MergeInlineOnly); 8295 8296 // SFS_Inline implies SFS_Empty 8297 verifyFormat("int f() {}", MergeInlineOnly); 8298 verifyFormat("class C {\n" 8299 " int f() {}\n" 8300 "};", 8301 MergeInlineOnly); 8302 } 8303 8304 TEST_F(FormatTest, PullInlineOnlyFunctionDefinitionsIntoSingleLine) { 8305 FormatStyle MergeInlineOnly = getLLVMStyle(); 8306 MergeInlineOnly.AllowShortFunctionsOnASingleLine = 8307 FormatStyle::SFS_InlineOnly; 8308 verifyFormat("class C {\n" 8309 " int f() { return 42; }\n" 8310 "};", 8311 MergeInlineOnly); 8312 verifyFormat("int f() {\n" 8313 " return 42;\n" 8314 "}", 8315 MergeInlineOnly); 8316 8317 // SFS_InlineOnly does not imply SFS_Empty 8318 verifyFormat("class C {\n" 8319 " int f() {}\n" 8320 "};", 8321 MergeInlineOnly); 8322 verifyFormat("int f() {\n" 8323 "}", 8324 MergeInlineOnly); 8325 8326 // Also verify behavior when BraceWrapping.AfterFunction = true 8327 MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom; 8328 MergeInlineOnly.BraceWrapping.AfterFunction = true; 8329 verifyFormat("class C {\n" 8330 " int f() { return 42; }\n" 8331 "};", 8332 MergeInlineOnly); 8333 verifyFormat("int f()\n" 8334 "{\n" 8335 " return 42;\n" 8336 "}", 8337 MergeInlineOnly); 8338 8339 // SFS_InlineOnly does not imply SFS_Empty 8340 verifyFormat("int f()\n" 8341 "{\n" 8342 "}", 8343 MergeInlineOnly); 8344 verifyFormat("class C {\n" 8345 " int f() {}\n" 8346 "};", 8347 MergeInlineOnly); 8348 } 8349 8350 TEST_F(FormatTest, SplitEmptyFunction) { 8351 FormatStyle Style = getLLVMStyle(); 8352 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 8353 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8354 Style.BraceWrapping.AfterFunction = true; 8355 Style.BraceWrapping.SplitEmptyFunction = false; 8356 Style.ColumnLimit = 40; 8357 8358 verifyFormat("int f()\n" 8359 "{}", 8360 Style); 8361 verifyFormat("int f()\n" 8362 "{\n" 8363 " return 42;\n" 8364 "}", 8365 Style); 8366 verifyFormat("int f()\n" 8367 "{\n" 8368 " // some comment\n" 8369 "}", 8370 Style); 8371 8372 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty; 8373 verifyFormat("int f() {}", Style); 8374 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8375 "{}", 8376 Style); 8377 verifyFormat("int f()\n" 8378 "{\n" 8379 " return 0;\n" 8380 "}", 8381 Style); 8382 8383 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; 8384 verifyFormat("class Foo {\n" 8385 " int f() {}\n" 8386 "};\n", 8387 Style); 8388 verifyFormat("class Foo {\n" 8389 " int f() { return 0; }\n" 8390 "};\n", 8391 Style); 8392 verifyFormat("class Foo {\n" 8393 " int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8394 " {}\n" 8395 "};\n", 8396 Style); 8397 verifyFormat("class Foo {\n" 8398 " int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8399 " {\n" 8400 " return 0;\n" 8401 " }\n" 8402 "};\n", 8403 Style); 8404 8405 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 8406 verifyFormat("int f() {}", Style); 8407 verifyFormat("int f() { return 0; }", Style); 8408 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8409 "{}", 8410 Style); 8411 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8412 "{\n" 8413 " return 0;\n" 8414 "}", 8415 Style); 8416 } 8417 TEST_F(FormatTest, KeepShortFunctionAfterPPElse) { 8418 FormatStyle Style = getLLVMStyle(); 8419 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 8420 verifyFormat("#ifdef A\n" 8421 "int f() {}\n" 8422 "#else\n" 8423 "int g() {}\n" 8424 "#endif", 8425 Style); 8426 } 8427 8428 TEST_F(FormatTest, SplitEmptyClass) { 8429 FormatStyle Style = getLLVMStyle(); 8430 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8431 Style.BraceWrapping.AfterClass = true; 8432 Style.BraceWrapping.SplitEmptyRecord = false; 8433 8434 verifyFormat("class Foo\n" 8435 "{};", 8436 Style); 8437 verifyFormat("/* something */ class Foo\n" 8438 "{};", 8439 Style); 8440 verifyFormat("template <typename X> class Foo\n" 8441 "{};", 8442 Style); 8443 verifyFormat("class Foo\n" 8444 "{\n" 8445 " Foo();\n" 8446 "};", 8447 Style); 8448 verifyFormat("typedef class Foo\n" 8449 "{\n" 8450 "} Foo_t;", 8451 Style); 8452 } 8453 8454 TEST_F(FormatTest, SplitEmptyStruct) { 8455 FormatStyle Style = getLLVMStyle(); 8456 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8457 Style.BraceWrapping.AfterStruct = true; 8458 Style.BraceWrapping.SplitEmptyRecord = false; 8459 8460 verifyFormat("struct Foo\n" 8461 "{};", 8462 Style); 8463 verifyFormat("/* something */ struct Foo\n" 8464 "{};", 8465 Style); 8466 verifyFormat("template <typename X> struct Foo\n" 8467 "{};", 8468 Style); 8469 verifyFormat("struct Foo\n" 8470 "{\n" 8471 " Foo();\n" 8472 "};", 8473 Style); 8474 verifyFormat("typedef struct Foo\n" 8475 "{\n" 8476 "} Foo_t;", 8477 Style); 8478 //typedef struct Bar {} Bar_t; 8479 } 8480 8481 TEST_F(FormatTest, SplitEmptyUnion) { 8482 FormatStyle Style = getLLVMStyle(); 8483 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8484 Style.BraceWrapping.AfterUnion = true; 8485 Style.BraceWrapping.SplitEmptyRecord = false; 8486 8487 verifyFormat("union Foo\n" 8488 "{};", 8489 Style); 8490 verifyFormat("/* something */ union Foo\n" 8491 "{};", 8492 Style); 8493 verifyFormat("union Foo\n" 8494 "{\n" 8495 " A,\n" 8496 "};", 8497 Style); 8498 verifyFormat("typedef union Foo\n" 8499 "{\n" 8500 "} Foo_t;", 8501 Style); 8502 } 8503 8504 TEST_F(FormatTest, SplitEmptyNamespace) { 8505 FormatStyle Style = getLLVMStyle(); 8506 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8507 Style.BraceWrapping.AfterNamespace = true; 8508 Style.BraceWrapping.SplitEmptyNamespace = false; 8509 8510 verifyFormat("namespace Foo\n" 8511 "{};", 8512 Style); 8513 verifyFormat("/* something */ namespace Foo\n" 8514 "{};", 8515 Style); 8516 verifyFormat("inline namespace Foo\n" 8517 "{};", 8518 Style); 8519 verifyFormat("/* something */ inline namespace Foo\n" 8520 "{};", 8521 Style); 8522 verifyFormat("export namespace Foo\n" 8523 "{};", 8524 Style); 8525 verifyFormat("namespace Foo\n" 8526 "{\n" 8527 "void Bar();\n" 8528 "};", 8529 Style); 8530 } 8531 8532 TEST_F(FormatTest, NeverMergeShortRecords) { 8533 FormatStyle Style = getLLVMStyle(); 8534 8535 verifyFormat("class Foo {\n" 8536 " Foo();\n" 8537 "};", 8538 Style); 8539 verifyFormat("typedef class Foo {\n" 8540 " Foo();\n" 8541 "} Foo_t;", 8542 Style); 8543 verifyFormat("struct Foo {\n" 8544 " Foo();\n" 8545 "};", 8546 Style); 8547 verifyFormat("typedef struct Foo {\n" 8548 " Foo();\n" 8549 "} Foo_t;", 8550 Style); 8551 verifyFormat("union Foo {\n" 8552 " A,\n" 8553 "};", 8554 Style); 8555 verifyFormat("typedef union Foo {\n" 8556 " A,\n" 8557 "} Foo_t;", 8558 Style); 8559 verifyFormat("namespace Foo {\n" 8560 "void Bar();\n" 8561 "};", 8562 Style); 8563 8564 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8565 Style.BraceWrapping.AfterClass = true; 8566 Style.BraceWrapping.AfterStruct = true; 8567 Style.BraceWrapping.AfterUnion = true; 8568 Style.BraceWrapping.AfterNamespace = true; 8569 verifyFormat("class Foo\n" 8570 "{\n" 8571 " Foo();\n" 8572 "};", 8573 Style); 8574 verifyFormat("typedef class Foo\n" 8575 "{\n" 8576 " Foo();\n" 8577 "} Foo_t;", 8578 Style); 8579 verifyFormat("struct Foo\n" 8580 "{\n" 8581 " Foo();\n" 8582 "};", 8583 Style); 8584 verifyFormat("typedef struct Foo\n" 8585 "{\n" 8586 " Foo();\n" 8587 "} Foo_t;", 8588 Style); 8589 verifyFormat("union Foo\n" 8590 "{\n" 8591 " A,\n" 8592 "};", 8593 Style); 8594 verifyFormat("typedef union Foo\n" 8595 "{\n" 8596 " A,\n" 8597 "} Foo_t;", 8598 Style); 8599 verifyFormat("namespace Foo\n" 8600 "{\n" 8601 "void Bar();\n" 8602 "};", 8603 Style); 8604 } 8605 8606 TEST_F(FormatTest, UnderstandContextOfRecordTypeKeywords) { 8607 // Elaborate type variable declarations. 8608 verifyFormat("struct foo a = {bar};\nint n;"); 8609 verifyFormat("class foo a = {bar};\nint n;"); 8610 verifyFormat("union foo a = {bar};\nint n;"); 8611 8612 // Elaborate types inside function definitions. 8613 verifyFormat("struct foo f() {}\nint n;"); 8614 verifyFormat("class foo f() {}\nint n;"); 8615 verifyFormat("union foo f() {}\nint n;"); 8616 8617 // Templates. 8618 verifyFormat("template <class X> void f() {}\nint n;"); 8619 verifyFormat("template <struct X> void f() {}\nint n;"); 8620 verifyFormat("template <union X> void f() {}\nint n;"); 8621 8622 // Actual definitions... 8623 verifyFormat("struct {\n} n;"); 8624 verifyFormat( 8625 "template <template <class T, class Y>, class Z> class X {\n} n;"); 8626 verifyFormat("union Z {\n int n;\n} x;"); 8627 verifyFormat("class MACRO Z {\n} n;"); 8628 verifyFormat("class MACRO(X) Z {\n} n;"); 8629 verifyFormat("class __attribute__(X) Z {\n} n;"); 8630 verifyFormat("class __declspec(X) Z {\n} n;"); 8631 verifyFormat("class A##B##C {\n} n;"); 8632 verifyFormat("class alignas(16) Z {\n} n;"); 8633 verifyFormat("class MACRO(X) alignas(16) Z {\n} n;"); 8634 verifyFormat("class MACROA MACRO(X) Z {\n} n;"); 8635 8636 // Redefinition from nested context: 8637 verifyFormat("class A::B::C {\n} n;"); 8638 8639 // Template definitions. 8640 verifyFormat( 8641 "template <typename F>\n" 8642 "Matcher(const Matcher<F> &Other,\n" 8643 " typename enable_if_c<is_base_of<F, T>::value &&\n" 8644 " !is_same<F, T>::value>::type * = 0)\n" 8645 " : Implementation(new ImplicitCastMatcher<F>(Other)) {}"); 8646 8647 // FIXME: This is still incorrectly handled at the formatter side. 8648 verifyFormat("template <> struct X < 15, i<3 && 42 < 50 && 33 < 28> {};"); 8649 verifyFormat("int i = SomeFunction(a<b, a> b);"); 8650 8651 // FIXME: 8652 // This now gets parsed incorrectly as class definition. 8653 // verifyFormat("class A<int> f() {\n}\nint n;"); 8654 8655 // Elaborate types where incorrectly parsing the structural element would 8656 // break the indent. 8657 verifyFormat("if (true)\n" 8658 " class X x;\n" 8659 "else\n" 8660 " f();\n"); 8661 8662 // This is simply incomplete. Formatting is not important, but must not crash. 8663 verifyFormat("class A:"); 8664 } 8665 8666 TEST_F(FormatTest, DoNotInterfereWithErrorAndWarning) { 8667 EXPECT_EQ("#error Leave all white!!!!! space* alone!\n", 8668 format("#error Leave all white!!!!! space* alone!\n")); 8669 EXPECT_EQ( 8670 "#warning Leave all white!!!!! space* alone!\n", 8671 format("#warning Leave all white!!!!! space* alone!\n")); 8672 EXPECT_EQ("#error 1", format(" # error 1")); 8673 EXPECT_EQ("#warning 1", format(" # warning 1")); 8674 } 8675 8676 TEST_F(FormatTest, FormatHashIfExpressions) { 8677 verifyFormat("#if AAAA && BBBB"); 8678 verifyFormat("#if (AAAA && BBBB)"); 8679 verifyFormat("#elif (AAAA && BBBB)"); 8680 // FIXME: Come up with a better indentation for #elif. 8681 verifyFormat( 8682 "#if !defined(AAAAAAA) && (defined CCCCCC || defined DDDDDD) && \\\n" 8683 " defined(BBBBBBBB)\n" 8684 "#elif !defined(AAAAAA) && (defined CCCCC || defined DDDDDD) && \\\n" 8685 " defined(BBBBBBBB)\n" 8686 "#endif", 8687 getLLVMStyleWithColumns(65)); 8688 } 8689 8690 TEST_F(FormatTest, MergeHandlingInTheFaceOfPreprocessorDirectives) { 8691 FormatStyle AllowsMergedIf = getGoogleStyle(); 8692 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = 8693 FormatStyle::SIS_WithoutElse; 8694 verifyFormat("void f() { f(); }\n#error E", AllowsMergedIf); 8695 verifyFormat("if (true) return 42;\n#error E", AllowsMergedIf); 8696 verifyFormat("if (true)\n#error E\n return 42;", AllowsMergedIf); 8697 EXPECT_EQ("if (true) return 42;", 8698 format("if (true)\nreturn 42;", AllowsMergedIf)); 8699 FormatStyle ShortMergedIf = AllowsMergedIf; 8700 ShortMergedIf.ColumnLimit = 25; 8701 verifyFormat("#define A \\\n" 8702 " if (true) return 42;", 8703 ShortMergedIf); 8704 verifyFormat("#define A \\\n" 8705 " f(); \\\n" 8706 " if (true)\n" 8707 "#define B", 8708 ShortMergedIf); 8709 verifyFormat("#define A \\\n" 8710 " f(); \\\n" 8711 " if (true)\n" 8712 "g();", 8713 ShortMergedIf); 8714 verifyFormat("{\n" 8715 "#ifdef A\n" 8716 " // Comment\n" 8717 " if (true) continue;\n" 8718 "#endif\n" 8719 " // Comment\n" 8720 " if (true) continue;\n" 8721 "}", 8722 ShortMergedIf); 8723 ShortMergedIf.ColumnLimit = 33; 8724 verifyFormat("#define A \\\n" 8725 " if constexpr (true) return 42;", 8726 ShortMergedIf); 8727 verifyFormat("#define A \\\n" 8728 " if CONSTEXPR (true) return 42;", 8729 ShortMergedIf); 8730 ShortMergedIf.ColumnLimit = 29; 8731 verifyFormat("#define A \\\n" 8732 " if (aaaaaaaaaa) return 1; \\\n" 8733 " return 2;", 8734 ShortMergedIf); 8735 ShortMergedIf.ColumnLimit = 28; 8736 verifyFormat("#define A \\\n" 8737 " if (aaaaaaaaaa) \\\n" 8738 " return 1; \\\n" 8739 " return 2;", 8740 ShortMergedIf); 8741 verifyFormat("#define A \\\n" 8742 " if constexpr (aaaaaaa) \\\n" 8743 " return 1; \\\n" 8744 " return 2;", 8745 ShortMergedIf); 8746 verifyFormat("#define A \\\n" 8747 " if CONSTEXPR (aaaaaaa) \\\n" 8748 " return 1; \\\n" 8749 " return 2;", 8750 ShortMergedIf); 8751 } 8752 8753 TEST_F(FormatTest, FormatStarDependingOnContext) { 8754 verifyFormat("void f(int *a);"); 8755 verifyFormat("void f() { f(fint * b); }"); 8756 verifyFormat("class A {\n void f(int *a);\n};"); 8757 verifyFormat("class A {\n int *a;\n};"); 8758 verifyFormat("namespace a {\n" 8759 "namespace b {\n" 8760 "class A {\n" 8761 " void f() {}\n" 8762 " int *a;\n" 8763 "};\n" 8764 "} // namespace b\n" 8765 "} // namespace a"); 8766 } 8767 8768 TEST_F(FormatTest, SpecialTokensAtEndOfLine) { 8769 verifyFormat("while"); 8770 verifyFormat("operator"); 8771 } 8772 8773 TEST_F(FormatTest, SkipsDeeplyNestedLines) { 8774 // This code would be painfully slow to format if we didn't skip it. 8775 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 8776 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 8777 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 8778 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 8779 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 8780 "A(1, 1)\n" 8781 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" // 10x 8782 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 8783 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 8784 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 8785 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 8786 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 8787 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 8788 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 8789 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 8790 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1);\n"); 8791 // Deeply nested part is untouched, rest is formatted. 8792 EXPECT_EQ(std::string("int i;\n") + Code + "int j;\n", 8793 format(std::string("int i;\n") + Code + "int j;\n", 8794 getLLVMStyle(), SC_ExpectIncomplete)); 8795 } 8796 8797 //===----------------------------------------------------------------------===// 8798 // Objective-C tests. 8799 //===----------------------------------------------------------------------===// 8800 8801 TEST_F(FormatTest, FormatForObjectiveCMethodDecls) { 8802 verifyFormat("- (void)sendAction:(SEL)aSelector to:(BOOL)anObject;"); 8803 EXPECT_EQ("- (NSUInteger)indexOfObject:(id)anObject;", 8804 format("-(NSUInteger)indexOfObject:(id)anObject;")); 8805 EXPECT_EQ("- (NSInteger)Mthod1;", format("-(NSInteger)Mthod1;")); 8806 EXPECT_EQ("+ (id)Mthod2;", format("+(id)Mthod2;")); 8807 EXPECT_EQ("- (NSInteger)Method3:(id)anObject;", 8808 format("-(NSInteger)Method3:(id)anObject;")); 8809 EXPECT_EQ("- (NSInteger)Method4:(id)anObject;", 8810 format("-(NSInteger)Method4:(id)anObject;")); 8811 EXPECT_EQ("- (NSInteger)Method5:(id)anObject:(id)AnotherObject;", 8812 format("-(NSInteger)Method5:(id)anObject:(id)AnotherObject;")); 8813 EXPECT_EQ("- (id)Method6:(id)A:(id)B:(id)C:(id)D;", 8814 format("- (id)Method6:(id)A:(id)B:(id)C:(id)D;")); 8815 EXPECT_EQ("- (void)sendAction:(SEL)aSelector to:(id)anObject " 8816 "forAllCells:(BOOL)flag;", 8817 format("- (void)sendAction:(SEL)aSelector to:(id)anObject " 8818 "forAllCells:(BOOL)flag;")); 8819 8820 // Very long objectiveC method declaration. 8821 verifyFormat("- (void)aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n" 8822 " (SoooooooooooooooooooooomeType *)bbbbbbbbbb;"); 8823 verifyFormat("- (NSUInteger)indexOfObject:(id)anObject\n" 8824 " inRange:(NSRange)range\n" 8825 " outRange:(NSRange)out_range\n" 8826 " outRange1:(NSRange)out_range1\n" 8827 " outRange2:(NSRange)out_range2\n" 8828 " outRange3:(NSRange)out_range3\n" 8829 " outRange4:(NSRange)out_range4\n" 8830 " outRange5:(NSRange)out_range5\n" 8831 " outRange6:(NSRange)out_range6\n" 8832 " outRange7:(NSRange)out_range7\n" 8833 " outRange8:(NSRange)out_range8\n" 8834 " outRange9:(NSRange)out_range9;"); 8835 8836 // When the function name has to be wrapped. 8837 FormatStyle Style = getLLVMStyle(); 8838 // ObjC ignores IndentWrappedFunctionNames when wrapping methods 8839 // and always indents instead. 8840 Style.IndentWrappedFunctionNames = false; 8841 verifyFormat("- (SomeLooooooooooooooooooooongType *)\n" 8842 " veryLooooooooooongName:(NSString)aaaaaaaaaaaaaa\n" 8843 " anotherName:(NSString)bbbbbbbbbbbbbb {\n" 8844 "}", 8845 Style); 8846 Style.IndentWrappedFunctionNames = true; 8847 verifyFormat("- (SomeLooooooooooooooooooooongType *)\n" 8848 " veryLooooooooooongName:(NSString)cccccccccccccc\n" 8849 " anotherName:(NSString)dddddddddddddd {\n" 8850 "}", 8851 Style); 8852 8853 verifyFormat("- (int)sum:(vector<int>)numbers;"); 8854 verifyGoogleFormat("- (void)setDelegate:(id<Protocol>)delegate;"); 8855 // FIXME: In LLVM style, there should be a space in front of a '<' for ObjC 8856 // protocol lists (but not for template classes): 8857 // verifyFormat("- (void)setDelegate:(id <Protocol>)delegate;"); 8858 8859 verifyFormat("- (int (*)())foo:(int (*)())f;"); 8860 verifyGoogleFormat("- (int (*)())foo:(int (*)())foo;"); 8861 8862 // If there's no return type (very rare in practice!), LLVM and Google style 8863 // agree. 8864 verifyFormat("- foo;"); 8865 verifyFormat("- foo:(int)f;"); 8866 verifyGoogleFormat("- foo:(int)foo;"); 8867 } 8868 8869 8870 TEST_F(FormatTest, BreaksStringLiterals) { 8871 EXPECT_EQ("\"some text \"\n" 8872 "\"other\";", 8873 format("\"some text other\";", getLLVMStyleWithColumns(12))); 8874 EXPECT_EQ("\"some text \"\n" 8875 "\"other\";", 8876 format("\\\n\"some text other\";", getLLVMStyleWithColumns(12))); 8877 EXPECT_EQ( 8878 "#define A \\\n" 8879 " \"some \" \\\n" 8880 " \"text \" \\\n" 8881 " \"other\";", 8882 format("#define A \"some text other\";", getLLVMStyleWithColumns(12))); 8883 EXPECT_EQ( 8884 "#define A \\\n" 8885 " \"so \" \\\n" 8886 " \"text \" \\\n" 8887 " \"other\";", 8888 format("#define A \"so text other\";", getLLVMStyleWithColumns(12))); 8889 8890 EXPECT_EQ("\"some text\"", 8891 format("\"some text\"", getLLVMStyleWithColumns(1))); 8892 EXPECT_EQ("\"some text\"", 8893 format("\"some text\"", getLLVMStyleWithColumns(11))); 8894 EXPECT_EQ("\"some \"\n" 8895 "\"text\"", 8896 format("\"some text\"", getLLVMStyleWithColumns(10))); 8897 EXPECT_EQ("\"some \"\n" 8898 "\"text\"", 8899 format("\"some text\"", getLLVMStyleWithColumns(7))); 8900 EXPECT_EQ("\"some\"\n" 8901 "\" tex\"\n" 8902 "\"t\"", 8903 format("\"some text\"", getLLVMStyleWithColumns(6))); 8904 EXPECT_EQ("\"some\"\n" 8905 "\" tex\"\n" 8906 "\" and\"", 8907 format("\"some tex and\"", getLLVMStyleWithColumns(6))); 8908 EXPECT_EQ("\"some\"\n" 8909 "\"/tex\"\n" 8910 "\"/and\"", 8911 format("\"some/tex/and\"", getLLVMStyleWithColumns(6))); 8912 8913 EXPECT_EQ("variable =\n" 8914 " \"long string \"\n" 8915 " \"literal\";", 8916 format("variable = \"long string literal\";", 8917 getLLVMStyleWithColumns(20))); 8918 8919 EXPECT_EQ("variable = f(\n" 8920 " \"long string \"\n" 8921 " \"literal\",\n" 8922 " short,\n" 8923 " loooooooooooooooooooong);", 8924 format("variable = f(\"long string literal\", short, " 8925 "loooooooooooooooooooong);", 8926 getLLVMStyleWithColumns(20))); 8927 8928 EXPECT_EQ( 8929 "f(g(\"long string \"\n" 8930 " \"literal\"),\n" 8931 " b);", 8932 format("f(g(\"long string literal\"), b);", getLLVMStyleWithColumns(20))); 8933 EXPECT_EQ("f(g(\"long string \"\n" 8934 " \"literal\",\n" 8935 " a),\n" 8936 " b);", 8937 format("f(g(\"long string literal\", a), b);", 8938 getLLVMStyleWithColumns(20))); 8939 EXPECT_EQ( 8940 "f(\"one two\".split(\n" 8941 " variable));", 8942 format("f(\"one two\".split(variable));", getLLVMStyleWithColumns(20))); 8943 EXPECT_EQ("f(\"one two three four five six \"\n" 8944 " \"seven\".split(\n" 8945 " really_looooong_variable));", 8946 format("f(\"one two three four five six seven\"." 8947 "split(really_looooong_variable));", 8948 getLLVMStyleWithColumns(33))); 8949 8950 EXPECT_EQ("f(\"some \"\n" 8951 " \"text\",\n" 8952 " other);", 8953 format("f(\"some text\", other);", getLLVMStyleWithColumns(10))); 8954 8955 // Only break as a last resort. 8956 verifyFormat( 8957 "aaaaaaaaaaaaaaaaaaaa(\n" 8958 " aaaaaaaaaaaaaaaaaaaa,\n" 8959 " aaaaaa(\"aaa aaaaa aaa aaa aaaaa aaa aaaaa aaa aaa aaaaaa\"));"); 8960 8961 EXPECT_EQ("\"splitmea\"\n" 8962 "\"trandomp\"\n" 8963 "\"oint\"", 8964 format("\"splitmeatrandompoint\"", getLLVMStyleWithColumns(10))); 8965 8966 EXPECT_EQ("\"split/\"\n" 8967 "\"pathat/\"\n" 8968 "\"slashes\"", 8969 format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10))); 8970 8971 EXPECT_EQ("\"split/\"\n" 8972 "\"pathat/\"\n" 8973 "\"slashes\"", 8974 format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10))); 8975 EXPECT_EQ("\"split at \"\n" 8976 "\"spaces/at/\"\n" 8977 "\"slashes.at.any$\"\n" 8978 "\"non-alphanumeric%\"\n" 8979 "\"1111111111characte\"\n" 8980 "\"rs\"", 8981 format("\"split at " 8982 "spaces/at/" 8983 "slashes.at." 8984 "any$non-" 8985 "alphanumeric%" 8986 "1111111111characte" 8987 "rs\"", 8988 getLLVMStyleWithColumns(20))); 8989 8990 // Verify that splitting the strings understands 8991 // Style::AlwaysBreakBeforeMultilineStrings. 8992 EXPECT_EQ( 8993 "aaaaaaaaaaaa(\n" 8994 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa \"\n" 8995 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\");", 8996 format("aaaaaaaaaaaa(\"aaaaaaaaaaaaaaaaaaaaaaaaaa " 8997 "aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa " 8998 "aaaaaaaaaaaaaaaaaaaaaa\");", 8999 getGoogleStyle())); 9000 EXPECT_EQ("return \"aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 9001 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\";", 9002 format("return \"aaaaaaaaaaaaaaaaaaaaaa " 9003 "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa " 9004 "aaaaaaaaaaaaaaaaaaaaaa\";", 9005 getGoogleStyle())); 9006 EXPECT_EQ("llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 9007 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";", 9008 format("llvm::outs() << " 9009 "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa" 9010 "aaaaaaaaaaaaaaaaaaa\";")); 9011 EXPECT_EQ("ffff(\n" 9012 " {\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 9013 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});", 9014 format("ffff({\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa " 9015 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});", 9016 getGoogleStyle())); 9017 9018 FormatStyle Style = getLLVMStyleWithColumns(12); 9019 Style.BreakStringLiterals = false; 9020 EXPECT_EQ("\"some text other\";", format("\"some text other\";", Style)); 9021 9022 FormatStyle AlignLeft = getLLVMStyleWithColumns(12); 9023 AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left; 9024 EXPECT_EQ("#define A \\\n" 9025 " \"some \" \\\n" 9026 " \"text \" \\\n" 9027 " \"other\";", 9028 format("#define A \"some text other\";", AlignLeft)); 9029 } 9030 9031 TEST_F(FormatTest, BreaksStringLiteralsAtColumnLimit) { 9032 EXPECT_EQ("C a = \"some more \"\n" 9033 " \"text\";", 9034 format("C a = \"some more text\";", getLLVMStyleWithColumns(18))); 9035 } 9036 9037 TEST_F(FormatTest, FullyRemoveEmptyLines) { 9038 FormatStyle NoEmptyLines = getLLVMStyleWithColumns(80); 9039 NoEmptyLines.MaxEmptyLinesToKeep = 0; 9040 EXPECT_EQ("int i = a(b());", 9041 format("int i=a(\n\n b(\n\n\n )\n\n);", NoEmptyLines)); 9042 } 9043 9044 TEST_F(FormatTest, BreaksStringLiteralsWithTabs) { 9045 EXPECT_EQ( 9046 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 9047 "(\n" 9048 " \"x\t\");", 9049 format("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 9050 "aaaaaaa(" 9051 "\"x\t\");")); 9052 } 9053 9054 TEST_F(FormatTest, BreaksWideAndNSStringLiterals) { 9055 EXPECT_EQ( 9056 "u8\"utf8 string \"\n" 9057 "u8\"literal\";", 9058 format("u8\"utf8 string literal\";", getGoogleStyleWithColumns(16))); 9059 EXPECT_EQ( 9060 "u\"utf16 string \"\n" 9061 "u\"literal\";", 9062 format("u\"utf16 string literal\";", getGoogleStyleWithColumns(16))); 9063 EXPECT_EQ( 9064 "U\"utf32 string \"\n" 9065 "U\"literal\";", 9066 format("U\"utf32 string literal\";", getGoogleStyleWithColumns(16))); 9067 EXPECT_EQ("L\"wide string \"\n" 9068 "L\"literal\";", 9069 format("L\"wide string literal\";", getGoogleStyleWithColumns(16))); 9070 EXPECT_EQ("@\"NSString \"\n" 9071 "@\"literal\";", 9072 format("@\"NSString literal\";", getGoogleStyleWithColumns(19))); 9073 verifyFormat(R"(NSString *s = @"那那那那";)", getLLVMStyleWithColumns(26)); 9074 9075 // This input makes clang-format try to split the incomplete unicode escape 9076 // sequence, which used to lead to a crasher. 9077 verifyNoCrash( 9078 "aaaaaaaaaaaaaaaaaaaa = L\"\\udff\"'; // aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 9079 getLLVMStyleWithColumns(60)); 9080 } 9081 9082 TEST_F(FormatTest, DoesNotBreakRawStringLiterals) { 9083 FormatStyle Style = getGoogleStyleWithColumns(15); 9084 EXPECT_EQ("R\"x(raw literal)x\";", format("R\"x(raw literal)x\";", Style)); 9085 EXPECT_EQ("uR\"x(raw literal)x\";", format("uR\"x(raw literal)x\";", Style)); 9086 EXPECT_EQ("LR\"x(raw literal)x\";", format("LR\"x(raw literal)x\";", Style)); 9087 EXPECT_EQ("UR\"x(raw literal)x\";", format("UR\"x(raw literal)x\";", Style)); 9088 EXPECT_EQ("u8R\"x(raw literal)x\";", 9089 format("u8R\"x(raw literal)x\";", Style)); 9090 } 9091 9092 TEST_F(FormatTest, BreaksStringLiteralsWithin_TMacro) { 9093 FormatStyle Style = getLLVMStyleWithColumns(20); 9094 EXPECT_EQ( 9095 "_T(\"aaaaaaaaaaaaaa\")\n" 9096 "_T(\"aaaaaaaaaaaaaa\")\n" 9097 "_T(\"aaaaaaaaaaaa\")", 9098 format(" _T(\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\")", Style)); 9099 EXPECT_EQ("f(x,\n" 9100 " _T(\"aaaaaaaaaaaa\")\n" 9101 " _T(\"aaa\"),\n" 9102 " z);", 9103 format("f(x, _T(\"aaaaaaaaaaaaaaa\"), z);", Style)); 9104 9105 // FIXME: Handle embedded spaces in one iteration. 9106 // EXPECT_EQ("_T(\"aaaaaaaaaaaaa\")\n" 9107 // "_T(\"aaaaaaaaaaaaa\")\n" 9108 // "_T(\"aaaaaaaaaaaaa\")\n" 9109 // "_T(\"a\")", 9110 // format(" _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", 9111 // getLLVMStyleWithColumns(20))); 9112 EXPECT_EQ( 9113 "_T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", 9114 format(" _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", Style)); 9115 EXPECT_EQ("f(\n" 9116 "#if !TEST\n" 9117 " _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n" 9118 "#endif\n" 9119 ");", 9120 format("f(\n" 9121 "#if !TEST\n" 9122 "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n" 9123 "#endif\n" 9124 ");")); 9125 EXPECT_EQ("f(\n" 9126 "\n" 9127 " _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));", 9128 format("f(\n" 9129 "\n" 9130 "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));")); 9131 } 9132 9133 TEST_F(FormatTest, BreaksStringLiteralOperands) { 9134 // In a function call with two operands, the second can be broken with no line 9135 // break before it. 9136 EXPECT_EQ("func(a, \"long long \"\n" 9137 " \"long long\");", 9138 format("func(a, \"long long long long\");", 9139 getLLVMStyleWithColumns(24))); 9140 // In a function call with three operands, the second must be broken with a 9141 // line break before it. 9142 EXPECT_EQ("func(a,\n" 9143 " \"long long long \"\n" 9144 " \"long\",\n" 9145 " c);", 9146 format("func(a, \"long long long long\", c);", 9147 getLLVMStyleWithColumns(24))); 9148 // In a function call with three operands, the third must be broken with a 9149 // line break before it. 9150 EXPECT_EQ("func(a, b,\n" 9151 " \"long long long \"\n" 9152 " \"long\");", 9153 format("func(a, b, \"long long long long\");", 9154 getLLVMStyleWithColumns(24))); 9155 // In a function call with three operands, both the second and the third must 9156 // be broken with a line break before them. 9157 EXPECT_EQ("func(a,\n" 9158 " \"long long long \"\n" 9159 " \"long\",\n" 9160 " \"long long long \"\n" 9161 " \"long\");", 9162 format("func(a, \"long long long long\", \"long long long long\");", 9163 getLLVMStyleWithColumns(24))); 9164 // In a chain of << with two operands, the second can be broken with no line 9165 // break before it. 9166 EXPECT_EQ("a << \"line line \"\n" 9167 " \"line\";", 9168 format("a << \"line line line\";", 9169 getLLVMStyleWithColumns(20))); 9170 // In a chain of << with three operands, the second can be broken with no line 9171 // break before it. 9172 EXPECT_EQ("abcde << \"line \"\n" 9173 " \"line line\"\n" 9174 " << c;", 9175 format("abcde << \"line line line\" << c;", 9176 getLLVMStyleWithColumns(20))); 9177 // In a chain of << with three operands, the third must be broken with a line 9178 // break before it. 9179 EXPECT_EQ("a << b\n" 9180 " << \"line line \"\n" 9181 " \"line\";", 9182 format("a << b << \"line line line\";", 9183 getLLVMStyleWithColumns(20))); 9184 // In a chain of << with three operands, the second can be broken with no line 9185 // break before it and the third must be broken with a line break before it. 9186 EXPECT_EQ("abcd << \"line line \"\n" 9187 " \"line\"\n" 9188 " << \"line line \"\n" 9189 " \"line\";", 9190 format("abcd << \"line line line\" << \"line line line\";", 9191 getLLVMStyleWithColumns(20))); 9192 // In a chain of binary operators with two operands, the second can be broken 9193 // with no line break before it. 9194 EXPECT_EQ("abcd + \"line line \"\n" 9195 " \"line line\";", 9196 format("abcd + \"line line line line\";", 9197 getLLVMStyleWithColumns(20))); 9198 // In a chain of binary operators with three operands, the second must be 9199 // broken with a line break before it. 9200 EXPECT_EQ("abcd +\n" 9201 " \"line line \"\n" 9202 " \"line line\" +\n" 9203 " e;", 9204 format("abcd + \"line line line line\" + e;", 9205 getLLVMStyleWithColumns(20))); 9206 // In a function call with two operands, with AlignAfterOpenBracket enabled, 9207 // the first must be broken with a line break before it. 9208 FormatStyle Style = getLLVMStyleWithColumns(25); 9209 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 9210 EXPECT_EQ("someFunction(\n" 9211 " \"long long long \"\n" 9212 " \"long\",\n" 9213 " a);", 9214 format("someFunction(\"long long long long\", a);", Style)); 9215 } 9216 9217 TEST_F(FormatTest, DontSplitStringLiteralsWithEscapedNewlines) { 9218 EXPECT_EQ( 9219 "aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 9220 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 9221 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";", 9222 format("aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 9223 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 9224 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";")); 9225 } 9226 9227 TEST_F(FormatTest, CountsCharactersInMultilineRawStringLiterals) { 9228 EXPECT_EQ("f(g(R\"x(raw literal)x\", a), b);", 9229 format("f(g(R\"x(raw literal)x\", a), b);", getGoogleStyle())); 9230 EXPECT_EQ("fffffffffff(g(R\"x(\n" 9231 "multiline raw string literal xxxxxxxxxxxxxx\n" 9232 ")x\",\n" 9233 " a),\n" 9234 " b);", 9235 format("fffffffffff(g(R\"x(\n" 9236 "multiline raw string literal xxxxxxxxxxxxxx\n" 9237 ")x\", a), b);", 9238 getGoogleStyleWithColumns(20))); 9239 EXPECT_EQ("fffffffffff(\n" 9240 " g(R\"x(qqq\n" 9241 "multiline raw string literal xxxxxxxxxxxxxx\n" 9242 ")x\",\n" 9243 " a),\n" 9244 " b);", 9245 format("fffffffffff(g(R\"x(qqq\n" 9246 "multiline raw string literal xxxxxxxxxxxxxx\n" 9247 ")x\", a), b);", 9248 getGoogleStyleWithColumns(20))); 9249 9250 EXPECT_EQ("fffffffffff(R\"x(\n" 9251 "multiline raw string literal xxxxxxxxxxxxxx\n" 9252 ")x\");", 9253 format("fffffffffff(R\"x(\n" 9254 "multiline raw string literal xxxxxxxxxxxxxx\n" 9255 ")x\");", 9256 getGoogleStyleWithColumns(20))); 9257 EXPECT_EQ("fffffffffff(R\"x(\n" 9258 "multiline raw string literal xxxxxxxxxxxxxx\n" 9259 ")x\" + bbbbbb);", 9260 format("fffffffffff(R\"x(\n" 9261 "multiline raw string literal xxxxxxxxxxxxxx\n" 9262 ")x\" + bbbbbb);", 9263 getGoogleStyleWithColumns(20))); 9264 EXPECT_EQ("fffffffffff(\n" 9265 " R\"x(\n" 9266 "multiline raw string literal xxxxxxxxxxxxxx\n" 9267 ")x\" +\n" 9268 " bbbbbb);", 9269 format("fffffffffff(\n" 9270 " R\"x(\n" 9271 "multiline raw string literal xxxxxxxxxxxxxx\n" 9272 ")x\" + bbbbbb);", 9273 getGoogleStyleWithColumns(20))); 9274 EXPECT_EQ("fffffffffff(R\"(single line raw string)\" + bbbbbb);", 9275 format("fffffffffff(\n" 9276 " R\"(single line raw string)\" + bbbbbb);")); 9277 } 9278 9279 TEST_F(FormatTest, SkipsUnknownStringLiterals) { 9280 verifyFormat("string a = \"unterminated;"); 9281 EXPECT_EQ("function(\"unterminated,\n" 9282 " OtherParameter);", 9283 format("function( \"unterminated,\n" 9284 " OtherParameter);")); 9285 } 9286 9287 TEST_F(FormatTest, DoesNotTryToParseUDLiteralsInPreCpp11Code) { 9288 FormatStyle Style = getLLVMStyle(); 9289 Style.Standard = FormatStyle::LS_Cpp03; 9290 EXPECT_EQ("#define x(_a) printf(\"foo\" _a);", 9291 format("#define x(_a) printf(\"foo\"_a);", Style)); 9292 } 9293 9294 TEST_F(FormatTest, UnderstandsCpp1y) { verifyFormat("int bi{1'000'000};"); } 9295 9296 TEST_F(FormatTest, BreakStringLiteralsBeforeUnbreakableTokenSequence) { 9297 EXPECT_EQ("someFunction(\"aaabbbcccd\"\n" 9298 " \"ddeeefff\");", 9299 format("someFunction(\"aaabbbcccdddeeefff\");", 9300 getLLVMStyleWithColumns(25))); 9301 EXPECT_EQ("someFunction1234567890(\n" 9302 " \"aaabbbcccdddeeefff\");", 9303 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 9304 getLLVMStyleWithColumns(26))); 9305 EXPECT_EQ("someFunction1234567890(\n" 9306 " \"aaabbbcccdddeeeff\"\n" 9307 " \"f\");", 9308 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 9309 getLLVMStyleWithColumns(25))); 9310 EXPECT_EQ("someFunction1234567890(\n" 9311 " \"aaabbbcccdddeeeff\"\n" 9312 " \"f\");", 9313 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 9314 getLLVMStyleWithColumns(24))); 9315 EXPECT_EQ("someFunction(\n" 9316 " \"aaabbbcc ddde \"\n" 9317 " \"efff\");", 9318 format("someFunction(\"aaabbbcc ddde efff\");", 9319 getLLVMStyleWithColumns(25))); 9320 EXPECT_EQ("someFunction(\"aaabbbccc \"\n" 9321 " \"ddeeefff\");", 9322 format("someFunction(\"aaabbbccc ddeeefff\");", 9323 getLLVMStyleWithColumns(25))); 9324 EXPECT_EQ("someFunction1234567890(\n" 9325 " \"aaabb \"\n" 9326 " \"cccdddeeefff\");", 9327 format("someFunction1234567890(\"aaabb cccdddeeefff\");", 9328 getLLVMStyleWithColumns(25))); 9329 EXPECT_EQ("#define A \\\n" 9330 " string s = \\\n" 9331 " \"123456789\" \\\n" 9332 " \"0\"; \\\n" 9333 " int i;", 9334 format("#define A string s = \"1234567890\"; int i;", 9335 getLLVMStyleWithColumns(20))); 9336 EXPECT_EQ("someFunction(\n" 9337 " \"aaabbbcc \"\n" 9338 " \"dddeeefff\");", 9339 format("someFunction(\"aaabbbcc dddeeefff\");", 9340 getLLVMStyleWithColumns(25))); 9341 } 9342 9343 TEST_F(FormatTest, DoNotBreakStringLiteralsInEscapeSequence) { 9344 EXPECT_EQ("\"\\a\"", format("\"\\a\"", getLLVMStyleWithColumns(3))); 9345 EXPECT_EQ("\"\\\"", format("\"\\\"", getLLVMStyleWithColumns(2))); 9346 EXPECT_EQ("\"test\"\n" 9347 "\"\\n\"", 9348 format("\"test\\n\"", getLLVMStyleWithColumns(7))); 9349 EXPECT_EQ("\"tes\\\\\"\n" 9350 "\"n\"", 9351 format("\"tes\\\\n\"", getLLVMStyleWithColumns(7))); 9352 EXPECT_EQ("\"\\\\\\\\\"\n" 9353 "\"\\n\"", 9354 format("\"\\\\\\\\\\n\"", getLLVMStyleWithColumns(7))); 9355 EXPECT_EQ("\"\\uff01\"", format("\"\\uff01\"", getLLVMStyleWithColumns(7))); 9356 EXPECT_EQ("\"\\uff01\"\n" 9357 "\"test\"", 9358 format("\"\\uff01test\"", getLLVMStyleWithColumns(8))); 9359 EXPECT_EQ("\"\\Uff01ff02\"", 9360 format("\"\\Uff01ff02\"", getLLVMStyleWithColumns(11))); 9361 EXPECT_EQ("\"\\x000000000001\"\n" 9362 "\"next\"", 9363 format("\"\\x000000000001next\"", getLLVMStyleWithColumns(16))); 9364 EXPECT_EQ("\"\\x000000000001next\"", 9365 format("\"\\x000000000001next\"", getLLVMStyleWithColumns(15))); 9366 EXPECT_EQ("\"\\x000000000001\"", 9367 format("\"\\x000000000001\"", getLLVMStyleWithColumns(7))); 9368 EXPECT_EQ("\"test\"\n" 9369 "\"\\000000\"\n" 9370 "\"000001\"", 9371 format("\"test\\000000000001\"", getLLVMStyleWithColumns(9))); 9372 EXPECT_EQ("\"test\\000\"\n" 9373 "\"00000000\"\n" 9374 "\"1\"", 9375 format("\"test\\000000000001\"", getLLVMStyleWithColumns(10))); 9376 } 9377 9378 TEST_F(FormatTest, DoNotCreateUnreasonableUnwrappedLines) { 9379 verifyFormat("void f() {\n" 9380 " return g() {}\n" 9381 " void h() {}"); 9382 verifyFormat("int a[] = {void forgot_closing_brace(){f();\n" 9383 "g();\n" 9384 "}"); 9385 } 9386 9387 TEST_F(FormatTest, DoNotPrematurelyEndUnwrappedLineForReturnStatements) { 9388 verifyFormat( 9389 "void f() { return C{param1, param2}.SomeCall(param1, param2); }"); 9390 } 9391 9392 TEST_F(FormatTest, FormatsClosingBracesInEmptyNestedBlocks) { 9393 verifyFormat("class X {\n" 9394 " void f() {\n" 9395 " }\n" 9396 "};", 9397 getLLVMStyleWithColumns(12)); 9398 } 9399 9400 TEST_F(FormatTest, ConfigurableIndentWidth) { 9401 FormatStyle EightIndent = getLLVMStyleWithColumns(18); 9402 EightIndent.IndentWidth = 8; 9403 EightIndent.ContinuationIndentWidth = 8; 9404 verifyFormat("void f() {\n" 9405 " someFunction();\n" 9406 " if (true) {\n" 9407 " f();\n" 9408 " }\n" 9409 "}", 9410 EightIndent); 9411 verifyFormat("class X {\n" 9412 " void f() {\n" 9413 " }\n" 9414 "};", 9415 EightIndent); 9416 verifyFormat("int x[] = {\n" 9417 " call(),\n" 9418 " call()};", 9419 EightIndent); 9420 } 9421 9422 TEST_F(FormatTest, ConfigurableFunctionDeclarationIndentAfterType) { 9423 verifyFormat("double\n" 9424 "f();", 9425 getLLVMStyleWithColumns(8)); 9426 } 9427 9428 TEST_F(FormatTest, ConfigurableUseOfTab) { 9429 FormatStyle Tab = getLLVMStyleWithColumns(42); 9430 Tab.IndentWidth = 8; 9431 Tab.UseTab = FormatStyle::UT_Always; 9432 Tab.AlignEscapedNewlines = FormatStyle::ENAS_Left; 9433 9434 EXPECT_EQ("if (aaaaaaaa && // q\n" 9435 " bb)\t\t// w\n" 9436 "\t;", 9437 format("if (aaaaaaaa &&// q\n" 9438 "bb)// w\n" 9439 ";", 9440 Tab)); 9441 EXPECT_EQ("if (aaa && bbb) // w\n" 9442 "\t;", 9443 format("if(aaa&&bbb)// w\n" 9444 ";", 9445 Tab)); 9446 9447 verifyFormat("class X {\n" 9448 "\tvoid f() {\n" 9449 "\t\tsomeFunction(parameter1,\n" 9450 "\t\t\t parameter2);\n" 9451 "\t}\n" 9452 "};", 9453 Tab); 9454 verifyFormat("#define A \\\n" 9455 "\tvoid f() { \\\n" 9456 "\t\tsomeFunction( \\\n" 9457 "\t\t parameter1, \\\n" 9458 "\t\t parameter2); \\\n" 9459 "\t}", 9460 Tab); 9461 verifyFormat("int a;\t // x\n" 9462 "int bbbbbbbb; // x\n", 9463 Tab); 9464 9465 Tab.TabWidth = 4; 9466 Tab.IndentWidth = 8; 9467 verifyFormat("class TabWidth4Indent8 {\n" 9468 "\t\tvoid f() {\n" 9469 "\t\t\t\tsomeFunction(parameter1,\n" 9470 "\t\t\t\t\t\t\t parameter2);\n" 9471 "\t\t}\n" 9472 "};", 9473 Tab); 9474 9475 Tab.TabWidth = 4; 9476 Tab.IndentWidth = 4; 9477 verifyFormat("class TabWidth4Indent4 {\n" 9478 "\tvoid f() {\n" 9479 "\t\tsomeFunction(parameter1,\n" 9480 "\t\t\t\t\t parameter2);\n" 9481 "\t}\n" 9482 "};", 9483 Tab); 9484 9485 Tab.TabWidth = 8; 9486 Tab.IndentWidth = 4; 9487 verifyFormat("class TabWidth8Indent4 {\n" 9488 " void f() {\n" 9489 "\tsomeFunction(parameter1,\n" 9490 "\t\t parameter2);\n" 9491 " }\n" 9492 "};", 9493 Tab); 9494 9495 Tab.TabWidth = 8; 9496 Tab.IndentWidth = 8; 9497 EXPECT_EQ("/*\n" 9498 "\t a\t\tcomment\n" 9499 "\t in multiple lines\n" 9500 " */", 9501 format(" /*\t \t \n" 9502 " \t \t a\t\tcomment\t \t\n" 9503 " \t \t in multiple lines\t\n" 9504 " \t */", 9505 Tab)); 9506 9507 Tab.UseTab = FormatStyle::UT_ForIndentation; 9508 verifyFormat("{\n" 9509 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9510 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9511 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9512 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9513 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9514 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9515 "};", 9516 Tab); 9517 verifyFormat("enum AA {\n" 9518 "\ta1, // Force multiple lines\n" 9519 "\ta2,\n" 9520 "\ta3\n" 9521 "};", 9522 Tab); 9523 EXPECT_EQ("if (aaaaaaaa && // q\n" 9524 " bb) // w\n" 9525 "\t;", 9526 format("if (aaaaaaaa &&// q\n" 9527 "bb)// w\n" 9528 ";", 9529 Tab)); 9530 verifyFormat("class X {\n" 9531 "\tvoid f() {\n" 9532 "\t\tsomeFunction(parameter1,\n" 9533 "\t\t parameter2);\n" 9534 "\t}\n" 9535 "};", 9536 Tab); 9537 verifyFormat("{\n" 9538 "\tQ(\n" 9539 "\t {\n" 9540 "\t\t int a;\n" 9541 "\t\t someFunction(aaaaaaaa,\n" 9542 "\t\t bbbbbbb);\n" 9543 "\t },\n" 9544 "\t p);\n" 9545 "}", 9546 Tab); 9547 EXPECT_EQ("{\n" 9548 "\t/* aaaa\n" 9549 "\t bbbb */\n" 9550 "}", 9551 format("{\n" 9552 "/* aaaa\n" 9553 " bbbb */\n" 9554 "}", 9555 Tab)); 9556 EXPECT_EQ("{\n" 9557 "\t/*\n" 9558 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 9559 "\t bbbbbbbbbbbbb\n" 9560 "\t*/\n" 9561 "}", 9562 format("{\n" 9563 "/*\n" 9564 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 9565 "*/\n" 9566 "}", 9567 Tab)); 9568 EXPECT_EQ("{\n" 9569 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 9570 "\t// bbbbbbbbbbbbb\n" 9571 "}", 9572 format("{\n" 9573 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 9574 "}", 9575 Tab)); 9576 EXPECT_EQ("{\n" 9577 "\t/*\n" 9578 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 9579 "\t bbbbbbbbbbbbb\n" 9580 "\t*/\n" 9581 "}", 9582 format("{\n" 9583 "\t/*\n" 9584 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 9585 "\t*/\n" 9586 "}", 9587 Tab)); 9588 EXPECT_EQ("{\n" 9589 "\t/*\n" 9590 "\n" 9591 "\t*/\n" 9592 "}", 9593 format("{\n" 9594 "\t/*\n" 9595 "\n" 9596 "\t*/\n" 9597 "}", 9598 Tab)); 9599 EXPECT_EQ("{\n" 9600 "\t/*\n" 9601 " asdf\n" 9602 "\t*/\n" 9603 "}", 9604 format("{\n" 9605 "\t/*\n" 9606 " asdf\n" 9607 "\t*/\n" 9608 "}", 9609 Tab)); 9610 9611 Tab.UseTab = FormatStyle::UT_Never; 9612 EXPECT_EQ("/*\n" 9613 " a\t\tcomment\n" 9614 " in multiple lines\n" 9615 " */", 9616 format(" /*\t \t \n" 9617 " \t \t a\t\tcomment\t \t\n" 9618 " \t \t in multiple lines\t\n" 9619 " \t */", 9620 Tab)); 9621 EXPECT_EQ("/* some\n" 9622 " comment */", 9623 format(" \t \t /* some\n" 9624 " \t \t comment */", 9625 Tab)); 9626 EXPECT_EQ("int a; /* some\n" 9627 " comment */", 9628 format(" \t \t int a; /* some\n" 9629 " \t \t comment */", 9630 Tab)); 9631 9632 EXPECT_EQ("int a; /* some\n" 9633 "comment */", 9634 format(" \t \t int\ta; /* some\n" 9635 " \t \t comment */", 9636 Tab)); 9637 EXPECT_EQ("f(\"\t\t\"); /* some\n" 9638 " comment */", 9639 format(" \t \t f(\"\t\t\"); /* some\n" 9640 " \t \t comment */", 9641 Tab)); 9642 EXPECT_EQ("{\n" 9643 " /*\n" 9644 " * Comment\n" 9645 " */\n" 9646 " int i;\n" 9647 "}", 9648 format("{\n" 9649 "\t/*\n" 9650 "\t * Comment\n" 9651 "\t */\n" 9652 "\t int i;\n" 9653 "}")); 9654 9655 Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation; 9656 Tab.TabWidth = 8; 9657 Tab.IndentWidth = 8; 9658 EXPECT_EQ("if (aaaaaaaa && // q\n" 9659 " bb) // w\n" 9660 "\t;", 9661 format("if (aaaaaaaa &&// q\n" 9662 "bb)// w\n" 9663 ";", 9664 Tab)); 9665 EXPECT_EQ("if (aaa && bbb) // w\n" 9666 "\t;", 9667 format("if(aaa&&bbb)// w\n" 9668 ";", 9669 Tab)); 9670 verifyFormat("class X {\n" 9671 "\tvoid f() {\n" 9672 "\t\tsomeFunction(parameter1,\n" 9673 "\t\t\t parameter2);\n" 9674 "\t}\n" 9675 "};", 9676 Tab); 9677 verifyFormat("#define A \\\n" 9678 "\tvoid f() { \\\n" 9679 "\t\tsomeFunction( \\\n" 9680 "\t\t parameter1, \\\n" 9681 "\t\t parameter2); \\\n" 9682 "\t}", 9683 Tab); 9684 Tab.TabWidth = 4; 9685 Tab.IndentWidth = 8; 9686 verifyFormat("class TabWidth4Indent8 {\n" 9687 "\t\tvoid f() {\n" 9688 "\t\t\t\tsomeFunction(parameter1,\n" 9689 "\t\t\t\t\t\t\t parameter2);\n" 9690 "\t\t}\n" 9691 "};", 9692 Tab); 9693 Tab.TabWidth = 4; 9694 Tab.IndentWidth = 4; 9695 verifyFormat("class TabWidth4Indent4 {\n" 9696 "\tvoid f() {\n" 9697 "\t\tsomeFunction(parameter1,\n" 9698 "\t\t\t\t\t parameter2);\n" 9699 "\t}\n" 9700 "};", 9701 Tab); 9702 Tab.TabWidth = 8; 9703 Tab.IndentWidth = 4; 9704 verifyFormat("class TabWidth8Indent4 {\n" 9705 " void f() {\n" 9706 "\tsomeFunction(parameter1,\n" 9707 "\t\t parameter2);\n" 9708 " }\n" 9709 "};", 9710 Tab); 9711 Tab.TabWidth = 8; 9712 Tab.IndentWidth = 8; 9713 EXPECT_EQ("/*\n" 9714 "\t a\t\tcomment\n" 9715 "\t in multiple lines\n" 9716 " */", 9717 format(" /*\t \t \n" 9718 " \t \t a\t\tcomment\t \t\n" 9719 " \t \t in multiple lines\t\n" 9720 " \t */", 9721 Tab)); 9722 verifyFormat("{\n" 9723 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9724 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9725 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9726 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9727 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9728 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9729 "};", 9730 Tab); 9731 verifyFormat("enum AA {\n" 9732 "\ta1, // Force multiple lines\n" 9733 "\ta2,\n" 9734 "\ta3\n" 9735 "};", 9736 Tab); 9737 EXPECT_EQ("if (aaaaaaaa && // q\n" 9738 " bb) // w\n" 9739 "\t;", 9740 format("if (aaaaaaaa &&// q\n" 9741 "bb)// w\n" 9742 ";", 9743 Tab)); 9744 verifyFormat("class X {\n" 9745 "\tvoid f() {\n" 9746 "\t\tsomeFunction(parameter1,\n" 9747 "\t\t\t parameter2);\n" 9748 "\t}\n" 9749 "};", 9750 Tab); 9751 verifyFormat("{\n" 9752 "\tQ(\n" 9753 "\t {\n" 9754 "\t\t int a;\n" 9755 "\t\t someFunction(aaaaaaaa,\n" 9756 "\t\t\t\t bbbbbbb);\n" 9757 "\t },\n" 9758 "\t p);\n" 9759 "}", 9760 Tab); 9761 EXPECT_EQ("{\n" 9762 "\t/* aaaa\n" 9763 "\t bbbb */\n" 9764 "}", 9765 format("{\n" 9766 "/* aaaa\n" 9767 " bbbb */\n" 9768 "}", 9769 Tab)); 9770 EXPECT_EQ("{\n" 9771 "\t/*\n" 9772 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 9773 "\t bbbbbbbbbbbbb\n" 9774 "\t*/\n" 9775 "}", 9776 format("{\n" 9777 "/*\n" 9778 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 9779 "*/\n" 9780 "}", 9781 Tab)); 9782 EXPECT_EQ("{\n" 9783 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 9784 "\t// bbbbbbbbbbbbb\n" 9785 "}", 9786 format("{\n" 9787 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 9788 "}", 9789 Tab)); 9790 EXPECT_EQ("{\n" 9791 "\t/*\n" 9792 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 9793 "\t bbbbbbbbbbbbb\n" 9794 "\t*/\n" 9795 "}", 9796 format("{\n" 9797 "\t/*\n" 9798 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 9799 "\t*/\n" 9800 "}", 9801 Tab)); 9802 EXPECT_EQ("{\n" 9803 "\t/*\n" 9804 "\n" 9805 "\t*/\n" 9806 "}", 9807 format("{\n" 9808 "\t/*\n" 9809 "\n" 9810 "\t*/\n" 9811 "}", 9812 Tab)); 9813 EXPECT_EQ("{\n" 9814 "\t/*\n" 9815 " asdf\n" 9816 "\t*/\n" 9817 "}", 9818 format("{\n" 9819 "\t/*\n" 9820 " asdf\n" 9821 "\t*/\n" 9822 "}", 9823 Tab)); 9824 EXPECT_EQ("/*\n" 9825 "\t a\t\tcomment\n" 9826 "\t in multiple lines\n" 9827 " */", 9828 format(" /*\t \t \n" 9829 " \t \t a\t\tcomment\t \t\n" 9830 " \t \t in multiple lines\t\n" 9831 " \t */", 9832 Tab)); 9833 EXPECT_EQ("/* some\n" 9834 " comment */", 9835 format(" \t \t /* some\n" 9836 " \t \t comment */", 9837 Tab)); 9838 EXPECT_EQ("int a; /* some\n" 9839 " comment */", 9840 format(" \t \t int a; /* some\n" 9841 " \t \t comment */", 9842 Tab)); 9843 EXPECT_EQ("int a; /* some\n" 9844 "comment */", 9845 format(" \t \t int\ta; /* some\n" 9846 " \t \t comment */", 9847 Tab)); 9848 EXPECT_EQ("f(\"\t\t\"); /* some\n" 9849 " comment */", 9850 format(" \t \t f(\"\t\t\"); /* some\n" 9851 " \t \t comment */", 9852 Tab)); 9853 EXPECT_EQ("{\n" 9854 " /*\n" 9855 " * Comment\n" 9856 " */\n" 9857 " int i;\n" 9858 "}", 9859 format("{\n" 9860 "\t/*\n" 9861 "\t * Comment\n" 9862 "\t */\n" 9863 "\t int i;\n" 9864 "}")); 9865 Tab.AlignConsecutiveAssignments = true; 9866 Tab.AlignConsecutiveDeclarations = true; 9867 Tab.TabWidth = 4; 9868 Tab.IndentWidth = 4; 9869 verifyFormat("class Assign {\n" 9870 "\tvoid f() {\n" 9871 "\t\tint x = 123;\n" 9872 "\t\tint random = 4;\n" 9873 "\t\tstd::string alphabet =\n" 9874 "\t\t\t\"abcdefghijklmnopqrstuvwxyz\";\n" 9875 "\t}\n" 9876 "};", 9877 Tab); 9878 } 9879 9880 TEST_F(FormatTest, CalculatesOriginalColumn) { 9881 EXPECT_EQ("\"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 9882 "q\"; /* some\n" 9883 " comment */", 9884 format(" \"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 9885 "q\"; /* some\n" 9886 " comment */", 9887 getLLVMStyle())); 9888 EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n" 9889 "/* some\n" 9890 " comment */", 9891 format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n" 9892 " /* some\n" 9893 " comment */", 9894 getLLVMStyle())); 9895 EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 9896 "qqq\n" 9897 "/* some\n" 9898 " comment */", 9899 format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 9900 "qqq\n" 9901 " /* some\n" 9902 " comment */", 9903 getLLVMStyle())); 9904 EXPECT_EQ("inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 9905 "wwww; /* some\n" 9906 " comment */", 9907 format(" inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 9908 "wwww; /* some\n" 9909 " comment */", 9910 getLLVMStyle())); 9911 } 9912 9913 TEST_F(FormatTest, ConfigurableSpaceBeforeParens) { 9914 FormatStyle NoSpace = getLLVMStyle(); 9915 NoSpace.SpaceBeforeParens = FormatStyle::SBPO_Never; 9916 9917 verifyFormat("while(true)\n" 9918 " continue;", 9919 NoSpace); 9920 verifyFormat("for(;;)\n" 9921 " continue;", 9922 NoSpace); 9923 verifyFormat("if(true)\n" 9924 " f();\n" 9925 "else if(true)\n" 9926 " f();", 9927 NoSpace); 9928 verifyFormat("do {\n" 9929 " do_something();\n" 9930 "} while(something());", 9931 NoSpace); 9932 verifyFormat("switch(x) {\n" 9933 "default:\n" 9934 " break;\n" 9935 "}", 9936 NoSpace); 9937 verifyFormat("auto i = std::make_unique<int>(5);", NoSpace); 9938 verifyFormat("size_t x = sizeof(x);", NoSpace); 9939 verifyFormat("auto f(int x) -> decltype(x);", NoSpace); 9940 verifyFormat("int f(T x) noexcept(x.create());", NoSpace); 9941 verifyFormat("alignas(128) char a[128];", NoSpace); 9942 verifyFormat("size_t x = alignof(MyType);", NoSpace); 9943 verifyFormat("static_assert(sizeof(char) == 1, \"Impossible!\");", NoSpace); 9944 verifyFormat("int f() throw(Deprecated);", NoSpace); 9945 verifyFormat("typedef void (*cb)(int);", NoSpace); 9946 verifyFormat("T A::operator()();", NoSpace); 9947 verifyFormat("X A::operator++(T);", NoSpace); 9948 verifyFormat("auto lambda = []() { return 0; };", NoSpace); 9949 9950 FormatStyle Space = getLLVMStyle(); 9951 Space.SpaceBeforeParens = FormatStyle::SBPO_Always; 9952 9953 verifyFormat("int f ();", Space); 9954 verifyFormat("void f (int a, T b) {\n" 9955 " while (true)\n" 9956 " continue;\n" 9957 "}", 9958 Space); 9959 verifyFormat("if (true)\n" 9960 " f ();\n" 9961 "else if (true)\n" 9962 " f ();", 9963 Space); 9964 verifyFormat("do {\n" 9965 " do_something ();\n" 9966 "} while (something ());", 9967 Space); 9968 verifyFormat("switch (x) {\n" 9969 "default:\n" 9970 " break;\n" 9971 "}", 9972 Space); 9973 verifyFormat("A::A () : a (1) {}", Space); 9974 verifyFormat("void f () __attribute__ ((asdf));", Space); 9975 verifyFormat("*(&a + 1);\n" 9976 "&((&a)[1]);\n" 9977 "a[(b + c) * d];\n" 9978 "(((a + 1) * 2) + 3) * 4;", 9979 Space); 9980 verifyFormat("#define A(x) x", Space); 9981 verifyFormat("#define A (x) x", Space); 9982 verifyFormat("#if defined(x)\n" 9983 "#endif", 9984 Space); 9985 verifyFormat("auto i = std::make_unique<int> (5);", Space); 9986 verifyFormat("size_t x = sizeof (x);", Space); 9987 verifyFormat("auto f (int x) -> decltype (x);", Space); 9988 verifyFormat("int f (T x) noexcept (x.create ());", Space); 9989 verifyFormat("alignas (128) char a[128];", Space); 9990 verifyFormat("size_t x = alignof (MyType);", Space); 9991 verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");", Space); 9992 verifyFormat("int f () throw (Deprecated);", Space); 9993 verifyFormat("typedef void (*cb) (int);", Space); 9994 verifyFormat("T A::operator() ();", Space); 9995 verifyFormat("X A::operator++ (T);", Space); 9996 verifyFormat("auto lambda = [] () { return 0; };", Space); 9997 verifyFormat("int x = int (y);", Space); 9998 9999 FormatStyle SomeSpace = getLLVMStyle(); 10000 SomeSpace.SpaceBeforeParens = FormatStyle::SBPO_NonEmptyParentheses; 10001 10002 verifyFormat("[]() -> float {}", SomeSpace); 10003 verifyFormat("[] (auto foo) {}", SomeSpace); 10004 verifyFormat("[foo]() -> int {}", SomeSpace); 10005 verifyFormat("int f();", SomeSpace); 10006 verifyFormat("void f (int a, T b) {\n" 10007 " while (true)\n" 10008 " continue;\n" 10009 "}", 10010 SomeSpace); 10011 verifyFormat("if (true)\n" 10012 " f();\n" 10013 "else if (true)\n" 10014 " f();", 10015 SomeSpace); 10016 verifyFormat("do {\n" 10017 " do_something();\n" 10018 "} while (something());", 10019 SomeSpace); 10020 verifyFormat("switch (x) {\n" 10021 "default:\n" 10022 " break;\n" 10023 "}", 10024 SomeSpace); 10025 verifyFormat("A::A() : a (1) {}", SomeSpace); 10026 verifyFormat("void f() __attribute__ ((asdf));", SomeSpace); 10027 verifyFormat("*(&a + 1);\n" 10028 "&((&a)[1]);\n" 10029 "a[(b + c) * d];\n" 10030 "(((a + 1) * 2) + 3) * 4;", 10031 SomeSpace); 10032 verifyFormat("#define A(x) x", SomeSpace); 10033 verifyFormat("#define A (x) x", SomeSpace); 10034 verifyFormat("#if defined(x)\n" 10035 "#endif", 10036 SomeSpace); 10037 verifyFormat("auto i = std::make_unique<int> (5);", SomeSpace); 10038 verifyFormat("size_t x = sizeof (x);", SomeSpace); 10039 verifyFormat("auto f (int x) -> decltype (x);", SomeSpace); 10040 verifyFormat("int f (T x) noexcept (x.create());", SomeSpace); 10041 verifyFormat("alignas (128) char a[128];", SomeSpace); 10042 verifyFormat("size_t x = alignof (MyType);", SomeSpace); 10043 verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");", 10044 SomeSpace); 10045 verifyFormat("int f() throw (Deprecated);", SomeSpace); 10046 verifyFormat("typedef void (*cb) (int);", SomeSpace); 10047 verifyFormat("T A::operator()();", SomeSpace); 10048 verifyFormat("X A::operator++ (T);", SomeSpace); 10049 verifyFormat("int x = int (y);", SomeSpace); 10050 verifyFormat("auto lambda = []() { return 0; };", SomeSpace); 10051 } 10052 10053 TEST_F(FormatTest, SpaceAfterLogicalNot) { 10054 FormatStyle Spaces = getLLVMStyle(); 10055 Spaces.SpaceAfterLogicalNot = true; 10056 10057 verifyFormat("bool x = ! y", Spaces); 10058 verifyFormat("if (! isFailure())", Spaces); 10059 verifyFormat("if (! (a && b))", Spaces); 10060 verifyFormat("\"Error!\"", Spaces); 10061 verifyFormat("! ! x", Spaces); 10062 } 10063 10064 TEST_F(FormatTest, ConfigurableSpacesInParentheses) { 10065 FormatStyle Spaces = getLLVMStyle(); 10066 10067 Spaces.SpacesInParentheses = true; 10068 verifyFormat("do_something( ::globalVar );", Spaces); 10069 verifyFormat("call( x, y, z );", Spaces); 10070 verifyFormat("call();", Spaces); 10071 verifyFormat("std::function<void( int, int )> callback;", Spaces); 10072 verifyFormat("void inFunction() { std::function<void( int, int )> fct; }", 10073 Spaces); 10074 verifyFormat("while ( (bool)1 )\n" 10075 " continue;", 10076 Spaces); 10077 verifyFormat("for ( ;; )\n" 10078 " continue;", 10079 Spaces); 10080 verifyFormat("if ( true )\n" 10081 " f();\n" 10082 "else if ( true )\n" 10083 " f();", 10084 Spaces); 10085 verifyFormat("do {\n" 10086 " do_something( (int)i );\n" 10087 "} while ( something() );", 10088 Spaces); 10089 verifyFormat("switch ( x ) {\n" 10090 "default:\n" 10091 " break;\n" 10092 "}", 10093 Spaces); 10094 10095 Spaces.SpacesInParentheses = false; 10096 Spaces.SpacesInCStyleCastParentheses = true; 10097 verifyFormat("Type *A = ( Type * )P;", Spaces); 10098 verifyFormat("Type *A = ( vector<Type *, int *> )P;", Spaces); 10099 verifyFormat("x = ( int32 )y;", Spaces); 10100 verifyFormat("int a = ( int )(2.0f);", Spaces); 10101 verifyFormat("#define AA(X) sizeof((( X * )NULL)->a)", Spaces); 10102 verifyFormat("my_int a = ( my_int )sizeof(int);", Spaces); 10103 verifyFormat("#define x (( int )-1)", Spaces); 10104 10105 // Run the first set of tests again with: 10106 Spaces.SpacesInParentheses = false; 10107 Spaces.SpaceInEmptyParentheses = true; 10108 Spaces.SpacesInCStyleCastParentheses = true; 10109 verifyFormat("call(x, y, z);", Spaces); 10110 verifyFormat("call( );", Spaces); 10111 verifyFormat("std::function<void(int, int)> callback;", Spaces); 10112 verifyFormat("while (( bool )1)\n" 10113 " continue;", 10114 Spaces); 10115 verifyFormat("for (;;)\n" 10116 " continue;", 10117 Spaces); 10118 verifyFormat("if (true)\n" 10119 " f( );\n" 10120 "else if (true)\n" 10121 " f( );", 10122 Spaces); 10123 verifyFormat("do {\n" 10124 " do_something(( int )i);\n" 10125 "} while (something( ));", 10126 Spaces); 10127 verifyFormat("switch (x) {\n" 10128 "default:\n" 10129 " break;\n" 10130 "}", 10131 Spaces); 10132 10133 // Run the first set of tests again with: 10134 Spaces.SpaceAfterCStyleCast = true; 10135 verifyFormat("call(x, y, z);", Spaces); 10136 verifyFormat("call( );", Spaces); 10137 verifyFormat("std::function<void(int, int)> callback;", Spaces); 10138 verifyFormat("while (( bool ) 1)\n" 10139 " continue;", 10140 Spaces); 10141 verifyFormat("for (;;)\n" 10142 " continue;", 10143 Spaces); 10144 verifyFormat("if (true)\n" 10145 " f( );\n" 10146 "else if (true)\n" 10147 " f( );", 10148 Spaces); 10149 verifyFormat("do {\n" 10150 " do_something(( int ) i);\n" 10151 "} while (something( ));", 10152 Spaces); 10153 verifyFormat("switch (x) {\n" 10154 "default:\n" 10155 " break;\n" 10156 "}", 10157 Spaces); 10158 10159 // Run subset of tests again with: 10160 Spaces.SpacesInCStyleCastParentheses = false; 10161 Spaces.SpaceAfterCStyleCast = true; 10162 verifyFormat("while ((bool) 1)\n" 10163 " continue;", 10164 Spaces); 10165 verifyFormat("do {\n" 10166 " do_something((int) i);\n" 10167 "} while (something( ));", 10168 Spaces); 10169 } 10170 10171 TEST_F(FormatTest, ConfigurableSpacesInSquareBrackets) { 10172 verifyFormat("int a[5];"); 10173 verifyFormat("a[3] += 42;"); 10174 10175 FormatStyle Spaces = getLLVMStyle(); 10176 Spaces.SpacesInSquareBrackets = true; 10177 // Lambdas unchanged. 10178 verifyFormat("int c = []() -> int { return 2; }();\n", Spaces); 10179 verifyFormat("return [i, args...] {};", Spaces); 10180 10181 // Not lambdas. 10182 verifyFormat("int a[ 5 ];", Spaces); 10183 verifyFormat("a[ 3 ] += 42;", Spaces); 10184 verifyFormat("constexpr char hello[]{\"hello\"};", Spaces); 10185 verifyFormat("double &operator[](int i) { return 0; }\n" 10186 "int i;", 10187 Spaces); 10188 verifyFormat("std::unique_ptr<int[]> foo() {}", Spaces); 10189 verifyFormat("int i = a[ a ][ a ]->f();", Spaces); 10190 verifyFormat("int i = (*b)[ a ]->f();", Spaces); 10191 } 10192 10193 TEST_F(FormatTest, ConfigurableSpaceBeforeAssignmentOperators) { 10194 verifyFormat("int a = 5;"); 10195 verifyFormat("a += 42;"); 10196 verifyFormat("a or_eq 8;"); 10197 10198 FormatStyle Spaces = getLLVMStyle(); 10199 Spaces.SpaceBeforeAssignmentOperators = false; 10200 verifyFormat("int a= 5;", Spaces); 10201 verifyFormat("a+= 42;", Spaces); 10202 verifyFormat("a or_eq 8;", Spaces); 10203 } 10204 10205 TEST_F(FormatTest, ConfigurableSpaceBeforeColon) { 10206 verifyFormat("class Foo : public Bar {};"); 10207 verifyFormat("Foo::Foo() : foo(1) {}"); 10208 verifyFormat("for (auto a : b) {\n}"); 10209 verifyFormat("int x = a ? b : c;"); 10210 verifyFormat("{\n" 10211 "label0:\n" 10212 " int x = 0;\n" 10213 "}"); 10214 verifyFormat("switch (x) {\n" 10215 "case 1:\n" 10216 "default:\n" 10217 "}"); 10218 10219 FormatStyle CtorInitializerStyle = getLLVMStyleWithColumns(30); 10220 CtorInitializerStyle.SpaceBeforeCtorInitializerColon = false; 10221 verifyFormat("class Foo : public Bar {};", CtorInitializerStyle); 10222 verifyFormat("Foo::Foo(): foo(1) {}", CtorInitializerStyle); 10223 verifyFormat("for (auto a : b) {\n}", CtorInitializerStyle); 10224 verifyFormat("int x = a ? b : c;", CtorInitializerStyle); 10225 verifyFormat("{\n" 10226 "label1:\n" 10227 " int x = 0;\n" 10228 "}", 10229 CtorInitializerStyle); 10230 verifyFormat("switch (x) {\n" 10231 "case 1:\n" 10232 "default:\n" 10233 "}", 10234 CtorInitializerStyle); 10235 CtorInitializerStyle.BreakConstructorInitializers = 10236 FormatStyle::BCIS_AfterColon; 10237 verifyFormat("Fooooooooooo::Fooooooooooo():\n" 10238 " aaaaaaaaaaaaaaaa(1),\n" 10239 " bbbbbbbbbbbbbbbb(2) {}", 10240 CtorInitializerStyle); 10241 CtorInitializerStyle.BreakConstructorInitializers = 10242 FormatStyle::BCIS_BeforeComma; 10243 verifyFormat("Fooooooooooo::Fooooooooooo()\n" 10244 " : aaaaaaaaaaaaaaaa(1)\n" 10245 " , bbbbbbbbbbbbbbbb(2) {}", 10246 CtorInitializerStyle); 10247 CtorInitializerStyle.BreakConstructorInitializers = 10248 FormatStyle::BCIS_BeforeColon; 10249 verifyFormat("Fooooooooooo::Fooooooooooo()\n" 10250 " : aaaaaaaaaaaaaaaa(1),\n" 10251 " bbbbbbbbbbbbbbbb(2) {}", 10252 CtorInitializerStyle); 10253 CtorInitializerStyle.ConstructorInitializerIndentWidth = 0; 10254 verifyFormat("Fooooooooooo::Fooooooooooo()\n" 10255 ": aaaaaaaaaaaaaaaa(1),\n" 10256 " bbbbbbbbbbbbbbbb(2) {}", 10257 CtorInitializerStyle); 10258 10259 FormatStyle InheritanceStyle = getLLVMStyleWithColumns(30); 10260 InheritanceStyle.SpaceBeforeInheritanceColon = false; 10261 verifyFormat("class Foo: public Bar {};", InheritanceStyle); 10262 verifyFormat("Foo::Foo() : foo(1) {}", InheritanceStyle); 10263 verifyFormat("for (auto a : b) {\n}", InheritanceStyle); 10264 verifyFormat("int x = a ? b : c;", InheritanceStyle); 10265 verifyFormat("{\n" 10266 "label2:\n" 10267 " int x = 0;\n" 10268 "}", 10269 InheritanceStyle); 10270 verifyFormat("switch (x) {\n" 10271 "case 1:\n" 10272 "default:\n" 10273 "}", 10274 InheritanceStyle); 10275 InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_AfterColon; 10276 verifyFormat("class Foooooooooooooooooooooo:\n" 10277 " public aaaaaaaaaaaaaaaaaa,\n" 10278 " public bbbbbbbbbbbbbbbbbb {\n" 10279 "}", 10280 InheritanceStyle); 10281 InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeComma; 10282 verifyFormat("class Foooooooooooooooooooooo\n" 10283 " : public aaaaaaaaaaaaaaaaaa\n" 10284 " , public bbbbbbbbbbbbbbbbbb {\n" 10285 "}", 10286 InheritanceStyle); 10287 InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeColon; 10288 verifyFormat("class Foooooooooooooooooooooo\n" 10289 " : public aaaaaaaaaaaaaaaaaa,\n" 10290 " public bbbbbbbbbbbbbbbbbb {\n" 10291 "}", 10292 InheritanceStyle); 10293 InheritanceStyle.ConstructorInitializerIndentWidth = 0; 10294 verifyFormat("class Foooooooooooooooooooooo\n" 10295 ": public aaaaaaaaaaaaaaaaaa,\n" 10296 " public bbbbbbbbbbbbbbbbbb {}", 10297 InheritanceStyle); 10298 10299 FormatStyle ForLoopStyle = getLLVMStyle(); 10300 ForLoopStyle.SpaceBeforeRangeBasedForLoopColon = false; 10301 verifyFormat("class Foo : public Bar {};", ForLoopStyle); 10302 verifyFormat("Foo::Foo() : foo(1) {}", ForLoopStyle); 10303 verifyFormat("for (auto a: b) {\n}", ForLoopStyle); 10304 verifyFormat("int x = a ? b : c;", ForLoopStyle); 10305 verifyFormat("{\n" 10306 "label2:\n" 10307 " int x = 0;\n" 10308 "}", 10309 ForLoopStyle); 10310 verifyFormat("switch (x) {\n" 10311 "case 1:\n" 10312 "default:\n" 10313 "}", 10314 ForLoopStyle); 10315 10316 FormatStyle NoSpaceStyle = getLLVMStyle(); 10317 NoSpaceStyle.SpaceBeforeCtorInitializerColon = false; 10318 NoSpaceStyle.SpaceBeforeInheritanceColon = false; 10319 NoSpaceStyle.SpaceBeforeRangeBasedForLoopColon = false; 10320 verifyFormat("class Foo: public Bar {};", NoSpaceStyle); 10321 verifyFormat("Foo::Foo(): foo(1) {}", NoSpaceStyle); 10322 verifyFormat("for (auto a: b) {\n}", NoSpaceStyle); 10323 verifyFormat("int x = a ? b : c;", NoSpaceStyle); 10324 verifyFormat("{\n" 10325 "label3:\n" 10326 " int x = 0;\n" 10327 "}", 10328 NoSpaceStyle); 10329 verifyFormat("switch (x) {\n" 10330 "case 1:\n" 10331 "default:\n" 10332 "}", 10333 NoSpaceStyle); 10334 } 10335 10336 TEST_F(FormatTest, AlignConsecutiveMacros) { 10337 FormatStyle Style = getLLVMStyle(); 10338 Style.AlignConsecutiveAssignments = true; 10339 Style.AlignConsecutiveDeclarations = true; 10340 Style.AlignConsecutiveMacros = false; 10341 10342 verifyFormat("#define a 3\n" 10343 "#define bbbb 4\n" 10344 "#define ccc (5)", 10345 Style); 10346 10347 verifyFormat("#define f(x) (x * x)\n" 10348 "#define fff(x, y, z) (x * y + z)\n" 10349 "#define ffff(x, y) (x - y)", 10350 Style); 10351 10352 verifyFormat("#define foo(x, y) (x + y)\n" 10353 "#define bar (5, 6)(2 + 2)", 10354 Style); 10355 10356 verifyFormat("#define a 3\n" 10357 "#define bbbb 4\n" 10358 "#define ccc (5)\n" 10359 "#define f(x) (x * x)\n" 10360 "#define fff(x, y, z) (x * y + z)\n" 10361 "#define ffff(x, y) (x - y)", 10362 Style); 10363 10364 Style.AlignConsecutiveMacros = true; 10365 verifyFormat("#define a 3\n" 10366 "#define bbbb 4\n" 10367 "#define ccc (5)", 10368 Style); 10369 10370 verifyFormat("#define f(x) (x * x)\n" 10371 "#define fff(x, y, z) (x * y + z)\n" 10372 "#define ffff(x, y) (x - y)", 10373 Style); 10374 10375 verifyFormat("#define foo(x, y) (x + y)\n" 10376 "#define bar (5, 6)(2 + 2)", 10377 Style); 10378 10379 verifyFormat("#define a 3\n" 10380 "#define bbbb 4\n" 10381 "#define ccc (5)\n" 10382 "#define f(x) (x * x)\n" 10383 "#define fff(x, y, z) (x * y + z)\n" 10384 "#define ffff(x, y) (x - y)", 10385 Style); 10386 10387 verifyFormat("#define a 5\n" 10388 "#define foo(x, y) (x + y)\n" 10389 "#define CCC (6)\n" 10390 "auto lambda = []() {\n" 10391 " auto ii = 0;\n" 10392 " float j = 0;\n" 10393 " return 0;\n" 10394 "};\n" 10395 "int i = 0;\n" 10396 "float i2 = 0;\n" 10397 "auto v = type{\n" 10398 " i = 1, //\n" 10399 " (i = 2), //\n" 10400 " i = 3 //\n" 10401 "};", 10402 Style); 10403 10404 Style.AlignConsecutiveMacros = false; 10405 Style.ColumnLimit = 20; 10406 10407 verifyFormat("#define a \\\n" 10408 " \"aabbbbbbbbbbbb\"\n" 10409 "#define D \\\n" 10410 " \"aabbbbbbbbbbbb\" \\\n" 10411 " \"ccddeeeeeeeee\"\n" 10412 "#define B \\\n" 10413 " \"QQQQQQQQQQQQQ\" \\\n" 10414 " \"FFFFFFFFFFFFF\" \\\n" 10415 " \"LLLLLLLL\"\n", 10416 Style); 10417 10418 Style.AlignConsecutiveMacros = true; 10419 verifyFormat("#define a \\\n" 10420 " \"aabbbbbbbbbbbb\"\n" 10421 "#define D \\\n" 10422 " \"aabbbbbbbbbbbb\" \\\n" 10423 " \"ccddeeeeeeeee\"\n" 10424 "#define B \\\n" 10425 " \"QQQQQQQQQQQQQ\" \\\n" 10426 " \"FFFFFFFFFFFFF\" \\\n" 10427 " \"LLLLLLLL\"\n", 10428 Style); 10429 } 10430 10431 TEST_F(FormatTest, AlignConsecutiveAssignments) { 10432 FormatStyle Alignment = getLLVMStyle(); 10433 Alignment.AlignConsecutiveMacros = true; 10434 Alignment.AlignConsecutiveAssignments = false; 10435 verifyFormat("int a = 5;\n" 10436 "int oneTwoThree = 123;", 10437 Alignment); 10438 verifyFormat("int a = 5;\n" 10439 "int oneTwoThree = 123;", 10440 Alignment); 10441 10442 Alignment.AlignConsecutiveAssignments = true; 10443 verifyFormat("int a = 5;\n" 10444 "int oneTwoThree = 123;", 10445 Alignment); 10446 verifyFormat("int a = method();\n" 10447 "int oneTwoThree = 133;", 10448 Alignment); 10449 verifyFormat("a &= 5;\n" 10450 "bcd *= 5;\n" 10451 "ghtyf += 5;\n" 10452 "dvfvdb -= 5;\n" 10453 "a /= 5;\n" 10454 "vdsvsv %= 5;\n" 10455 "sfdbddfbdfbb ^= 5;\n" 10456 "dvsdsv |= 5;\n" 10457 "int dsvvdvsdvvv = 123;", 10458 Alignment); 10459 verifyFormat("int i = 1, j = 10;\n" 10460 "something = 2000;", 10461 Alignment); 10462 verifyFormat("something = 2000;\n" 10463 "int i = 1, j = 10;\n", 10464 Alignment); 10465 verifyFormat("something = 2000;\n" 10466 "another = 911;\n" 10467 "int i = 1, j = 10;\n" 10468 "oneMore = 1;\n" 10469 "i = 2;", 10470 Alignment); 10471 verifyFormat("int a = 5;\n" 10472 "int one = 1;\n" 10473 "method();\n" 10474 "int oneTwoThree = 123;\n" 10475 "int oneTwo = 12;", 10476 Alignment); 10477 verifyFormat("int oneTwoThree = 123;\n" 10478 "int oneTwo = 12;\n" 10479 "method();\n", 10480 Alignment); 10481 verifyFormat("int oneTwoThree = 123; // comment\n" 10482 "int oneTwo = 12; // comment", 10483 Alignment); 10484 EXPECT_EQ("int a = 5;\n" 10485 "\n" 10486 "int oneTwoThree = 123;", 10487 format("int a = 5;\n" 10488 "\n" 10489 "int oneTwoThree= 123;", 10490 Alignment)); 10491 EXPECT_EQ("int a = 5;\n" 10492 "int one = 1;\n" 10493 "\n" 10494 "int oneTwoThree = 123;", 10495 format("int a = 5;\n" 10496 "int one = 1;\n" 10497 "\n" 10498 "int oneTwoThree = 123;", 10499 Alignment)); 10500 EXPECT_EQ("int a = 5;\n" 10501 "int one = 1;\n" 10502 "\n" 10503 "int oneTwoThree = 123;\n" 10504 "int oneTwo = 12;", 10505 format("int a = 5;\n" 10506 "int one = 1;\n" 10507 "\n" 10508 "int oneTwoThree = 123;\n" 10509 "int oneTwo = 12;", 10510 Alignment)); 10511 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign; 10512 verifyFormat("#define A \\\n" 10513 " int aaaa = 12; \\\n" 10514 " int b = 23; \\\n" 10515 " int ccc = 234; \\\n" 10516 " int dddddddddd = 2345;", 10517 Alignment); 10518 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left; 10519 verifyFormat("#define A \\\n" 10520 " int aaaa = 12; \\\n" 10521 " int b = 23; \\\n" 10522 " int ccc = 234; \\\n" 10523 " int dddddddddd = 2345;", 10524 Alignment); 10525 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right; 10526 verifyFormat("#define A " 10527 " \\\n" 10528 " int aaaa = 12; " 10529 " \\\n" 10530 " int b = 23; " 10531 " \\\n" 10532 " int ccc = 234; " 10533 " \\\n" 10534 " int dddddddddd = 2345;", 10535 Alignment); 10536 verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int " 10537 "k = 4, int l = 5,\n" 10538 " int m = 6) {\n" 10539 " int j = 10;\n" 10540 " otherThing = 1;\n" 10541 "}", 10542 Alignment); 10543 verifyFormat("void SomeFunction(int parameter = 0) {\n" 10544 " int i = 1;\n" 10545 " int j = 2;\n" 10546 " int big = 10000;\n" 10547 "}", 10548 Alignment); 10549 verifyFormat("class C {\n" 10550 "public:\n" 10551 " int i = 1;\n" 10552 " virtual void f() = 0;\n" 10553 "};", 10554 Alignment); 10555 verifyFormat("int i = 1;\n" 10556 "if (SomeType t = getSomething()) {\n" 10557 "}\n" 10558 "int j = 2;\n" 10559 "int big = 10000;", 10560 Alignment); 10561 verifyFormat("int j = 7;\n" 10562 "for (int k = 0; k < N; ++k) {\n" 10563 "}\n" 10564 "int j = 2;\n" 10565 "int big = 10000;\n" 10566 "}", 10567 Alignment); 10568 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 10569 verifyFormat("int i = 1;\n" 10570 "LooooooooooongType loooooooooooooooooooooongVariable\n" 10571 " = someLooooooooooooooooongFunction();\n" 10572 "int j = 2;", 10573 Alignment); 10574 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 10575 verifyFormat("int i = 1;\n" 10576 "LooooooooooongType loooooooooooooooooooooongVariable =\n" 10577 " someLooooooooooooooooongFunction();\n" 10578 "int j = 2;", 10579 Alignment); 10580 10581 verifyFormat("auto lambda = []() {\n" 10582 " auto i = 0;\n" 10583 " return 0;\n" 10584 "};\n" 10585 "int i = 0;\n" 10586 "auto v = type{\n" 10587 " i = 1, //\n" 10588 " (i = 2), //\n" 10589 " i = 3 //\n" 10590 "};", 10591 Alignment); 10592 10593 verifyFormat( 10594 "int i = 1;\n" 10595 "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n" 10596 " loooooooooooooooooooooongParameterB);\n" 10597 "int j = 2;", 10598 Alignment); 10599 10600 verifyFormat("template <typename T, typename T_0 = very_long_type_name_0,\n" 10601 " typename B = very_long_type_name_1,\n" 10602 " typename T_2 = very_long_type_name_2>\n" 10603 "auto foo() {}\n", 10604 Alignment); 10605 verifyFormat("int a, b = 1;\n" 10606 "int c = 2;\n" 10607 "int dd = 3;\n", 10608 Alignment); 10609 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n" 10610 "float b[1][] = {{3.f}};\n", 10611 Alignment); 10612 verifyFormat("for (int i = 0; i < 1; i++)\n" 10613 " int x = 1;\n", 10614 Alignment); 10615 verifyFormat("for (i = 0; i < 1; i++)\n" 10616 " x = 1;\n" 10617 "y = 1;\n", 10618 Alignment); 10619 } 10620 10621 TEST_F(FormatTest, AlignConsecutiveDeclarations) { 10622 FormatStyle Alignment = getLLVMStyle(); 10623 Alignment.AlignConsecutiveMacros = true; 10624 Alignment.AlignConsecutiveDeclarations = false; 10625 verifyFormat("float const a = 5;\n" 10626 "int oneTwoThree = 123;", 10627 Alignment); 10628 verifyFormat("int a = 5;\n" 10629 "float const oneTwoThree = 123;", 10630 Alignment); 10631 10632 Alignment.AlignConsecutiveDeclarations = true; 10633 verifyFormat("float const a = 5;\n" 10634 "int oneTwoThree = 123;", 10635 Alignment); 10636 verifyFormat("int a = method();\n" 10637 "float const oneTwoThree = 133;", 10638 Alignment); 10639 verifyFormat("int i = 1, j = 10;\n" 10640 "something = 2000;", 10641 Alignment); 10642 verifyFormat("something = 2000;\n" 10643 "int i = 1, j = 10;\n", 10644 Alignment); 10645 verifyFormat("float something = 2000;\n" 10646 "double another = 911;\n" 10647 "int i = 1, j = 10;\n" 10648 "const int *oneMore = 1;\n" 10649 "unsigned i = 2;", 10650 Alignment); 10651 verifyFormat("float a = 5;\n" 10652 "int one = 1;\n" 10653 "method();\n" 10654 "const double oneTwoThree = 123;\n" 10655 "const unsigned int oneTwo = 12;", 10656 Alignment); 10657 verifyFormat("int oneTwoThree{0}; // comment\n" 10658 "unsigned oneTwo; // comment", 10659 Alignment); 10660 EXPECT_EQ("float const a = 5;\n" 10661 "\n" 10662 "int oneTwoThree = 123;", 10663 format("float const a = 5;\n" 10664 "\n" 10665 "int oneTwoThree= 123;", 10666 Alignment)); 10667 EXPECT_EQ("float a = 5;\n" 10668 "int one = 1;\n" 10669 "\n" 10670 "unsigned oneTwoThree = 123;", 10671 format("float a = 5;\n" 10672 "int one = 1;\n" 10673 "\n" 10674 "unsigned oneTwoThree = 123;", 10675 Alignment)); 10676 EXPECT_EQ("float a = 5;\n" 10677 "int one = 1;\n" 10678 "\n" 10679 "unsigned oneTwoThree = 123;\n" 10680 "int oneTwo = 12;", 10681 format("float a = 5;\n" 10682 "int one = 1;\n" 10683 "\n" 10684 "unsigned oneTwoThree = 123;\n" 10685 "int oneTwo = 12;", 10686 Alignment)); 10687 // Function prototype alignment 10688 verifyFormat("int a();\n" 10689 "double b();", 10690 Alignment); 10691 verifyFormat("int a(int x);\n" 10692 "double b();", 10693 Alignment); 10694 unsigned OldColumnLimit = Alignment.ColumnLimit; 10695 // We need to set ColumnLimit to zero, in order to stress nested alignments, 10696 // otherwise the function parameters will be re-flowed onto a single line. 10697 Alignment.ColumnLimit = 0; 10698 EXPECT_EQ("int a(int x,\n" 10699 " float y);\n" 10700 "double b(int x,\n" 10701 " double y);", 10702 format("int a(int x,\n" 10703 " float y);\n" 10704 "double b(int x,\n" 10705 " double y);", 10706 Alignment)); 10707 // This ensures that function parameters of function declarations are 10708 // correctly indented when their owning functions are indented. 10709 // The failure case here is for 'double y' to not be indented enough. 10710 EXPECT_EQ("double a(int x);\n" 10711 "int b(int y,\n" 10712 " double z);", 10713 format("double a(int x);\n" 10714 "int b(int y,\n" 10715 " double z);", 10716 Alignment)); 10717 // Set ColumnLimit low so that we induce wrapping immediately after 10718 // the function name and opening paren. 10719 Alignment.ColumnLimit = 13; 10720 verifyFormat("int function(\n" 10721 " int x,\n" 10722 " bool y);", 10723 Alignment); 10724 Alignment.ColumnLimit = OldColumnLimit; 10725 // Ensure function pointers don't screw up recursive alignment 10726 verifyFormat("int a(int x, void (*fp)(int y));\n" 10727 "double b();", 10728 Alignment); 10729 Alignment.AlignConsecutiveAssignments = true; 10730 // Ensure recursive alignment is broken by function braces, so that the 10731 // "a = 1" does not align with subsequent assignments inside the function 10732 // body. 10733 verifyFormat("int func(int a = 1) {\n" 10734 " int b = 2;\n" 10735 " int cc = 3;\n" 10736 "}", 10737 Alignment); 10738 verifyFormat("float something = 2000;\n" 10739 "double another = 911;\n" 10740 "int i = 1, j = 10;\n" 10741 "const int *oneMore = 1;\n" 10742 "unsigned i = 2;", 10743 Alignment); 10744 verifyFormat("int oneTwoThree = {0}; // comment\n" 10745 "unsigned oneTwo = 0; // comment", 10746 Alignment); 10747 // Make sure that scope is correctly tracked, in the absence of braces 10748 verifyFormat("for (int i = 0; i < n; i++)\n" 10749 " j = i;\n" 10750 "double x = 1;\n", 10751 Alignment); 10752 verifyFormat("if (int i = 0)\n" 10753 " j = i;\n" 10754 "double x = 1;\n", 10755 Alignment); 10756 // Ensure operator[] and operator() are comprehended 10757 verifyFormat("struct test {\n" 10758 " long long int foo();\n" 10759 " int operator[](int a);\n" 10760 " double bar();\n" 10761 "};\n", 10762 Alignment); 10763 verifyFormat("struct test {\n" 10764 " long long int foo();\n" 10765 " int operator()(int a);\n" 10766 " double bar();\n" 10767 "};\n", 10768 Alignment); 10769 EXPECT_EQ("void SomeFunction(int parameter = 0) {\n" 10770 " int const i = 1;\n" 10771 " int * j = 2;\n" 10772 " int big = 10000;\n" 10773 "\n" 10774 " unsigned oneTwoThree = 123;\n" 10775 " int oneTwo = 12;\n" 10776 " method();\n" 10777 " float k = 2;\n" 10778 " int ll = 10000;\n" 10779 "}", 10780 format("void SomeFunction(int parameter= 0) {\n" 10781 " int const i= 1;\n" 10782 " int *j=2;\n" 10783 " int big = 10000;\n" 10784 "\n" 10785 "unsigned oneTwoThree =123;\n" 10786 "int oneTwo = 12;\n" 10787 " method();\n" 10788 "float k= 2;\n" 10789 "int ll=10000;\n" 10790 "}", 10791 Alignment)); 10792 Alignment.AlignConsecutiveAssignments = false; 10793 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign; 10794 verifyFormat("#define A \\\n" 10795 " int aaaa = 12; \\\n" 10796 " float b = 23; \\\n" 10797 " const int ccc = 234; \\\n" 10798 " unsigned dddddddddd = 2345;", 10799 Alignment); 10800 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left; 10801 verifyFormat("#define A \\\n" 10802 " int aaaa = 12; \\\n" 10803 " float b = 23; \\\n" 10804 " const int ccc = 234; \\\n" 10805 " unsigned dddddddddd = 2345;", 10806 Alignment); 10807 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right; 10808 Alignment.ColumnLimit = 30; 10809 verifyFormat("#define A \\\n" 10810 " int aaaa = 12; \\\n" 10811 " float b = 23; \\\n" 10812 " const int ccc = 234; \\\n" 10813 " int dddddddddd = 2345;", 10814 Alignment); 10815 Alignment.ColumnLimit = 80; 10816 verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int " 10817 "k = 4, int l = 5,\n" 10818 " int m = 6) {\n" 10819 " const int j = 10;\n" 10820 " otherThing = 1;\n" 10821 "}", 10822 Alignment); 10823 verifyFormat("void SomeFunction(int parameter = 0) {\n" 10824 " int const i = 1;\n" 10825 " int * j = 2;\n" 10826 " int big = 10000;\n" 10827 "}", 10828 Alignment); 10829 verifyFormat("class C {\n" 10830 "public:\n" 10831 " int i = 1;\n" 10832 " virtual void f() = 0;\n" 10833 "};", 10834 Alignment); 10835 verifyFormat("float i = 1;\n" 10836 "if (SomeType t = getSomething()) {\n" 10837 "}\n" 10838 "const unsigned j = 2;\n" 10839 "int big = 10000;", 10840 Alignment); 10841 verifyFormat("float j = 7;\n" 10842 "for (int k = 0; k < N; ++k) {\n" 10843 "}\n" 10844 "unsigned j = 2;\n" 10845 "int big = 10000;\n" 10846 "}", 10847 Alignment); 10848 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 10849 verifyFormat("float i = 1;\n" 10850 "LooooooooooongType loooooooooooooooooooooongVariable\n" 10851 " = someLooooooooooooooooongFunction();\n" 10852 "int j = 2;", 10853 Alignment); 10854 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 10855 verifyFormat("int i = 1;\n" 10856 "LooooooooooongType loooooooooooooooooooooongVariable =\n" 10857 " someLooooooooooooooooongFunction();\n" 10858 "int j = 2;", 10859 Alignment); 10860 10861 Alignment.AlignConsecutiveAssignments = true; 10862 verifyFormat("auto lambda = []() {\n" 10863 " auto ii = 0;\n" 10864 " float j = 0;\n" 10865 " return 0;\n" 10866 "};\n" 10867 "int i = 0;\n" 10868 "float i2 = 0;\n" 10869 "auto v = type{\n" 10870 " i = 1, //\n" 10871 " (i = 2), //\n" 10872 " i = 3 //\n" 10873 "};", 10874 Alignment); 10875 Alignment.AlignConsecutiveAssignments = false; 10876 10877 verifyFormat( 10878 "int i = 1;\n" 10879 "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n" 10880 " loooooooooooooooooooooongParameterB);\n" 10881 "int j = 2;", 10882 Alignment); 10883 10884 // Test interactions with ColumnLimit and AlignConsecutiveAssignments: 10885 // We expect declarations and assignments to align, as long as it doesn't 10886 // exceed the column limit, starting a new alignment sequence whenever it 10887 // happens. 10888 Alignment.AlignConsecutiveAssignments = true; 10889 Alignment.ColumnLimit = 30; 10890 verifyFormat("float ii = 1;\n" 10891 "unsigned j = 2;\n" 10892 "int someVerylongVariable = 1;\n" 10893 "AnotherLongType ll = 123456;\n" 10894 "VeryVeryLongType k = 2;\n" 10895 "int myvar = 1;", 10896 Alignment); 10897 Alignment.ColumnLimit = 80; 10898 Alignment.AlignConsecutiveAssignments = false; 10899 10900 verifyFormat( 10901 "template <typename LongTemplate, typename VeryLongTemplateTypeName,\n" 10902 " typename LongType, typename B>\n" 10903 "auto foo() {}\n", 10904 Alignment); 10905 verifyFormat("float a, b = 1;\n" 10906 "int c = 2;\n" 10907 "int dd = 3;\n", 10908 Alignment); 10909 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n" 10910 "float b[1][] = {{3.f}};\n", 10911 Alignment); 10912 Alignment.AlignConsecutiveAssignments = true; 10913 verifyFormat("float a, b = 1;\n" 10914 "int c = 2;\n" 10915 "int dd = 3;\n", 10916 Alignment); 10917 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n" 10918 "float b[1][] = {{3.f}};\n", 10919 Alignment); 10920 Alignment.AlignConsecutiveAssignments = false; 10921 10922 Alignment.ColumnLimit = 30; 10923 Alignment.BinPackParameters = false; 10924 verifyFormat("void foo(float a,\n" 10925 " float b,\n" 10926 " int c,\n" 10927 " uint32_t *d) {\n" 10928 " int * e = 0;\n" 10929 " float f = 0;\n" 10930 " double g = 0;\n" 10931 "}\n" 10932 "void bar(ino_t a,\n" 10933 " int b,\n" 10934 " uint32_t *c,\n" 10935 " bool d) {}\n", 10936 Alignment); 10937 Alignment.BinPackParameters = true; 10938 Alignment.ColumnLimit = 80; 10939 10940 // Bug 33507 10941 Alignment.PointerAlignment = FormatStyle::PAS_Middle; 10942 verifyFormat( 10943 "auto found = range::find_if(vsProducts, [&](auto * aProduct) {\n" 10944 " static const Version verVs2017;\n" 10945 " return true;\n" 10946 "});\n", 10947 Alignment); 10948 Alignment.PointerAlignment = FormatStyle::PAS_Right; 10949 10950 // See llvm.org/PR35641 10951 Alignment.AlignConsecutiveDeclarations = true; 10952 verifyFormat("int func() { //\n" 10953 " int b;\n" 10954 " unsigned c;\n" 10955 "}", 10956 Alignment); 10957 10958 // See PR37175 10959 FormatStyle Style = getMozillaStyle(); 10960 Style.AlignConsecutiveDeclarations = true; 10961 EXPECT_EQ("DECOR1 /**/ int8_t /**/ DECOR2 /**/\n" 10962 "foo(int a);", 10963 format("DECOR1 /**/ int8_t /**/ DECOR2 /**/ foo (int a);", Style)); 10964 } 10965 10966 TEST_F(FormatTest, LinuxBraceBreaking) { 10967 FormatStyle LinuxBraceStyle = getLLVMStyle(); 10968 LinuxBraceStyle.BreakBeforeBraces = FormatStyle::BS_Linux; 10969 verifyFormat("namespace a\n" 10970 "{\n" 10971 "class A\n" 10972 "{\n" 10973 " void f()\n" 10974 " {\n" 10975 " if (true) {\n" 10976 " a();\n" 10977 " b();\n" 10978 " } else {\n" 10979 " a();\n" 10980 " }\n" 10981 " }\n" 10982 " void g() { return; }\n" 10983 "};\n" 10984 "struct B {\n" 10985 " int x;\n" 10986 "};\n" 10987 "} // namespace a\n", 10988 LinuxBraceStyle); 10989 verifyFormat("enum X {\n" 10990 " Y = 0,\n" 10991 "}\n", 10992 LinuxBraceStyle); 10993 verifyFormat("struct S {\n" 10994 " int Type;\n" 10995 " union {\n" 10996 " int x;\n" 10997 " double y;\n" 10998 " } Value;\n" 10999 " class C\n" 11000 " {\n" 11001 " MyFavoriteType Value;\n" 11002 " } Class;\n" 11003 "}\n", 11004 LinuxBraceStyle); 11005 } 11006 11007 TEST_F(FormatTest, MozillaBraceBreaking) { 11008 FormatStyle MozillaBraceStyle = getLLVMStyle(); 11009 MozillaBraceStyle.BreakBeforeBraces = FormatStyle::BS_Mozilla; 11010 MozillaBraceStyle.FixNamespaceComments = false; 11011 verifyFormat("namespace a {\n" 11012 "class A\n" 11013 "{\n" 11014 " void f()\n" 11015 " {\n" 11016 " if (true) {\n" 11017 " a();\n" 11018 " b();\n" 11019 " }\n" 11020 " }\n" 11021 " void g() { return; }\n" 11022 "};\n" 11023 "enum E\n" 11024 "{\n" 11025 " A,\n" 11026 " // foo\n" 11027 " B,\n" 11028 " C\n" 11029 "};\n" 11030 "struct B\n" 11031 "{\n" 11032 " int x;\n" 11033 "};\n" 11034 "}\n", 11035 MozillaBraceStyle); 11036 verifyFormat("struct S\n" 11037 "{\n" 11038 " int Type;\n" 11039 " union\n" 11040 " {\n" 11041 " int x;\n" 11042 " double y;\n" 11043 " } Value;\n" 11044 " class C\n" 11045 " {\n" 11046 " MyFavoriteType Value;\n" 11047 " } Class;\n" 11048 "}\n", 11049 MozillaBraceStyle); 11050 } 11051 11052 TEST_F(FormatTest, StroustrupBraceBreaking) { 11053 FormatStyle StroustrupBraceStyle = getLLVMStyle(); 11054 StroustrupBraceStyle.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 11055 verifyFormat("namespace a {\n" 11056 "class A {\n" 11057 " void f()\n" 11058 " {\n" 11059 " if (true) {\n" 11060 " a();\n" 11061 " b();\n" 11062 " }\n" 11063 " }\n" 11064 " void g() { return; }\n" 11065 "};\n" 11066 "struct B {\n" 11067 " int x;\n" 11068 "};\n" 11069 "} // namespace a\n", 11070 StroustrupBraceStyle); 11071 11072 verifyFormat("void foo()\n" 11073 "{\n" 11074 " if (a) {\n" 11075 " a();\n" 11076 " }\n" 11077 " else {\n" 11078 " b();\n" 11079 " }\n" 11080 "}\n", 11081 StroustrupBraceStyle); 11082 11083 verifyFormat("#ifdef _DEBUG\n" 11084 "int foo(int i = 0)\n" 11085 "#else\n" 11086 "int foo(int i = 5)\n" 11087 "#endif\n" 11088 "{\n" 11089 " return i;\n" 11090 "}", 11091 StroustrupBraceStyle); 11092 11093 verifyFormat("void foo() {}\n" 11094 "void bar()\n" 11095 "#ifdef _DEBUG\n" 11096 "{\n" 11097 " foo();\n" 11098 "}\n" 11099 "#else\n" 11100 "{\n" 11101 "}\n" 11102 "#endif", 11103 StroustrupBraceStyle); 11104 11105 verifyFormat("void foobar() { int i = 5; }\n" 11106 "#ifdef _DEBUG\n" 11107 "void bar() {}\n" 11108 "#else\n" 11109 "void bar() { foobar(); }\n" 11110 "#endif", 11111 StroustrupBraceStyle); 11112 } 11113 11114 TEST_F(FormatTest, AllmanBraceBreaking) { 11115 FormatStyle AllmanBraceStyle = getLLVMStyle(); 11116 AllmanBraceStyle.BreakBeforeBraces = FormatStyle::BS_Allman; 11117 11118 EXPECT_EQ("namespace a\n" 11119 "{\n" 11120 "void f();\n" 11121 "void g();\n" 11122 "} // namespace a\n", 11123 format("namespace a\n" 11124 "{\n" 11125 "void f();\n" 11126 "void g();\n" 11127 "}\n", 11128 AllmanBraceStyle)); 11129 11130 verifyFormat("namespace a\n" 11131 "{\n" 11132 "class A\n" 11133 "{\n" 11134 " void f()\n" 11135 " {\n" 11136 " if (true)\n" 11137 " {\n" 11138 " a();\n" 11139 " b();\n" 11140 " }\n" 11141 " }\n" 11142 " void g() { return; }\n" 11143 "};\n" 11144 "struct B\n" 11145 "{\n" 11146 " int x;\n" 11147 "};\n" 11148 "union C\n" 11149 "{\n" 11150 "};\n" 11151 "} // namespace a", 11152 AllmanBraceStyle); 11153 11154 verifyFormat("void f()\n" 11155 "{\n" 11156 " if (true)\n" 11157 " {\n" 11158 " a();\n" 11159 " }\n" 11160 " else if (false)\n" 11161 " {\n" 11162 " b();\n" 11163 " }\n" 11164 " else\n" 11165 " {\n" 11166 " c();\n" 11167 " }\n" 11168 "}\n", 11169 AllmanBraceStyle); 11170 11171 verifyFormat("void f()\n" 11172 "{\n" 11173 " for (int i = 0; i < 10; ++i)\n" 11174 " {\n" 11175 " a();\n" 11176 " }\n" 11177 " while (false)\n" 11178 " {\n" 11179 " b();\n" 11180 " }\n" 11181 " do\n" 11182 " {\n" 11183 " c();\n" 11184 " } while (false)\n" 11185 "}\n", 11186 AllmanBraceStyle); 11187 11188 verifyFormat("void f(int a)\n" 11189 "{\n" 11190 " switch (a)\n" 11191 " {\n" 11192 " case 0:\n" 11193 " break;\n" 11194 " case 1:\n" 11195 " {\n" 11196 " break;\n" 11197 " }\n" 11198 " case 2:\n" 11199 " {\n" 11200 " }\n" 11201 " break;\n" 11202 " default:\n" 11203 " break;\n" 11204 " }\n" 11205 "}\n", 11206 AllmanBraceStyle); 11207 11208 verifyFormat("enum X\n" 11209 "{\n" 11210 " Y = 0,\n" 11211 "}\n", 11212 AllmanBraceStyle); 11213 verifyFormat("enum X\n" 11214 "{\n" 11215 " Y = 0\n" 11216 "}\n", 11217 AllmanBraceStyle); 11218 11219 verifyFormat("@interface BSApplicationController ()\n" 11220 "{\n" 11221 "@private\n" 11222 " id _extraIvar;\n" 11223 "}\n" 11224 "@end\n", 11225 AllmanBraceStyle); 11226 11227 verifyFormat("#ifdef _DEBUG\n" 11228 "int foo(int i = 0)\n" 11229 "#else\n" 11230 "int foo(int i = 5)\n" 11231 "#endif\n" 11232 "{\n" 11233 " return i;\n" 11234 "}", 11235 AllmanBraceStyle); 11236 11237 verifyFormat("void foo() {}\n" 11238 "void bar()\n" 11239 "#ifdef _DEBUG\n" 11240 "{\n" 11241 " foo();\n" 11242 "}\n" 11243 "#else\n" 11244 "{\n" 11245 "}\n" 11246 "#endif", 11247 AllmanBraceStyle); 11248 11249 verifyFormat("void foobar() { int i = 5; }\n" 11250 "#ifdef _DEBUG\n" 11251 "void bar() {}\n" 11252 "#else\n" 11253 "void bar() { foobar(); }\n" 11254 "#endif", 11255 AllmanBraceStyle); 11256 11257 // This shouldn't affect ObjC blocks.. 11258 verifyFormat("[self doSomeThingWithACompletionHandler:^{\n" 11259 " // ...\n" 11260 " int i;\n" 11261 "}];", 11262 AllmanBraceStyle); 11263 verifyFormat("void (^block)(void) = ^{\n" 11264 " // ...\n" 11265 " int i;\n" 11266 "};", 11267 AllmanBraceStyle); 11268 // .. or dict literals. 11269 verifyFormat("void f()\n" 11270 "{\n" 11271 " // ...\n" 11272 " [object someMethod:@{@\"a\" : @\"b\"}];\n" 11273 "}", 11274 AllmanBraceStyle); 11275 verifyFormat("void f()\n" 11276 "{\n" 11277 " // ...\n" 11278 " [object someMethod:@{a : @\"b\"}];\n" 11279 "}", 11280 AllmanBraceStyle); 11281 verifyFormat("int f()\n" 11282 "{ // comment\n" 11283 " return 42;\n" 11284 "}", 11285 AllmanBraceStyle); 11286 11287 AllmanBraceStyle.ColumnLimit = 19; 11288 verifyFormat("void f() { int i; }", AllmanBraceStyle); 11289 AllmanBraceStyle.ColumnLimit = 18; 11290 verifyFormat("void f()\n" 11291 "{\n" 11292 " int i;\n" 11293 "}", 11294 AllmanBraceStyle); 11295 AllmanBraceStyle.ColumnLimit = 80; 11296 11297 FormatStyle BreakBeforeBraceShortIfs = AllmanBraceStyle; 11298 BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine = 11299 FormatStyle::SIS_WithoutElse; 11300 BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true; 11301 verifyFormat("void f(bool b)\n" 11302 "{\n" 11303 " if (b)\n" 11304 " {\n" 11305 " return;\n" 11306 " }\n" 11307 "}\n", 11308 BreakBeforeBraceShortIfs); 11309 verifyFormat("void f(bool b)\n" 11310 "{\n" 11311 " if constexpr (b)\n" 11312 " {\n" 11313 " return;\n" 11314 " }\n" 11315 "}\n", 11316 BreakBeforeBraceShortIfs); 11317 verifyFormat("void f(bool b)\n" 11318 "{\n" 11319 " if CONSTEXPR (b)\n" 11320 " {\n" 11321 " return;\n" 11322 " }\n" 11323 "}\n", 11324 BreakBeforeBraceShortIfs); 11325 verifyFormat("void f(bool b)\n" 11326 "{\n" 11327 " if (b) return;\n" 11328 "}\n", 11329 BreakBeforeBraceShortIfs); 11330 verifyFormat("void f(bool b)\n" 11331 "{\n" 11332 " if constexpr (b) return;\n" 11333 "}\n", 11334 BreakBeforeBraceShortIfs); 11335 verifyFormat("void f(bool b)\n" 11336 "{\n" 11337 " if CONSTEXPR (b) return;\n" 11338 "}\n", 11339 BreakBeforeBraceShortIfs); 11340 verifyFormat("void f(bool b)\n" 11341 "{\n" 11342 " while (b)\n" 11343 " {\n" 11344 " return;\n" 11345 " }\n" 11346 "}\n", 11347 BreakBeforeBraceShortIfs); 11348 } 11349 11350 TEST_F(FormatTest, GNUBraceBreaking) { 11351 FormatStyle GNUBraceStyle = getLLVMStyle(); 11352 GNUBraceStyle.BreakBeforeBraces = FormatStyle::BS_GNU; 11353 verifyFormat("namespace a\n" 11354 "{\n" 11355 "class A\n" 11356 "{\n" 11357 " void f()\n" 11358 " {\n" 11359 " int a;\n" 11360 " {\n" 11361 " int b;\n" 11362 " }\n" 11363 " if (true)\n" 11364 " {\n" 11365 " a();\n" 11366 " b();\n" 11367 " }\n" 11368 " }\n" 11369 " void g() { return; }\n" 11370 "}\n" 11371 "} // namespace a", 11372 GNUBraceStyle); 11373 11374 verifyFormat("void f()\n" 11375 "{\n" 11376 " if (true)\n" 11377 " {\n" 11378 " a();\n" 11379 " }\n" 11380 " else if (false)\n" 11381 " {\n" 11382 " b();\n" 11383 " }\n" 11384 " else\n" 11385 " {\n" 11386 " c();\n" 11387 " }\n" 11388 "}\n", 11389 GNUBraceStyle); 11390 11391 verifyFormat("void f()\n" 11392 "{\n" 11393 " for (int i = 0; i < 10; ++i)\n" 11394 " {\n" 11395 " a();\n" 11396 " }\n" 11397 " while (false)\n" 11398 " {\n" 11399 " b();\n" 11400 " }\n" 11401 " do\n" 11402 " {\n" 11403 " c();\n" 11404 " }\n" 11405 " while (false);\n" 11406 "}\n", 11407 GNUBraceStyle); 11408 11409 verifyFormat("void f(int a)\n" 11410 "{\n" 11411 " switch (a)\n" 11412 " {\n" 11413 " case 0:\n" 11414 " break;\n" 11415 " case 1:\n" 11416 " {\n" 11417 " break;\n" 11418 " }\n" 11419 " case 2:\n" 11420 " {\n" 11421 " }\n" 11422 " break;\n" 11423 " default:\n" 11424 " break;\n" 11425 " }\n" 11426 "}\n", 11427 GNUBraceStyle); 11428 11429 verifyFormat("enum X\n" 11430 "{\n" 11431 " Y = 0,\n" 11432 "}\n", 11433 GNUBraceStyle); 11434 11435 verifyFormat("@interface BSApplicationController ()\n" 11436 "{\n" 11437 "@private\n" 11438 " id _extraIvar;\n" 11439 "}\n" 11440 "@end\n", 11441 GNUBraceStyle); 11442 11443 verifyFormat("#ifdef _DEBUG\n" 11444 "int foo(int i = 0)\n" 11445 "#else\n" 11446 "int foo(int i = 5)\n" 11447 "#endif\n" 11448 "{\n" 11449 " return i;\n" 11450 "}", 11451 GNUBraceStyle); 11452 11453 verifyFormat("void foo() {}\n" 11454 "void bar()\n" 11455 "#ifdef _DEBUG\n" 11456 "{\n" 11457 " foo();\n" 11458 "}\n" 11459 "#else\n" 11460 "{\n" 11461 "}\n" 11462 "#endif", 11463 GNUBraceStyle); 11464 11465 verifyFormat("void foobar() { int i = 5; }\n" 11466 "#ifdef _DEBUG\n" 11467 "void bar() {}\n" 11468 "#else\n" 11469 "void bar() { foobar(); }\n" 11470 "#endif", 11471 GNUBraceStyle); 11472 } 11473 11474 TEST_F(FormatTest, WebKitBraceBreaking) { 11475 FormatStyle WebKitBraceStyle = getLLVMStyle(); 11476 WebKitBraceStyle.BreakBeforeBraces = FormatStyle::BS_WebKit; 11477 WebKitBraceStyle.FixNamespaceComments = false; 11478 verifyFormat("namespace a {\n" 11479 "class A {\n" 11480 " void f()\n" 11481 " {\n" 11482 " if (true) {\n" 11483 " a();\n" 11484 " b();\n" 11485 " }\n" 11486 " }\n" 11487 " void g() { return; }\n" 11488 "};\n" 11489 "enum E {\n" 11490 " A,\n" 11491 " // foo\n" 11492 " B,\n" 11493 " C\n" 11494 "};\n" 11495 "struct B {\n" 11496 " int x;\n" 11497 "};\n" 11498 "}\n", 11499 WebKitBraceStyle); 11500 verifyFormat("struct S {\n" 11501 " int Type;\n" 11502 " union {\n" 11503 " int x;\n" 11504 " double y;\n" 11505 " } Value;\n" 11506 " class C {\n" 11507 " MyFavoriteType Value;\n" 11508 " } Class;\n" 11509 "};\n", 11510 WebKitBraceStyle); 11511 } 11512 11513 TEST_F(FormatTest, CatchExceptionReferenceBinding) { 11514 verifyFormat("void f() {\n" 11515 " try {\n" 11516 " } catch (const Exception &e) {\n" 11517 " }\n" 11518 "}\n", 11519 getLLVMStyle()); 11520 } 11521 11522 TEST_F(FormatTest, UnderstandsPragmas) { 11523 verifyFormat("#pragma omp reduction(| : var)"); 11524 verifyFormat("#pragma omp reduction(+ : var)"); 11525 11526 EXPECT_EQ("#pragma mark Any non-hyphenated or hyphenated string " 11527 "(including parentheses).", 11528 format("#pragma mark Any non-hyphenated or hyphenated string " 11529 "(including parentheses).")); 11530 } 11531 11532 TEST_F(FormatTest, UnderstandPragmaOption) { 11533 verifyFormat("#pragma option -C -A"); 11534 11535 EXPECT_EQ("#pragma option -C -A", format("#pragma option -C -A")); 11536 } 11537 11538 TEST_F(FormatTest, OptimizeBreakPenaltyVsExcess) { 11539 FormatStyle Style = getLLVMStyle(); 11540 Style.ColumnLimit = 20; 11541 11542 // See PR41213 11543 EXPECT_EQ("/*\n" 11544 " *\t9012345\n" 11545 " * /8901\n" 11546 " */", 11547 format("/*\n" 11548 " *\t9012345 /8901\n" 11549 " */", 11550 Style)); 11551 EXPECT_EQ("/*\n" 11552 " *345678\n" 11553 " *\t/8901\n" 11554 " */", 11555 format("/*\n" 11556 " *345678\t/8901\n" 11557 " */", 11558 Style)); 11559 11560 verifyFormat("int a; // the\n" 11561 " // comment", Style); 11562 EXPECT_EQ("int a; /* first line\n" 11563 " * second\n" 11564 " * line third\n" 11565 " * line\n" 11566 " */", 11567 format("int a; /* first line\n" 11568 " * second\n" 11569 " * line third\n" 11570 " * line\n" 11571 " */", 11572 Style)); 11573 EXPECT_EQ("int a; // first line\n" 11574 " // second\n" 11575 " // line third\n" 11576 " // line", 11577 format("int a; // first line\n" 11578 " // second line\n" 11579 " // third line", 11580 Style)); 11581 11582 Style.PenaltyExcessCharacter = 90; 11583 verifyFormat("int a; // the comment", Style); 11584 EXPECT_EQ("int a; // the comment\n" 11585 " // aaa", 11586 format("int a; // the comment aaa", Style)); 11587 EXPECT_EQ("int a; /* first line\n" 11588 " * second line\n" 11589 " * third line\n" 11590 " */", 11591 format("int a; /* first line\n" 11592 " * second line\n" 11593 " * third line\n" 11594 " */", 11595 Style)); 11596 EXPECT_EQ("int a; // first line\n" 11597 " // second line\n" 11598 " // third line", 11599 format("int a; // first line\n" 11600 " // second line\n" 11601 " // third line", 11602 Style)); 11603 // FIXME: Investigate why this is not getting the same layout as the test 11604 // above. 11605 EXPECT_EQ("int a; /* first line\n" 11606 " * second line\n" 11607 " * third line\n" 11608 " */", 11609 format("int a; /* first line second line third line" 11610 "\n*/", 11611 Style)); 11612 11613 EXPECT_EQ("// foo bar baz bazfoo\n" 11614 "// foo bar foo bar\n", 11615 format("// foo bar baz bazfoo\n" 11616 "// foo bar foo bar\n", 11617 Style)); 11618 EXPECT_EQ("// foo bar baz bazfoo\n" 11619 "// foo bar foo bar\n", 11620 format("// foo bar baz bazfoo\n" 11621 "// foo bar foo bar\n", 11622 Style)); 11623 11624 // FIXME: Optimally, we'd keep bazfoo on the first line and reflow bar to the 11625 // next one. 11626 EXPECT_EQ("// foo bar baz bazfoo\n" 11627 "// bar foo bar\n", 11628 format("// foo bar baz bazfoo bar\n" 11629 "// foo bar\n", 11630 Style)); 11631 11632 EXPECT_EQ("// foo bar baz bazfoo\n" 11633 "// foo bar baz bazfoo\n" 11634 "// bar foo bar\n", 11635 format("// foo bar baz bazfoo\n" 11636 "// foo bar baz bazfoo bar\n" 11637 "// foo bar\n", 11638 Style)); 11639 11640 EXPECT_EQ("// foo bar baz bazfoo\n" 11641 "// foo bar baz bazfoo\n" 11642 "// bar foo bar\n", 11643 format("// foo bar baz bazfoo\n" 11644 "// foo bar baz bazfoo bar\n" 11645 "// foo bar\n", 11646 Style)); 11647 11648 // Make sure we do not keep protruding characters if strict mode reflow is 11649 // cheaper than keeping protruding characters. 11650 Style.ColumnLimit = 21; 11651 EXPECT_EQ("// foo foo foo foo\n" 11652 "// foo foo foo foo\n" 11653 "// foo foo foo foo\n", 11654 format("// foo foo foo foo foo foo foo foo foo foo foo foo\n", 11655 Style)); 11656 11657 EXPECT_EQ("int a = /* long block\n" 11658 " comment */\n" 11659 " 42;", 11660 format("int a = /* long block comment */ 42;", Style)); 11661 } 11662 11663 #define EXPECT_ALL_STYLES_EQUAL(Styles) \ 11664 for (size_t i = 1; i < Styles.size(); ++i) \ 11665 EXPECT_EQ(Styles[0], Styles[i]) << "Style #" << i << " of " << Styles.size() \ 11666 << " differs from Style #0" 11667 11668 TEST_F(FormatTest, GetsPredefinedStyleByName) { 11669 SmallVector<FormatStyle, 3> Styles; 11670 Styles.resize(3); 11671 11672 Styles[0] = getLLVMStyle(); 11673 EXPECT_TRUE(getPredefinedStyle("LLVM", FormatStyle::LK_Cpp, &Styles[1])); 11674 EXPECT_TRUE(getPredefinedStyle("lLvM", FormatStyle::LK_Cpp, &Styles[2])); 11675 EXPECT_ALL_STYLES_EQUAL(Styles); 11676 11677 Styles[0] = getGoogleStyle(); 11678 EXPECT_TRUE(getPredefinedStyle("Google", FormatStyle::LK_Cpp, &Styles[1])); 11679 EXPECT_TRUE(getPredefinedStyle("gOOgle", FormatStyle::LK_Cpp, &Styles[2])); 11680 EXPECT_ALL_STYLES_EQUAL(Styles); 11681 11682 Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript); 11683 EXPECT_TRUE( 11684 getPredefinedStyle("Google", FormatStyle::LK_JavaScript, &Styles[1])); 11685 EXPECT_TRUE( 11686 getPredefinedStyle("gOOgle", FormatStyle::LK_JavaScript, &Styles[2])); 11687 EXPECT_ALL_STYLES_EQUAL(Styles); 11688 11689 Styles[0] = getChromiumStyle(FormatStyle::LK_Cpp); 11690 EXPECT_TRUE(getPredefinedStyle("Chromium", FormatStyle::LK_Cpp, &Styles[1])); 11691 EXPECT_TRUE(getPredefinedStyle("cHRoMiUM", FormatStyle::LK_Cpp, &Styles[2])); 11692 EXPECT_ALL_STYLES_EQUAL(Styles); 11693 11694 Styles[0] = getMozillaStyle(); 11695 EXPECT_TRUE(getPredefinedStyle("Mozilla", FormatStyle::LK_Cpp, &Styles[1])); 11696 EXPECT_TRUE(getPredefinedStyle("moZILla", FormatStyle::LK_Cpp, &Styles[2])); 11697 EXPECT_ALL_STYLES_EQUAL(Styles); 11698 11699 Styles[0] = getWebKitStyle(); 11700 EXPECT_TRUE(getPredefinedStyle("WebKit", FormatStyle::LK_Cpp, &Styles[1])); 11701 EXPECT_TRUE(getPredefinedStyle("wEbKit", FormatStyle::LK_Cpp, &Styles[2])); 11702 EXPECT_ALL_STYLES_EQUAL(Styles); 11703 11704 Styles[0] = getGNUStyle(); 11705 EXPECT_TRUE(getPredefinedStyle("GNU", FormatStyle::LK_Cpp, &Styles[1])); 11706 EXPECT_TRUE(getPredefinedStyle("gnU", FormatStyle::LK_Cpp, &Styles[2])); 11707 EXPECT_ALL_STYLES_EQUAL(Styles); 11708 11709 EXPECT_FALSE(getPredefinedStyle("qwerty", FormatStyle::LK_Cpp, &Styles[0])); 11710 } 11711 11712 TEST_F(FormatTest, GetsCorrectBasedOnStyle) { 11713 SmallVector<FormatStyle, 8> Styles; 11714 Styles.resize(2); 11715 11716 Styles[0] = getGoogleStyle(); 11717 Styles[1] = getLLVMStyle(); 11718 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value()); 11719 EXPECT_ALL_STYLES_EQUAL(Styles); 11720 11721 Styles.resize(5); 11722 Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript); 11723 Styles[1] = getLLVMStyle(); 11724 Styles[1].Language = FormatStyle::LK_JavaScript; 11725 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value()); 11726 11727 Styles[2] = getLLVMStyle(); 11728 Styles[2].Language = FormatStyle::LK_JavaScript; 11729 EXPECT_EQ(0, parseConfiguration("Language: JavaScript\n" 11730 "BasedOnStyle: Google", 11731 &Styles[2]) 11732 .value()); 11733 11734 Styles[3] = getLLVMStyle(); 11735 Styles[3].Language = FormatStyle::LK_JavaScript; 11736 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google\n" 11737 "Language: JavaScript", 11738 &Styles[3]) 11739 .value()); 11740 11741 Styles[4] = getLLVMStyle(); 11742 Styles[4].Language = FormatStyle::LK_JavaScript; 11743 EXPECT_EQ(0, parseConfiguration("---\n" 11744 "BasedOnStyle: LLVM\n" 11745 "IndentWidth: 123\n" 11746 "---\n" 11747 "BasedOnStyle: Google\n" 11748 "Language: JavaScript", 11749 &Styles[4]) 11750 .value()); 11751 EXPECT_ALL_STYLES_EQUAL(Styles); 11752 } 11753 11754 #define CHECK_PARSE_BOOL_FIELD(FIELD, CONFIG_NAME) \ 11755 Style.FIELD = false; \ 11756 EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": true", &Style).value()); \ 11757 EXPECT_TRUE(Style.FIELD); \ 11758 EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": false", &Style).value()); \ 11759 EXPECT_FALSE(Style.FIELD); 11760 11761 #define CHECK_PARSE_BOOL(FIELD) CHECK_PARSE_BOOL_FIELD(FIELD, #FIELD) 11762 11763 #define CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, CONFIG_NAME) \ 11764 Style.STRUCT.FIELD = false; \ 11765 EXPECT_EQ(0, \ 11766 parseConfiguration(#STRUCT ":\n " CONFIG_NAME ": true", &Style) \ 11767 .value()); \ 11768 EXPECT_TRUE(Style.STRUCT.FIELD); \ 11769 EXPECT_EQ(0, \ 11770 parseConfiguration(#STRUCT ":\n " CONFIG_NAME ": false", &Style) \ 11771 .value()); \ 11772 EXPECT_FALSE(Style.STRUCT.FIELD); 11773 11774 #define CHECK_PARSE_NESTED_BOOL(STRUCT, FIELD) \ 11775 CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, #FIELD) 11776 11777 #define CHECK_PARSE(TEXT, FIELD, VALUE) \ 11778 EXPECT_NE(VALUE, Style.FIELD); \ 11779 EXPECT_EQ(0, parseConfiguration(TEXT, &Style).value()); \ 11780 EXPECT_EQ(VALUE, Style.FIELD) 11781 11782 TEST_F(FormatTest, ParsesConfigurationBools) { 11783 FormatStyle Style = {}; 11784 Style.Language = FormatStyle::LK_Cpp; 11785 CHECK_PARSE_BOOL(AlignOperands); 11786 CHECK_PARSE_BOOL(AlignTrailingComments); 11787 CHECK_PARSE_BOOL(AlignConsecutiveAssignments); 11788 CHECK_PARSE_BOOL(AlignConsecutiveDeclarations); 11789 CHECK_PARSE_BOOL(AlignConsecutiveMacros); 11790 CHECK_PARSE_BOOL(AllowAllArgumentsOnNextLine); 11791 CHECK_PARSE_BOOL(AllowAllConstructorInitializersOnNextLine); 11792 CHECK_PARSE_BOOL(AllowAllParametersOfDeclarationOnNextLine); 11793 CHECK_PARSE_BOOL(AllowShortCaseLabelsOnASingleLine); 11794 CHECK_PARSE_BOOL(AllowShortLoopsOnASingleLine); 11795 CHECK_PARSE_BOOL(BinPackArguments); 11796 CHECK_PARSE_BOOL(BinPackParameters); 11797 CHECK_PARSE_BOOL(BreakAfterJavaFieldAnnotations); 11798 CHECK_PARSE_BOOL(BreakBeforeTernaryOperators); 11799 CHECK_PARSE_BOOL(BreakStringLiterals); 11800 CHECK_PARSE_BOOL(CompactNamespaces); 11801 CHECK_PARSE_BOOL(ConstructorInitializerAllOnOneLineOrOnePerLine); 11802 CHECK_PARSE_BOOL(DerivePointerAlignment); 11803 CHECK_PARSE_BOOL_FIELD(DerivePointerAlignment, "DerivePointerBinding"); 11804 CHECK_PARSE_BOOL(DisableFormat); 11805 CHECK_PARSE_BOOL(IndentCaseLabels); 11806 CHECK_PARSE_BOOL(IndentGotoLabels); 11807 CHECK_PARSE_BOOL(IndentWrappedFunctionNames); 11808 CHECK_PARSE_BOOL(KeepEmptyLinesAtTheStartOfBlocks); 11809 CHECK_PARSE_BOOL(ObjCSpaceAfterProperty); 11810 CHECK_PARSE_BOOL(ObjCSpaceBeforeProtocolList); 11811 CHECK_PARSE_BOOL(Cpp11BracedListStyle); 11812 CHECK_PARSE_BOOL(ReflowComments); 11813 CHECK_PARSE_BOOL(SortIncludes); 11814 CHECK_PARSE_BOOL(SortUsingDeclarations); 11815 CHECK_PARSE_BOOL(SpacesInParentheses); 11816 CHECK_PARSE_BOOL(SpacesInSquareBrackets); 11817 CHECK_PARSE_BOOL(SpacesInAngles); 11818 CHECK_PARSE_BOOL(SpaceInEmptyBlock); 11819 CHECK_PARSE_BOOL(SpaceInEmptyParentheses); 11820 CHECK_PARSE_BOOL(SpacesInContainerLiterals); 11821 CHECK_PARSE_BOOL(SpacesInCStyleCastParentheses); 11822 CHECK_PARSE_BOOL(SpaceAfterCStyleCast); 11823 CHECK_PARSE_BOOL(SpaceAfterTemplateKeyword); 11824 CHECK_PARSE_BOOL(SpaceAfterLogicalNot); 11825 CHECK_PARSE_BOOL(SpaceBeforeAssignmentOperators); 11826 CHECK_PARSE_BOOL(SpaceBeforeCpp11BracedList); 11827 CHECK_PARSE_BOOL(SpaceBeforeCtorInitializerColon); 11828 CHECK_PARSE_BOOL(SpaceBeforeInheritanceColon); 11829 CHECK_PARSE_BOOL(SpaceBeforeRangeBasedForLoopColon); 11830 11831 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterCaseLabel); 11832 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterClass); 11833 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterControlStatement); 11834 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterEnum); 11835 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterFunction); 11836 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterNamespace); 11837 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterObjCDeclaration); 11838 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterStruct); 11839 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterUnion); 11840 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterExternBlock); 11841 CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeCatch); 11842 CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeElse); 11843 CHECK_PARSE_NESTED_BOOL(BraceWrapping, IndentBraces); 11844 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyFunction); 11845 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyRecord); 11846 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyNamespace); 11847 } 11848 11849 #undef CHECK_PARSE_BOOL 11850 11851 TEST_F(FormatTest, ParsesConfiguration) { 11852 FormatStyle Style = {}; 11853 Style.Language = FormatStyle::LK_Cpp; 11854 CHECK_PARSE("AccessModifierOffset: -1234", AccessModifierOffset, -1234); 11855 CHECK_PARSE("ConstructorInitializerIndentWidth: 1234", 11856 ConstructorInitializerIndentWidth, 1234u); 11857 CHECK_PARSE("ObjCBlockIndentWidth: 1234", ObjCBlockIndentWidth, 1234u); 11858 CHECK_PARSE("ColumnLimit: 1234", ColumnLimit, 1234u); 11859 CHECK_PARSE("MaxEmptyLinesToKeep: 1234", MaxEmptyLinesToKeep, 1234u); 11860 CHECK_PARSE("PenaltyBreakAssignment: 1234", 11861 PenaltyBreakAssignment, 1234u); 11862 CHECK_PARSE("PenaltyBreakBeforeFirstCallParameter: 1234", 11863 PenaltyBreakBeforeFirstCallParameter, 1234u); 11864 CHECK_PARSE("PenaltyBreakTemplateDeclaration: 1234", 11865 PenaltyBreakTemplateDeclaration, 1234u); 11866 CHECK_PARSE("PenaltyExcessCharacter: 1234", PenaltyExcessCharacter, 1234u); 11867 CHECK_PARSE("PenaltyReturnTypeOnItsOwnLine: 1234", 11868 PenaltyReturnTypeOnItsOwnLine, 1234u); 11869 CHECK_PARSE("SpacesBeforeTrailingComments: 1234", 11870 SpacesBeforeTrailingComments, 1234u); 11871 CHECK_PARSE("IndentWidth: 32", IndentWidth, 32u); 11872 CHECK_PARSE("ContinuationIndentWidth: 11", ContinuationIndentWidth, 11u); 11873 CHECK_PARSE("CommentPragmas: '// abc$'", CommentPragmas, "// abc$"); 11874 11875 Style.PointerAlignment = FormatStyle::PAS_Middle; 11876 CHECK_PARSE("PointerAlignment: Left", PointerAlignment, 11877 FormatStyle::PAS_Left); 11878 CHECK_PARSE("PointerAlignment: Right", PointerAlignment, 11879 FormatStyle::PAS_Right); 11880 CHECK_PARSE("PointerAlignment: Middle", PointerAlignment, 11881 FormatStyle::PAS_Middle); 11882 // For backward compatibility: 11883 CHECK_PARSE("PointerBindsToType: Left", PointerAlignment, 11884 FormatStyle::PAS_Left); 11885 CHECK_PARSE("PointerBindsToType: Right", PointerAlignment, 11886 FormatStyle::PAS_Right); 11887 CHECK_PARSE("PointerBindsToType: Middle", PointerAlignment, 11888 FormatStyle::PAS_Middle); 11889 11890 Style.Standard = FormatStyle::LS_Auto; 11891 CHECK_PARSE("Standard: Cpp03", Standard, FormatStyle::LS_Cpp03); 11892 CHECK_PARSE("Standard: Cpp11", Standard, FormatStyle::LS_Cpp11); 11893 CHECK_PARSE("Standard: C++03", Standard, FormatStyle::LS_Cpp03); 11894 CHECK_PARSE("Standard: C++11", Standard, FormatStyle::LS_Cpp11); 11895 CHECK_PARSE("Standard: Auto", Standard, FormatStyle::LS_Auto); 11896 11897 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 11898 CHECK_PARSE("BreakBeforeBinaryOperators: NonAssignment", 11899 BreakBeforeBinaryOperators, FormatStyle::BOS_NonAssignment); 11900 CHECK_PARSE("BreakBeforeBinaryOperators: None", BreakBeforeBinaryOperators, 11901 FormatStyle::BOS_None); 11902 CHECK_PARSE("BreakBeforeBinaryOperators: All", BreakBeforeBinaryOperators, 11903 FormatStyle::BOS_All); 11904 // For backward compatibility: 11905 CHECK_PARSE("BreakBeforeBinaryOperators: false", BreakBeforeBinaryOperators, 11906 FormatStyle::BOS_None); 11907 CHECK_PARSE("BreakBeforeBinaryOperators: true", BreakBeforeBinaryOperators, 11908 FormatStyle::BOS_All); 11909 11910 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon; 11911 CHECK_PARSE("BreakConstructorInitializers: BeforeComma", 11912 BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma); 11913 CHECK_PARSE("BreakConstructorInitializers: AfterColon", 11914 BreakConstructorInitializers, FormatStyle::BCIS_AfterColon); 11915 CHECK_PARSE("BreakConstructorInitializers: BeforeColon", 11916 BreakConstructorInitializers, FormatStyle::BCIS_BeforeColon); 11917 // For backward compatibility: 11918 CHECK_PARSE("BreakConstructorInitializersBeforeComma: true", 11919 BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma); 11920 11921 Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon; 11922 CHECK_PARSE("BreakInheritanceList: BeforeComma", 11923 BreakInheritanceList, FormatStyle::BILS_BeforeComma); 11924 CHECK_PARSE("BreakInheritanceList: AfterColon", 11925 BreakInheritanceList, FormatStyle::BILS_AfterColon); 11926 CHECK_PARSE("BreakInheritanceList: BeforeColon", 11927 BreakInheritanceList, FormatStyle::BILS_BeforeColon); 11928 // For backward compatibility: 11929 CHECK_PARSE("BreakBeforeInheritanceComma: true", 11930 BreakInheritanceList, FormatStyle::BILS_BeforeComma); 11931 11932 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 11933 CHECK_PARSE("AlignAfterOpenBracket: Align", AlignAfterOpenBracket, 11934 FormatStyle::BAS_Align); 11935 CHECK_PARSE("AlignAfterOpenBracket: DontAlign", AlignAfterOpenBracket, 11936 FormatStyle::BAS_DontAlign); 11937 CHECK_PARSE("AlignAfterOpenBracket: AlwaysBreak", AlignAfterOpenBracket, 11938 FormatStyle::BAS_AlwaysBreak); 11939 // For backward compatibility: 11940 CHECK_PARSE("AlignAfterOpenBracket: false", AlignAfterOpenBracket, 11941 FormatStyle::BAS_DontAlign); 11942 CHECK_PARSE("AlignAfterOpenBracket: true", AlignAfterOpenBracket, 11943 FormatStyle::BAS_Align); 11944 11945 Style.AlignEscapedNewlines = FormatStyle::ENAS_Left; 11946 CHECK_PARSE("AlignEscapedNewlines: DontAlign", AlignEscapedNewlines, 11947 FormatStyle::ENAS_DontAlign); 11948 CHECK_PARSE("AlignEscapedNewlines: Left", AlignEscapedNewlines, 11949 FormatStyle::ENAS_Left); 11950 CHECK_PARSE("AlignEscapedNewlines: Right", AlignEscapedNewlines, 11951 FormatStyle::ENAS_Right); 11952 // For backward compatibility: 11953 CHECK_PARSE("AlignEscapedNewlinesLeft: true", AlignEscapedNewlines, 11954 FormatStyle::ENAS_Left); 11955 CHECK_PARSE("AlignEscapedNewlinesLeft: false", AlignEscapedNewlines, 11956 FormatStyle::ENAS_Right); 11957 11958 Style.UseTab = FormatStyle::UT_ForIndentation; 11959 CHECK_PARSE("UseTab: Never", UseTab, FormatStyle::UT_Never); 11960 CHECK_PARSE("UseTab: ForIndentation", UseTab, FormatStyle::UT_ForIndentation); 11961 CHECK_PARSE("UseTab: Always", UseTab, FormatStyle::UT_Always); 11962 CHECK_PARSE("UseTab: ForContinuationAndIndentation", UseTab, 11963 FormatStyle::UT_ForContinuationAndIndentation); 11964 // For backward compatibility: 11965 CHECK_PARSE("UseTab: false", UseTab, FormatStyle::UT_Never); 11966 CHECK_PARSE("UseTab: true", UseTab, FormatStyle::UT_Always); 11967 11968 Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty; 11969 CHECK_PARSE("AllowShortBlocksOnASingleLine: Never", 11970 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never); 11971 CHECK_PARSE("AllowShortBlocksOnASingleLine: Empty", 11972 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Empty); 11973 CHECK_PARSE("AllowShortBlocksOnASingleLine: Always", 11974 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always); 11975 // For backward compatibility: 11976 CHECK_PARSE("AllowShortBlocksOnASingleLine: false", 11977 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never); 11978 CHECK_PARSE("AllowShortBlocksOnASingleLine: true", 11979 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always); 11980 11981 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; 11982 CHECK_PARSE("AllowShortFunctionsOnASingleLine: None", 11983 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None); 11984 CHECK_PARSE("AllowShortFunctionsOnASingleLine: Inline", 11985 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Inline); 11986 CHECK_PARSE("AllowShortFunctionsOnASingleLine: Empty", 11987 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Empty); 11988 CHECK_PARSE("AllowShortFunctionsOnASingleLine: All", 11989 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All); 11990 // For backward compatibility: 11991 CHECK_PARSE("AllowShortFunctionsOnASingleLine: false", 11992 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None); 11993 CHECK_PARSE("AllowShortFunctionsOnASingleLine: true", 11994 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All); 11995 11996 Style.SpaceBeforeParens = FormatStyle::SBPO_Always; 11997 CHECK_PARSE("SpaceBeforeParens: Never", SpaceBeforeParens, 11998 FormatStyle::SBPO_Never); 11999 CHECK_PARSE("SpaceBeforeParens: Always", SpaceBeforeParens, 12000 FormatStyle::SBPO_Always); 12001 CHECK_PARSE("SpaceBeforeParens: ControlStatements", SpaceBeforeParens, 12002 FormatStyle::SBPO_ControlStatements); 12003 CHECK_PARSE("SpaceBeforeParens: NonEmptyParentheses", SpaceBeforeParens, 12004 FormatStyle::SBPO_NonEmptyParentheses); 12005 // For backward compatibility: 12006 CHECK_PARSE("SpaceAfterControlStatementKeyword: false", SpaceBeforeParens, 12007 FormatStyle::SBPO_Never); 12008 CHECK_PARSE("SpaceAfterControlStatementKeyword: true", SpaceBeforeParens, 12009 FormatStyle::SBPO_ControlStatements); 12010 12011 Style.ColumnLimit = 123; 12012 FormatStyle BaseStyle = getLLVMStyle(); 12013 CHECK_PARSE("BasedOnStyle: LLVM", ColumnLimit, BaseStyle.ColumnLimit); 12014 CHECK_PARSE("BasedOnStyle: LLVM\nColumnLimit: 1234", ColumnLimit, 1234u); 12015 12016 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 12017 CHECK_PARSE("BreakBeforeBraces: Attach", BreakBeforeBraces, 12018 FormatStyle::BS_Attach); 12019 CHECK_PARSE("BreakBeforeBraces: Linux", BreakBeforeBraces, 12020 FormatStyle::BS_Linux); 12021 CHECK_PARSE("BreakBeforeBraces: Mozilla", BreakBeforeBraces, 12022 FormatStyle::BS_Mozilla); 12023 CHECK_PARSE("BreakBeforeBraces: Stroustrup", BreakBeforeBraces, 12024 FormatStyle::BS_Stroustrup); 12025 CHECK_PARSE("BreakBeforeBraces: Allman", BreakBeforeBraces, 12026 FormatStyle::BS_Allman); 12027 CHECK_PARSE("BreakBeforeBraces: GNU", BreakBeforeBraces, FormatStyle::BS_GNU); 12028 CHECK_PARSE("BreakBeforeBraces: WebKit", BreakBeforeBraces, 12029 FormatStyle::BS_WebKit); 12030 CHECK_PARSE("BreakBeforeBraces: Custom", BreakBeforeBraces, 12031 FormatStyle::BS_Custom); 12032 12033 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All; 12034 CHECK_PARSE("AlwaysBreakAfterReturnType: None", AlwaysBreakAfterReturnType, 12035 FormatStyle::RTBS_None); 12036 CHECK_PARSE("AlwaysBreakAfterReturnType: All", AlwaysBreakAfterReturnType, 12037 FormatStyle::RTBS_All); 12038 CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevel", 12039 AlwaysBreakAfterReturnType, FormatStyle::RTBS_TopLevel); 12040 CHECK_PARSE("AlwaysBreakAfterReturnType: AllDefinitions", 12041 AlwaysBreakAfterReturnType, FormatStyle::RTBS_AllDefinitions); 12042 CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevelDefinitions", 12043 AlwaysBreakAfterReturnType, 12044 FormatStyle::RTBS_TopLevelDefinitions); 12045 12046 Style.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes; 12047 CHECK_PARSE("AlwaysBreakTemplateDeclarations: No", AlwaysBreakTemplateDeclarations, 12048 FormatStyle::BTDS_No); 12049 CHECK_PARSE("AlwaysBreakTemplateDeclarations: MultiLine", AlwaysBreakTemplateDeclarations, 12050 FormatStyle::BTDS_MultiLine); 12051 CHECK_PARSE("AlwaysBreakTemplateDeclarations: Yes", AlwaysBreakTemplateDeclarations, 12052 FormatStyle::BTDS_Yes); 12053 CHECK_PARSE("AlwaysBreakTemplateDeclarations: false", AlwaysBreakTemplateDeclarations, 12054 FormatStyle::BTDS_MultiLine); 12055 CHECK_PARSE("AlwaysBreakTemplateDeclarations: true", AlwaysBreakTemplateDeclarations, 12056 FormatStyle::BTDS_Yes); 12057 12058 Style.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_All; 12059 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: None", 12060 AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_None); 12061 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: All", 12062 AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_All); 12063 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: TopLevel", 12064 AlwaysBreakAfterDefinitionReturnType, 12065 FormatStyle::DRTBS_TopLevel); 12066 12067 Style.NamespaceIndentation = FormatStyle::NI_All; 12068 CHECK_PARSE("NamespaceIndentation: None", NamespaceIndentation, 12069 FormatStyle::NI_None); 12070 CHECK_PARSE("NamespaceIndentation: Inner", NamespaceIndentation, 12071 FormatStyle::NI_Inner); 12072 CHECK_PARSE("NamespaceIndentation: All", NamespaceIndentation, 12073 FormatStyle::NI_All); 12074 12075 Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Always; 12076 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Never", 12077 AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never); 12078 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: WithoutElse", 12079 AllowShortIfStatementsOnASingleLine, 12080 FormatStyle::SIS_WithoutElse); 12081 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Always", 12082 AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Always); 12083 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: false", 12084 AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never); 12085 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: true", 12086 AllowShortIfStatementsOnASingleLine, 12087 FormatStyle::SIS_WithoutElse); 12088 12089 // FIXME: This is required because parsing a configuration simply overwrites 12090 // the first N elements of the list instead of resetting it. 12091 Style.ForEachMacros.clear(); 12092 std::vector<std::string> BoostForeach; 12093 BoostForeach.push_back("BOOST_FOREACH"); 12094 CHECK_PARSE("ForEachMacros: [BOOST_FOREACH]", ForEachMacros, BoostForeach); 12095 std::vector<std::string> BoostAndQForeach; 12096 BoostAndQForeach.push_back("BOOST_FOREACH"); 12097 BoostAndQForeach.push_back("Q_FOREACH"); 12098 CHECK_PARSE("ForEachMacros: [BOOST_FOREACH, Q_FOREACH]", ForEachMacros, 12099 BoostAndQForeach); 12100 12101 Style.StatementMacros.clear(); 12102 CHECK_PARSE("StatementMacros: [QUNUSED]", StatementMacros, 12103 std::vector<std::string>{"QUNUSED"}); 12104 CHECK_PARSE("StatementMacros: [QUNUSED, QT_REQUIRE_VERSION]", StatementMacros, 12105 std::vector<std::string>({"QUNUSED", "QT_REQUIRE_VERSION"})); 12106 12107 Style.NamespaceMacros.clear(); 12108 CHECK_PARSE("NamespaceMacros: [TESTSUITE]", NamespaceMacros, 12109 std::vector<std::string>{"TESTSUITE"}); 12110 CHECK_PARSE("NamespaceMacros: [TESTSUITE, SUITE]", NamespaceMacros, 12111 std::vector<std::string>({"TESTSUITE", "SUITE"})); 12112 12113 Style.IncludeStyle.IncludeCategories.clear(); 12114 std::vector<tooling::IncludeStyle::IncludeCategory> ExpectedCategories = { 12115 {"abc/.*", 2}, {".*", 1}}; 12116 CHECK_PARSE("IncludeCategories:\n" 12117 " - Regex: abc/.*\n" 12118 " Priority: 2\n" 12119 " - Regex: .*\n" 12120 " Priority: 1", 12121 IncludeStyle.IncludeCategories, ExpectedCategories); 12122 CHECK_PARSE("IncludeIsMainRegex: 'abc$'", IncludeStyle.IncludeIsMainRegex, 12123 "abc$"); 12124 12125 Style.RawStringFormats.clear(); 12126 std::vector<FormatStyle::RawStringFormat> ExpectedRawStringFormats = { 12127 { 12128 FormatStyle::LK_TextProto, 12129 {"pb", "proto"}, 12130 {"PARSE_TEXT_PROTO"}, 12131 /*CanonicalDelimiter=*/"", 12132 "llvm", 12133 }, 12134 { 12135 FormatStyle::LK_Cpp, 12136 {"cc", "cpp"}, 12137 {"C_CODEBLOCK", "CPPEVAL"}, 12138 /*CanonicalDelimiter=*/"cc", 12139 /*BasedOnStyle=*/"", 12140 }, 12141 }; 12142 12143 CHECK_PARSE("RawStringFormats:\n" 12144 " - Language: TextProto\n" 12145 " Delimiters:\n" 12146 " - 'pb'\n" 12147 " - 'proto'\n" 12148 " EnclosingFunctions:\n" 12149 " - 'PARSE_TEXT_PROTO'\n" 12150 " BasedOnStyle: llvm\n" 12151 " - Language: Cpp\n" 12152 " Delimiters:\n" 12153 " - 'cc'\n" 12154 " - 'cpp'\n" 12155 " EnclosingFunctions:\n" 12156 " - 'C_CODEBLOCK'\n" 12157 " - 'CPPEVAL'\n" 12158 " CanonicalDelimiter: 'cc'", 12159 RawStringFormats, ExpectedRawStringFormats); 12160 } 12161 12162 TEST_F(FormatTest, ParsesConfigurationWithLanguages) { 12163 FormatStyle Style = {}; 12164 Style.Language = FormatStyle::LK_Cpp; 12165 CHECK_PARSE("Language: Cpp\n" 12166 "IndentWidth: 12", 12167 IndentWidth, 12u); 12168 EXPECT_EQ(parseConfiguration("Language: JavaScript\n" 12169 "IndentWidth: 34", 12170 &Style), 12171 ParseError::Unsuitable); 12172 EXPECT_EQ(12u, Style.IndentWidth); 12173 CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u); 12174 EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language); 12175 12176 Style.Language = FormatStyle::LK_JavaScript; 12177 CHECK_PARSE("Language: JavaScript\n" 12178 "IndentWidth: 12", 12179 IndentWidth, 12u); 12180 CHECK_PARSE("IndentWidth: 23", IndentWidth, 23u); 12181 EXPECT_EQ(parseConfiguration("Language: Cpp\n" 12182 "IndentWidth: 34", 12183 &Style), 12184 ParseError::Unsuitable); 12185 EXPECT_EQ(23u, Style.IndentWidth); 12186 CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u); 12187 EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language); 12188 12189 CHECK_PARSE("BasedOnStyle: LLVM\n" 12190 "IndentWidth: 67", 12191 IndentWidth, 67u); 12192 12193 CHECK_PARSE("---\n" 12194 "Language: JavaScript\n" 12195 "IndentWidth: 12\n" 12196 "---\n" 12197 "Language: Cpp\n" 12198 "IndentWidth: 34\n" 12199 "...\n", 12200 IndentWidth, 12u); 12201 12202 Style.Language = FormatStyle::LK_Cpp; 12203 CHECK_PARSE("---\n" 12204 "Language: JavaScript\n" 12205 "IndentWidth: 12\n" 12206 "---\n" 12207 "Language: Cpp\n" 12208 "IndentWidth: 34\n" 12209 "...\n", 12210 IndentWidth, 34u); 12211 CHECK_PARSE("---\n" 12212 "IndentWidth: 78\n" 12213 "---\n" 12214 "Language: JavaScript\n" 12215 "IndentWidth: 56\n" 12216 "...\n", 12217 IndentWidth, 78u); 12218 12219 Style.ColumnLimit = 123; 12220 Style.IndentWidth = 234; 12221 Style.BreakBeforeBraces = FormatStyle::BS_Linux; 12222 Style.TabWidth = 345; 12223 EXPECT_FALSE(parseConfiguration("---\n" 12224 "IndentWidth: 456\n" 12225 "BreakBeforeBraces: Allman\n" 12226 "---\n" 12227 "Language: JavaScript\n" 12228 "IndentWidth: 111\n" 12229 "TabWidth: 111\n" 12230 "---\n" 12231 "Language: Cpp\n" 12232 "BreakBeforeBraces: Stroustrup\n" 12233 "TabWidth: 789\n" 12234 "...\n", 12235 &Style)); 12236 EXPECT_EQ(123u, Style.ColumnLimit); 12237 EXPECT_EQ(456u, Style.IndentWidth); 12238 EXPECT_EQ(FormatStyle::BS_Stroustrup, Style.BreakBeforeBraces); 12239 EXPECT_EQ(789u, Style.TabWidth); 12240 12241 EXPECT_EQ(parseConfiguration("---\n" 12242 "Language: JavaScript\n" 12243 "IndentWidth: 56\n" 12244 "---\n" 12245 "IndentWidth: 78\n" 12246 "...\n", 12247 &Style), 12248 ParseError::Error); 12249 EXPECT_EQ(parseConfiguration("---\n" 12250 "Language: JavaScript\n" 12251 "IndentWidth: 56\n" 12252 "---\n" 12253 "Language: JavaScript\n" 12254 "IndentWidth: 78\n" 12255 "...\n", 12256 &Style), 12257 ParseError::Error); 12258 12259 EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language); 12260 } 12261 12262 #undef CHECK_PARSE 12263 12264 TEST_F(FormatTest, UsesLanguageForBasedOnStyle) { 12265 FormatStyle Style = {}; 12266 Style.Language = FormatStyle::LK_JavaScript; 12267 Style.BreakBeforeTernaryOperators = true; 12268 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Style).value()); 12269 EXPECT_FALSE(Style.BreakBeforeTernaryOperators); 12270 12271 Style.BreakBeforeTernaryOperators = true; 12272 EXPECT_EQ(0, parseConfiguration("---\n" 12273 "BasedOnStyle: Google\n" 12274 "---\n" 12275 "Language: JavaScript\n" 12276 "IndentWidth: 76\n" 12277 "...\n", 12278 &Style) 12279 .value()); 12280 EXPECT_FALSE(Style.BreakBeforeTernaryOperators); 12281 EXPECT_EQ(76u, Style.IndentWidth); 12282 EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language); 12283 } 12284 12285 TEST_F(FormatTest, ConfigurationRoundTripTest) { 12286 FormatStyle Style = getLLVMStyle(); 12287 std::string YAML = configurationAsText(Style); 12288 FormatStyle ParsedStyle = {}; 12289 ParsedStyle.Language = FormatStyle::LK_Cpp; 12290 EXPECT_EQ(0, parseConfiguration(YAML, &ParsedStyle).value()); 12291 EXPECT_EQ(Style, ParsedStyle); 12292 } 12293 12294 TEST_F(FormatTest, WorksFor8bitEncodings) { 12295 EXPECT_EQ("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 \"\n" 12296 "\"\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \"\n" 12297 "\"\xe7\xe8\xec\xed\xfe\xfe \"\n" 12298 "\"\xef\xee\xf0\xf3...\"", 12299 format("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 " 12300 "\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \xe7\xe8\xec\xed\xfe\xfe " 12301 "\xef\xee\xf0\xf3...\"", 12302 getLLVMStyleWithColumns(12))); 12303 } 12304 12305 TEST_F(FormatTest, HandlesUTF8BOM) { 12306 EXPECT_EQ("\xef\xbb\xbf", format("\xef\xbb\xbf")); 12307 EXPECT_EQ("\xef\xbb\xbf#include <iostream>", 12308 format("\xef\xbb\xbf#include <iostream>")); 12309 EXPECT_EQ("\xef\xbb\xbf\n#include <iostream>", 12310 format("\xef\xbb\xbf\n#include <iostream>")); 12311 } 12312 12313 // FIXME: Encode Cyrillic and CJK characters below to appease MS compilers. 12314 #if !defined(_MSC_VER) 12315 12316 TEST_F(FormatTest, CountsUTF8CharactersProperly) { 12317 verifyFormat("\"Однажды в студёную зимнюю пору...\"", 12318 getLLVMStyleWithColumns(35)); 12319 verifyFormat("\"一 二 三 四 五 六 七 八 九 十\"", 12320 getLLVMStyleWithColumns(31)); 12321 verifyFormat("// Однажды в студёную зимнюю пору...", 12322 getLLVMStyleWithColumns(36)); 12323 verifyFormat("// 一 二 三 四 五 六 七 八 九 十", getLLVMStyleWithColumns(32)); 12324 verifyFormat("/* Однажды в студёную зимнюю пору... */", 12325 getLLVMStyleWithColumns(39)); 12326 verifyFormat("/* 一 二 三 四 五 六 七 八 九 十 */", 12327 getLLVMStyleWithColumns(35)); 12328 } 12329 12330 TEST_F(FormatTest, SplitsUTF8Strings) { 12331 // Non-printable characters' width is currently considered to be the length in 12332 // bytes in UTF8. The characters can be displayed in very different manner 12333 // (zero-width, single width with a substitution glyph, expanded to their code 12334 // (e.g. "<8d>"), so there's no single correct way to handle them. 12335 EXPECT_EQ("\"aaaaÄ\"\n" 12336 "\"\xc2\x8d\";", 12337 format("\"aaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10))); 12338 EXPECT_EQ("\"aaaaaaaÄ\"\n" 12339 "\"\xc2\x8d\";", 12340 format("\"aaaaaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10))); 12341 EXPECT_EQ("\"Однажды, в \"\n" 12342 "\"студёную \"\n" 12343 "\"зимнюю \"\n" 12344 "\"пору,\"", 12345 format("\"Однажды, в студёную зимнюю пору,\"", 12346 getLLVMStyleWithColumns(13))); 12347 EXPECT_EQ( 12348 "\"一 二 三 \"\n" 12349 "\"四 五六 \"\n" 12350 "\"七 八 九 \"\n" 12351 "\"十\"", 12352 format("\"一 二 三 四 五六 七 八 九 十\"", getLLVMStyleWithColumns(11))); 12353 EXPECT_EQ("\"一\t\"\n" 12354 "\"二 \t\"\n" 12355 "\"三 四 \"\n" 12356 "\"五\t\"\n" 12357 "\"六 \t\"\n" 12358 "\"七 \"\n" 12359 "\"八九十\tqq\"", 12360 format("\"一\t二 \t三 四 五\t六 \t七 八九十\tqq\"", 12361 getLLVMStyleWithColumns(11))); 12362 12363 // UTF8 character in an escape sequence. 12364 EXPECT_EQ("\"aaaaaa\"\n" 12365 "\"\\\xC2\x8D\"", 12366 format("\"aaaaaa\\\xC2\x8D\"", getLLVMStyleWithColumns(10))); 12367 } 12368 12369 TEST_F(FormatTest, HandlesDoubleWidthCharsInMultiLineStrings) { 12370 EXPECT_EQ("const char *sssss =\n" 12371 " \"一二三四五六七八\\\n" 12372 " 九 十\";", 12373 format("const char *sssss = \"一二三四五六七八\\\n" 12374 " 九 十\";", 12375 getLLVMStyleWithColumns(30))); 12376 } 12377 12378 TEST_F(FormatTest, SplitsUTF8LineComments) { 12379 EXPECT_EQ("// aaaaÄ\xc2\x8d", 12380 format("// aaaaÄ\xc2\x8d", getLLVMStyleWithColumns(10))); 12381 EXPECT_EQ("// Я из лесу\n" 12382 "// вышел; был\n" 12383 "// сильный\n" 12384 "// мороз.", 12385 format("// Я из лесу вышел; был сильный мороз.", 12386 getLLVMStyleWithColumns(13))); 12387 EXPECT_EQ("// 一二三\n" 12388 "// 四五六七\n" 12389 "// 八 九\n" 12390 "// 十", 12391 format("// 一二三 四五六七 八 九 十", getLLVMStyleWithColumns(9))); 12392 } 12393 12394 TEST_F(FormatTest, SplitsUTF8BlockComments) { 12395 EXPECT_EQ("/* Гляжу,\n" 12396 " * поднимается\n" 12397 " * медленно в\n" 12398 " * гору\n" 12399 " * Лошадка,\n" 12400 " * везущая\n" 12401 " * хворосту\n" 12402 " * воз. */", 12403 format("/* Гляжу, поднимается медленно в гору\n" 12404 " * Лошадка, везущая хворосту воз. */", 12405 getLLVMStyleWithColumns(13))); 12406 EXPECT_EQ( 12407 "/* 一二三\n" 12408 " * 四五六七\n" 12409 " * 八 九\n" 12410 " * 十 */", 12411 format("/* 一二三 四五六七 八 九 十 */", getLLVMStyleWithColumns(9))); 12412 EXPECT_EQ("/* �������� ��������\n" 12413 " * ��������\n" 12414 " * ������-�� */", 12415 format("/* �������� �������� �������� ������-�� */", getLLVMStyleWithColumns(12))); 12416 } 12417 12418 #endif // _MSC_VER 12419 12420 TEST_F(FormatTest, ConstructorInitializerIndentWidth) { 12421 FormatStyle Style = getLLVMStyle(); 12422 12423 Style.ConstructorInitializerIndentWidth = 4; 12424 verifyFormat( 12425 "SomeClass::Constructor()\n" 12426 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 12427 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 12428 Style); 12429 12430 Style.ConstructorInitializerIndentWidth = 2; 12431 verifyFormat( 12432 "SomeClass::Constructor()\n" 12433 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 12434 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 12435 Style); 12436 12437 Style.ConstructorInitializerIndentWidth = 0; 12438 verifyFormat( 12439 "SomeClass::Constructor()\n" 12440 ": aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 12441 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 12442 Style); 12443 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 12444 verifyFormat( 12445 "SomeLongTemplateVariableName<\n" 12446 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>", 12447 Style); 12448 verifyFormat( 12449 "bool smaller = 1 < bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 12450 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 12451 Style); 12452 12453 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 12454 verifyFormat( 12455 "SomeClass::Constructor() :\n" 12456 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa),\n" 12457 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa) {}", 12458 Style); 12459 } 12460 12461 TEST_F(FormatTest, BreakConstructorInitializersBeforeComma) { 12462 FormatStyle Style = getLLVMStyle(); 12463 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 12464 Style.ConstructorInitializerIndentWidth = 4; 12465 verifyFormat("SomeClass::Constructor()\n" 12466 " : a(a)\n" 12467 " , b(b)\n" 12468 " , c(c) {}", 12469 Style); 12470 verifyFormat("SomeClass::Constructor()\n" 12471 " : a(a) {}", 12472 Style); 12473 12474 Style.ColumnLimit = 0; 12475 verifyFormat("SomeClass::Constructor()\n" 12476 " : a(a) {}", 12477 Style); 12478 verifyFormat("SomeClass::Constructor() noexcept\n" 12479 " : a(a) {}", 12480 Style); 12481 verifyFormat("SomeClass::Constructor()\n" 12482 " : a(a)\n" 12483 " , b(b)\n" 12484 " , c(c) {}", 12485 Style); 12486 verifyFormat("SomeClass::Constructor()\n" 12487 " : a(a) {\n" 12488 " foo();\n" 12489 " bar();\n" 12490 "}", 12491 Style); 12492 12493 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 12494 verifyFormat("SomeClass::Constructor()\n" 12495 " : a(a)\n" 12496 " , b(b)\n" 12497 " , c(c) {\n}", 12498 Style); 12499 verifyFormat("SomeClass::Constructor()\n" 12500 " : a(a) {\n}", 12501 Style); 12502 12503 Style.ColumnLimit = 80; 12504 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 12505 Style.ConstructorInitializerIndentWidth = 2; 12506 verifyFormat("SomeClass::Constructor()\n" 12507 " : a(a)\n" 12508 " , b(b)\n" 12509 " , c(c) {}", 12510 Style); 12511 12512 Style.ConstructorInitializerIndentWidth = 0; 12513 verifyFormat("SomeClass::Constructor()\n" 12514 ": a(a)\n" 12515 ", b(b)\n" 12516 ", c(c) {}", 12517 Style); 12518 12519 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 12520 Style.ConstructorInitializerIndentWidth = 4; 12521 verifyFormat("SomeClass::Constructor() : aaaaaaaa(aaaaaaaa) {}", Style); 12522 verifyFormat( 12523 "SomeClass::Constructor() : aaaaa(aaaaa), aaaaa(aaaaa), aaaaa(aaaaa)\n", 12524 Style); 12525 verifyFormat( 12526 "SomeClass::Constructor()\n" 12527 " : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa) {}", 12528 Style); 12529 Style.ConstructorInitializerIndentWidth = 4; 12530 Style.ColumnLimit = 60; 12531 verifyFormat("SomeClass::Constructor()\n" 12532 " : aaaaaaaa(aaaaaaaa)\n" 12533 " , aaaaaaaa(aaaaaaaa)\n" 12534 " , aaaaaaaa(aaaaaaaa) {}", 12535 Style); 12536 } 12537 12538 TEST_F(FormatTest, Destructors) { 12539 verifyFormat("void F(int &i) { i.~int(); }"); 12540 verifyFormat("void F(int &i) { i->~int(); }"); 12541 } 12542 12543 TEST_F(FormatTest, FormatsWithWebKitStyle) { 12544 FormatStyle Style = getWebKitStyle(); 12545 12546 // Don't indent in outer namespaces. 12547 verifyFormat("namespace outer {\n" 12548 "int i;\n" 12549 "namespace inner {\n" 12550 " int i;\n" 12551 "} // namespace inner\n" 12552 "} // namespace outer\n" 12553 "namespace other_outer {\n" 12554 "int i;\n" 12555 "}", 12556 Style); 12557 12558 // Don't indent case labels. 12559 verifyFormat("switch (variable) {\n" 12560 "case 1:\n" 12561 "case 2:\n" 12562 " doSomething();\n" 12563 " break;\n" 12564 "default:\n" 12565 " ++variable;\n" 12566 "}", 12567 Style); 12568 12569 // Wrap before binary operators. 12570 EXPECT_EQ("void f()\n" 12571 "{\n" 12572 " if (aaaaaaaaaaaaaaaa\n" 12573 " && bbbbbbbbbbbbbbbbbbbbbbbb\n" 12574 " && (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n" 12575 " return;\n" 12576 "}", 12577 format("void f() {\n" 12578 "if (aaaaaaaaaaaaaaaa\n" 12579 "&& bbbbbbbbbbbbbbbbbbbbbbbb\n" 12580 "&& (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n" 12581 "return;\n" 12582 "}", 12583 Style)); 12584 12585 // Allow functions on a single line. 12586 verifyFormat("void f() { return; }", Style); 12587 12588 // Allow empty blocks on a single line and insert a space in empty blocks. 12589 EXPECT_EQ("void f() { }", format("void f() {}", Style)); 12590 EXPECT_EQ("while (true) { }", format("while (true) {}", Style)); 12591 // However, don't merge non-empty short loops. 12592 EXPECT_EQ("while (true) {\n" 12593 " continue;\n" 12594 "}", format("while (true) { continue; }", Style)); 12595 12596 // Constructor initializers are formatted one per line with the "," on the 12597 // new line. 12598 verifyFormat("Constructor()\n" 12599 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 12600 " , aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaa, // break\n" 12601 " aaaaaaaaaaaaaa)\n" 12602 " , aaaaaaaaaaaaaaaaaaaaaaa()\n" 12603 "{\n" 12604 "}", 12605 Style); 12606 verifyFormat("SomeClass::Constructor()\n" 12607 " : a(a)\n" 12608 "{\n" 12609 "}", 12610 Style); 12611 EXPECT_EQ("SomeClass::Constructor()\n" 12612 " : a(a)\n" 12613 "{\n" 12614 "}", 12615 format("SomeClass::Constructor():a(a){}", Style)); 12616 verifyFormat("SomeClass::Constructor()\n" 12617 " : a(a)\n" 12618 " , b(b)\n" 12619 " , c(c)\n" 12620 "{\n" 12621 "}", 12622 Style); 12623 verifyFormat("SomeClass::Constructor()\n" 12624 " : a(a)\n" 12625 "{\n" 12626 " foo();\n" 12627 " bar();\n" 12628 "}", 12629 Style); 12630 12631 // Access specifiers should be aligned left. 12632 verifyFormat("class C {\n" 12633 "public:\n" 12634 " int i;\n" 12635 "};", 12636 Style); 12637 12638 // Do not align comments. 12639 verifyFormat("int a; // Do not\n" 12640 "double b; // align comments.", 12641 Style); 12642 12643 // Do not align operands. 12644 EXPECT_EQ("ASSERT(aaaa\n" 12645 " || bbbb);", 12646 format("ASSERT ( aaaa\n||bbbb);", Style)); 12647 12648 // Accept input's line breaks. 12649 EXPECT_EQ("if (aaaaaaaaaaaaaaa\n" 12650 " || bbbbbbbbbbbbbbb) {\n" 12651 " i++;\n" 12652 "}", 12653 format("if (aaaaaaaaaaaaaaa\n" 12654 "|| bbbbbbbbbbbbbbb) { i++; }", 12655 Style)); 12656 EXPECT_EQ("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) {\n" 12657 " i++;\n" 12658 "}", 12659 format("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) { i++; }", Style)); 12660 12661 // Don't automatically break all macro definitions (llvm.org/PR17842). 12662 verifyFormat("#define aNumber 10", Style); 12663 // However, generally keep the line breaks that the user authored. 12664 EXPECT_EQ("#define aNumber \\\n" 12665 " 10", 12666 format("#define aNumber \\\n" 12667 " 10", 12668 Style)); 12669 12670 // Keep empty and one-element array literals on a single line. 12671 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[]\n" 12672 " copyItems:YES];", 12673 format("NSArray*a=[[NSArray alloc] initWithArray:@[]\n" 12674 "copyItems:YES];", 12675 Style)); 12676 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\" ]\n" 12677 " copyItems:YES];", 12678 format("NSArray*a=[[NSArray alloc]initWithArray:@[ @\"a\" ]\n" 12679 " copyItems:YES];", 12680 Style)); 12681 // FIXME: This does not seem right, there should be more indentation before 12682 // the array literal's entries. Nested blocks have the same problem. 12683 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[\n" 12684 " @\"a\",\n" 12685 " @\"a\"\n" 12686 "]\n" 12687 " copyItems:YES];", 12688 format("NSArray* a = [[NSArray alloc] initWithArray:@[\n" 12689 " @\"a\",\n" 12690 " @\"a\"\n" 12691 " ]\n" 12692 " copyItems:YES];", 12693 Style)); 12694 EXPECT_EQ( 12695 "NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n" 12696 " copyItems:YES];", 12697 format("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n" 12698 " copyItems:YES];", 12699 Style)); 12700 12701 verifyFormat("[self.a b:c c:d];", Style); 12702 EXPECT_EQ("[self.a b:c\n" 12703 " c:d];", 12704 format("[self.a b:c\n" 12705 "c:d];", 12706 Style)); 12707 } 12708 12709 TEST_F(FormatTest, FormatsLambdas) { 12710 verifyFormat("int c = [b]() mutable { return [&b] { return b++; }(); }();\n"); 12711 verifyFormat( 12712 "int c = [b]() mutable noexcept { return [&b] { return b++; }(); }();\n"); 12713 verifyFormat("int c = [&] { [=] { return b++; }(); }();\n"); 12714 verifyFormat("int c = [&, &a, a] { [=, c, &d] { return b++; }(); }();\n"); 12715 verifyFormat("int c = [&a, &a, a] { [=, a, b, &c] { return b++; }(); }();\n"); 12716 verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] { return b++; }(); }}\n"); 12717 verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] {}(); }}\n"); 12718 verifyFormat("auto c = [a = [b = 42] {}] {};\n"); 12719 verifyFormat("auto c = [a = &i + 10, b = [] {}] {};\n"); 12720 verifyFormat("int x = f(*+[] {});"); 12721 verifyFormat("void f() {\n" 12722 " other(x.begin(), x.end(), [&](int, int) { return 1; });\n" 12723 "}\n"); 12724 verifyFormat("void f() {\n" 12725 " other(x.begin(), //\n" 12726 " x.end(), //\n" 12727 " [&](int, int) { return 1; });\n" 12728 "}\n"); 12729 verifyFormat("void f() {\n" 12730 " other.other.other.other.other(\n" 12731 " x.begin(), x.end(),\n" 12732 " [something, rather](int, int, int, int, int, int, int) { return 1; });\n" 12733 "}\n"); 12734 verifyFormat("void f() {\n" 12735 " other.other.other.other.other(\n" 12736 " x.begin(), x.end(),\n" 12737 " [something, rather](int, int, int, int, int, int, int) {\n" 12738 " //\n" 12739 " });\n" 12740 "}\n"); 12741 verifyFormat("SomeFunction([]() { // A cool function...\n" 12742 " return 43;\n" 12743 "});"); 12744 EXPECT_EQ("SomeFunction([]() {\n" 12745 "#define A a\n" 12746 " return 43;\n" 12747 "});", 12748 format("SomeFunction([](){\n" 12749 "#define A a\n" 12750 "return 43;\n" 12751 "});")); 12752 verifyFormat("void f() {\n" 12753 " SomeFunction([](decltype(x), A *a) {});\n" 12754 "}"); 12755 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 12756 " [](const aaaaaaaaaa &a) { return a; });"); 12757 verifyFormat("string abc = SomeFunction(aaaaaaaaaaaaa, aaaaa, []() {\n" 12758 " SomeOtherFunctioooooooooooooooooooooooooon();\n" 12759 "});"); 12760 verifyFormat("Constructor()\n" 12761 " : Field([] { // comment\n" 12762 " int i;\n" 12763 " }) {}"); 12764 verifyFormat("auto my_lambda = [](const string &some_parameter) {\n" 12765 " return some_parameter.size();\n" 12766 "};"); 12767 verifyFormat("std::function<std::string(const std::string &)> my_lambda =\n" 12768 " [](const string &s) { return s; };"); 12769 verifyFormat("int i = aaaaaa ? 1 //\n" 12770 " : [] {\n" 12771 " return 2; //\n" 12772 " }();"); 12773 verifyFormat("llvm::errs() << \"number of twos is \"\n" 12774 " << std::count_if(v.begin(), v.end(), [](int x) {\n" 12775 " return x == 2; // force break\n" 12776 " });"); 12777 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 12778 " [=](int iiiiiiiiiiii) {\n" 12779 " return aaaaaaaaaaaaaaaaaaaaaaa !=\n" 12780 " aaaaaaaaaaaaaaaaaaaaaaa;\n" 12781 " });", 12782 getLLVMStyleWithColumns(60)); 12783 verifyFormat("SomeFunction({[&] {\n" 12784 " // comment\n" 12785 " },\n" 12786 " [&] {\n" 12787 " // comment\n" 12788 " }});"); 12789 verifyFormat("SomeFunction({[&] {\n" 12790 " // comment\n" 12791 "}});"); 12792 verifyFormat("virtual aaaaaaaaaaaaaaaa(\n" 12793 " std::function<bool()> bbbbbbbbbbbb = [&]() { return true; },\n" 12794 " aaaaa aaaaaaaaa);"); 12795 12796 // Lambdas with return types. 12797 verifyFormat("int c = []() -> int { return 2; }();\n"); 12798 verifyFormat("int c = []() -> int * { return 2; }();\n"); 12799 verifyFormat("int c = []() -> vector<int> { return {2}; }();\n"); 12800 verifyFormat("Foo([]() -> std::vector<int> { return {2}; }());"); 12801 verifyGoogleFormat("auto a = [&b, c](D* d) -> D* {};"); 12802 verifyGoogleFormat("auto a = [&b, c](D* d) -> pair<D*, D*> {};"); 12803 verifyGoogleFormat("auto a = [&b, c](D* d) -> D& {};"); 12804 verifyGoogleFormat("auto a = [&b, c](D* d) -> const D* {};"); 12805 verifyFormat("[a, a]() -> a<1> {};"); 12806 verifyFormat("[]() -> foo<5 + 2> { return {}; };"); 12807 verifyFormat("[]() -> foo<5 - 2> { return {}; };"); 12808 verifyFormat("[]() -> foo<5 / 2> { return {}; };"); 12809 verifyFormat("[]() -> foo<5 * 2> { return {}; };"); 12810 verifyFormat("[]() -> foo<5 % 2> { return {}; };"); 12811 verifyFormat("[]() -> foo<5 << 2> { return {}; };"); 12812 verifyFormat("[]() -> foo<!5> { return {}; };"); 12813 verifyFormat("[]() -> foo<~5> { return {}; };"); 12814 verifyFormat("[]() -> foo<5 | 2> { return {}; };"); 12815 verifyFormat("[]() -> foo<5 || 2> { return {}; };"); 12816 verifyFormat("[]() -> foo<5 & 2> { return {}; };"); 12817 verifyFormat("[]() -> foo<5 && 2> { return {}; };"); 12818 verifyFormat("[]() -> foo<5 == 2> { return {}; };"); 12819 verifyFormat("[]() -> foo<5 != 2> { return {}; };"); 12820 verifyFormat("[]() -> foo<5 >= 2> { return {}; };"); 12821 verifyFormat("[]() -> foo<5 <= 2> { return {}; };"); 12822 verifyFormat("[]() -> foo<5 < 2> { return {}; };"); 12823 verifyFormat("[]() -> foo<2 ? 1 : 0> { return {}; };"); 12824 verifyFormat("namespace bar {\n" 12825 "// broken:\n" 12826 "auto foo{[]() -> foo<5 + 2> { return {}; }};\n" 12827 "} // namespace bar"); 12828 verifyFormat("namespace bar {\n" 12829 "// broken:\n" 12830 "auto foo{[]() -> foo<5 - 2> { return {}; }};\n" 12831 "} // namespace bar"); 12832 verifyFormat("namespace bar {\n" 12833 "// broken:\n" 12834 "auto foo{[]() -> foo<5 / 2> { return {}; }};\n" 12835 "} // namespace bar"); 12836 verifyFormat("namespace bar {\n" 12837 "// broken:\n" 12838 "auto foo{[]() -> foo<5 * 2> { return {}; }};\n" 12839 "} // namespace bar"); 12840 verifyFormat("namespace bar {\n" 12841 "// broken:\n" 12842 "auto foo{[]() -> foo<5 % 2> { return {}; }};\n" 12843 "} // namespace bar"); 12844 verifyFormat("namespace bar {\n" 12845 "// broken:\n" 12846 "auto foo{[]() -> foo<5 << 2> { return {}; }};\n" 12847 "} // namespace bar"); 12848 verifyFormat("namespace bar {\n" 12849 "// broken:\n" 12850 "auto foo{[]() -> foo<!5> { return {}; }};\n" 12851 "} // namespace bar"); 12852 verifyFormat("namespace bar {\n" 12853 "// broken:\n" 12854 "auto foo{[]() -> foo<~5> { return {}; }};\n" 12855 "} // namespace bar"); 12856 verifyFormat("namespace bar {\n" 12857 "// broken:\n" 12858 "auto foo{[]() -> foo<5 | 2> { return {}; }};\n" 12859 "} // namespace bar"); 12860 verifyFormat("namespace bar {\n" 12861 "// broken:\n" 12862 "auto foo{[]() -> foo<5 || 2> { return {}; }};\n" 12863 "} // namespace bar"); 12864 verifyFormat("namespace bar {\n" 12865 "// broken:\n" 12866 "auto foo{[]() -> foo<5 & 2> { return {}; }};\n" 12867 "} // namespace bar"); 12868 verifyFormat("namespace bar {\n" 12869 "// broken:\n" 12870 "auto foo{[]() -> foo<5 && 2> { return {}; }};\n" 12871 "} // namespace bar"); 12872 verifyFormat("namespace bar {\n" 12873 "// broken:\n" 12874 "auto foo{[]() -> foo<5 == 2> { return {}; }};\n" 12875 "} // namespace bar"); 12876 verifyFormat("namespace bar {\n" 12877 "// broken:\n" 12878 "auto foo{[]() -> foo<5 != 2> { return {}; }};\n" 12879 "} // namespace bar"); 12880 verifyFormat("namespace bar {\n" 12881 "// broken:\n" 12882 "auto foo{[]() -> foo<5 >= 2> { return {}; }};\n" 12883 "} // namespace bar"); 12884 verifyFormat("namespace bar {\n" 12885 "// broken:\n" 12886 "auto foo{[]() -> foo<5 <= 2> { return {}; }};\n" 12887 "} // namespace bar"); 12888 verifyFormat("namespace bar {\n" 12889 "// broken:\n" 12890 "auto foo{[]() -> foo<5 < 2> { return {}; }};\n" 12891 "} // namespace bar"); 12892 verifyFormat("namespace bar {\n" 12893 "// broken:\n" 12894 "auto foo{[]() -> foo<2 ? 1 : 0> { return {}; }};\n" 12895 "} // namespace bar"); 12896 verifyFormat("[]() -> a<1> {};"); 12897 verifyFormat("[]() -> a<1> { ; };"); 12898 verifyFormat("[]() -> a<1> { ; }();"); 12899 verifyFormat("[a, a]() -> a<true> {};"); 12900 verifyFormat("[]() -> a<true> {};"); 12901 verifyFormat("[]() -> a<true> { ; };"); 12902 verifyFormat("[]() -> a<true> { ; }();"); 12903 verifyFormat("[a, a]() -> a<false> {};"); 12904 verifyFormat("[]() -> a<false> {};"); 12905 verifyFormat("[]() -> a<false> { ; };"); 12906 verifyFormat("[]() -> a<false> { ; }();"); 12907 verifyFormat("auto foo{[]() -> foo<false> { ; }};"); 12908 verifyFormat("namespace bar {\n" 12909 "auto foo{[]() -> foo<false> { ; }};\n" 12910 "} // namespace bar"); 12911 verifyFormat("auto aaaaaaaa = [](int i, // break for some reason\n" 12912 " int j) -> int {\n" 12913 " return ffffffffffffffffffffffffffffffffffffffffffff(i * j);\n" 12914 "};"); 12915 verifyFormat( 12916 "aaaaaaaaaaaaaaaaaaaaaa(\n" 12917 " [](aaaaaaaaaaaaaaaaaaaaaaaaaaa &aaa) -> aaaaaaaaaaaaaaaa {\n" 12918 " return aaaaaaaaaaaaaaaaa;\n" 12919 " });", 12920 getLLVMStyleWithColumns(70)); 12921 verifyFormat("[]() //\n" 12922 " -> int {\n" 12923 " return 1; //\n" 12924 "};"); 12925 12926 // Lambdas with explicit template argument lists. 12927 verifyFormat( 12928 "auto L = []<template <typename> class T, class U>(T<U> &&a) {};\n"); 12929 12930 // Multiple lambdas in the same parentheses change indentation rules. These 12931 // lambdas are forced to start on new lines. 12932 verifyFormat("SomeFunction(\n" 12933 " []() {\n" 12934 " //\n" 12935 " },\n" 12936 " []() {\n" 12937 " //\n" 12938 " });"); 12939 12940 // A lambda passed as arg0 is always pushed to the next line. 12941 verifyFormat("SomeFunction(\n" 12942 " [this] {\n" 12943 " //\n" 12944 " },\n" 12945 " 1);\n"); 12946 12947 // A multi-line lambda passed as arg1 forces arg0 to be pushed out, just like 12948 // the arg0 case above. 12949 auto Style = getGoogleStyle(); 12950 Style.BinPackArguments = false; 12951 verifyFormat("SomeFunction(\n" 12952 " a,\n" 12953 " [this] {\n" 12954 " //\n" 12955 " },\n" 12956 " b);\n", 12957 Style); 12958 verifyFormat("SomeFunction(\n" 12959 " a,\n" 12960 " [this] {\n" 12961 " //\n" 12962 " },\n" 12963 " b);\n"); 12964 12965 // A lambda with a very long line forces arg0 to be pushed out irrespective of 12966 // the BinPackArguments value (as long as the code is wide enough). 12967 verifyFormat("something->SomeFunction(\n" 12968 " a,\n" 12969 " [this] {\n" 12970 " D0000000000000000000000000000000000000000000000000000000000001();\n" 12971 " },\n" 12972 " b);\n"); 12973 12974 // A multi-line lambda is pulled up as long as the introducer fits on the previous 12975 // line and there are no further args. 12976 verifyFormat("function(1, [this, that] {\n" 12977 " //\n" 12978 "});\n"); 12979 verifyFormat("function([this, that] {\n" 12980 " //\n" 12981 "});\n"); 12982 // FIXME: this format is not ideal and we should consider forcing the first arg 12983 // onto its own line. 12984 verifyFormat("function(a, b, c, //\n" 12985 " d, [this, that] {\n" 12986 " //\n" 12987 " });\n"); 12988 12989 // Multiple lambdas are treated correctly even when there is a short arg0. 12990 verifyFormat("SomeFunction(\n" 12991 " 1,\n" 12992 " [this] {\n" 12993 " //\n" 12994 " },\n" 12995 " [this] {\n" 12996 " //\n" 12997 " },\n" 12998 " 1);\n"); 12999 13000 // More complex introducers. 13001 verifyFormat("return [i, args...] {};"); 13002 13003 // Not lambdas. 13004 verifyFormat("constexpr char hello[]{\"hello\"};"); 13005 verifyFormat("double &operator[](int i) { return 0; }\n" 13006 "int i;"); 13007 verifyFormat("std::unique_ptr<int[]> foo() {}"); 13008 verifyFormat("int i = a[a][a]->f();"); 13009 verifyFormat("int i = (*b)[a]->f();"); 13010 13011 // Other corner cases. 13012 verifyFormat("void f() {\n" 13013 " bar([]() {} // Did not respect SpacesBeforeTrailingComments\n" 13014 " );\n" 13015 "}"); 13016 13017 // Lambdas created through weird macros. 13018 verifyFormat("void f() {\n" 13019 " MACRO((const AA &a) { return 1; });\n" 13020 " MACRO((AA &a) { return 1; });\n" 13021 "}"); 13022 13023 verifyFormat("if (blah_blah(whatever, whatever, [] {\n" 13024 " doo_dah();\n" 13025 " doo_dah();\n" 13026 " })) {\n" 13027 "}"); 13028 verifyFormat("if constexpr (blah_blah(whatever, whatever, [] {\n" 13029 " doo_dah();\n" 13030 " doo_dah();\n" 13031 " })) {\n" 13032 "}"); 13033 verifyFormat("if CONSTEXPR (blah_blah(whatever, whatever, [] {\n" 13034 " doo_dah();\n" 13035 " doo_dah();\n" 13036 " })) {\n" 13037 "}"); 13038 verifyFormat("auto lambda = []() {\n" 13039 " int a = 2\n" 13040 "#if A\n" 13041 " + 2\n" 13042 "#endif\n" 13043 " ;\n" 13044 "};"); 13045 13046 // Lambdas with complex multiline introducers. 13047 verifyFormat( 13048 "aaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 13049 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]()\n" 13050 " -> ::std::unordered_set<\n" 13051 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> {\n" 13052 " //\n" 13053 " });"); 13054 13055 FormatStyle DoNotMerge = getLLVMStyle(); 13056 DoNotMerge.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None; 13057 verifyFormat("auto c = []() {\n" 13058 " return b;\n" 13059 "};", 13060 "auto c = []() { return b; };", DoNotMerge); 13061 verifyFormat("auto c = []() {\n" 13062 "};", 13063 " auto c = []() {};", DoNotMerge); 13064 13065 FormatStyle MergeEmptyOnly = getLLVMStyle(); 13066 MergeEmptyOnly.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Empty; 13067 verifyFormat("auto c = []() {\n" 13068 " return b;\n" 13069 "};", 13070 "auto c = []() {\n" 13071 " return b;\n" 13072 " };", 13073 MergeEmptyOnly); 13074 verifyFormat("auto c = []() {};", 13075 "auto c = []() {\n" 13076 "};", 13077 MergeEmptyOnly); 13078 13079 FormatStyle MergeInline = getLLVMStyle(); 13080 MergeInline.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Inline; 13081 verifyFormat("auto c = []() {\n" 13082 " return b;\n" 13083 "};", 13084 "auto c = []() { return b; };", MergeInline); 13085 verifyFormat("function([]() { return b; })", "function([]() { return b; })", 13086 MergeInline); 13087 verifyFormat("function([]() { return b; }, a)", 13088 "function([]() { return b; }, a)", MergeInline); 13089 verifyFormat("function(a, []() { return b; })", 13090 "function(a, []() { return b; })", MergeInline); 13091 } 13092 13093 TEST_F(FormatTest, EmptyLinesInLambdas) { 13094 verifyFormat("auto lambda = []() {\n" 13095 " x(); //\n" 13096 "};", 13097 "auto lambda = []() {\n" 13098 "\n" 13099 " x(); //\n" 13100 "\n" 13101 "};"); 13102 } 13103 13104 TEST_F(FormatTest, FormatsBlocks) { 13105 FormatStyle ShortBlocks = getLLVMStyle(); 13106 ShortBlocks.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always; 13107 verifyFormat("int (^Block)(int, int);", ShortBlocks); 13108 verifyFormat("int (^Block1)(int, int) = ^(int i, int j)", ShortBlocks); 13109 verifyFormat("void (^block)(int) = ^(id test) { int i; };", ShortBlocks); 13110 verifyFormat("void (^block)(int) = ^(int test) { int i; };", ShortBlocks); 13111 verifyFormat("void (^block)(int) = ^id(int test) { int i; };", ShortBlocks); 13112 verifyFormat("void (^block)(int) = ^int(int test) { int i; };", ShortBlocks); 13113 13114 verifyFormat("foo(^{ bar(); });", ShortBlocks); 13115 verifyFormat("foo(a, ^{ bar(); });", ShortBlocks); 13116 verifyFormat("{ void (^block)(Object *x); }", ShortBlocks); 13117 13118 verifyFormat("[operation setCompletionBlock:^{\n" 13119 " [self onOperationDone];\n" 13120 "}];"); 13121 verifyFormat("int i = {[operation setCompletionBlock:^{\n" 13122 " [self onOperationDone];\n" 13123 "}]};"); 13124 verifyFormat("[operation setCompletionBlock:^(int *i) {\n" 13125 " f();\n" 13126 "}];"); 13127 verifyFormat("int a = [operation block:^int(int *i) {\n" 13128 " return 1;\n" 13129 "}];"); 13130 verifyFormat("[myObject doSomethingWith:arg1\n" 13131 " aaa:^int(int *a) {\n" 13132 " return 1;\n" 13133 " }\n" 13134 " bbb:f(a * bbbbbbbb)];"); 13135 13136 verifyFormat("[operation setCompletionBlock:^{\n" 13137 " [self.delegate newDataAvailable];\n" 13138 "}];", 13139 getLLVMStyleWithColumns(60)); 13140 verifyFormat("dispatch_async(_fileIOQueue, ^{\n" 13141 " NSString *path = [self sessionFilePath];\n" 13142 " if (path) {\n" 13143 " // ...\n" 13144 " }\n" 13145 "});"); 13146 verifyFormat("[[SessionService sharedService]\n" 13147 " loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 13148 " if (window) {\n" 13149 " [self windowDidLoad:window];\n" 13150 " } else {\n" 13151 " [self errorLoadingWindow];\n" 13152 " }\n" 13153 " }];"); 13154 verifyFormat("void (^largeBlock)(void) = ^{\n" 13155 " // ...\n" 13156 "};\n", 13157 getLLVMStyleWithColumns(40)); 13158 verifyFormat("[[SessionService sharedService]\n" 13159 " loadWindowWithCompletionBlock: //\n" 13160 " ^(SessionWindow *window) {\n" 13161 " if (window) {\n" 13162 " [self windowDidLoad:window];\n" 13163 " } else {\n" 13164 " [self errorLoadingWindow];\n" 13165 " }\n" 13166 " }];", 13167 getLLVMStyleWithColumns(60)); 13168 verifyFormat("[myObject doSomethingWith:arg1\n" 13169 " firstBlock:^(Foo *a) {\n" 13170 " // ...\n" 13171 " int i;\n" 13172 " }\n" 13173 " secondBlock:^(Bar *b) {\n" 13174 " // ...\n" 13175 " int i;\n" 13176 " }\n" 13177 " thirdBlock:^Foo(Bar *b) {\n" 13178 " // ...\n" 13179 " int i;\n" 13180 " }];"); 13181 verifyFormat("[myObject doSomethingWith:arg1\n" 13182 " firstBlock:-1\n" 13183 " secondBlock:^(Bar *b) {\n" 13184 " // ...\n" 13185 " int i;\n" 13186 " }];"); 13187 13188 verifyFormat("f(^{\n" 13189 " @autoreleasepool {\n" 13190 " if (a) {\n" 13191 " g();\n" 13192 " }\n" 13193 " }\n" 13194 "});"); 13195 verifyFormat("Block b = ^int *(A *a, B *b) {}"); 13196 verifyFormat("BOOL (^aaa)(void) = ^BOOL {\n" 13197 "};"); 13198 13199 FormatStyle FourIndent = getLLVMStyle(); 13200 FourIndent.ObjCBlockIndentWidth = 4; 13201 verifyFormat("[operation setCompletionBlock:^{\n" 13202 " [self onOperationDone];\n" 13203 "}];", 13204 FourIndent); 13205 } 13206 13207 TEST_F(FormatTest, FormatsBlocksWithZeroColumnWidth) { 13208 FormatStyle ZeroColumn = getLLVMStyle(); 13209 ZeroColumn.ColumnLimit = 0; 13210 13211 verifyFormat("[[SessionService sharedService] " 13212 "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 13213 " if (window) {\n" 13214 " [self windowDidLoad:window];\n" 13215 " } else {\n" 13216 " [self errorLoadingWindow];\n" 13217 " }\n" 13218 "}];", 13219 ZeroColumn); 13220 EXPECT_EQ("[[SessionService sharedService]\n" 13221 " loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 13222 " if (window) {\n" 13223 " [self windowDidLoad:window];\n" 13224 " } else {\n" 13225 " [self errorLoadingWindow];\n" 13226 " }\n" 13227 " }];", 13228 format("[[SessionService sharedService]\n" 13229 "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 13230 " if (window) {\n" 13231 " [self windowDidLoad:window];\n" 13232 " } else {\n" 13233 " [self errorLoadingWindow];\n" 13234 " }\n" 13235 "}];", 13236 ZeroColumn)); 13237 verifyFormat("[myObject doSomethingWith:arg1\n" 13238 " firstBlock:^(Foo *a) {\n" 13239 " // ...\n" 13240 " int i;\n" 13241 " }\n" 13242 " secondBlock:^(Bar *b) {\n" 13243 " // ...\n" 13244 " int i;\n" 13245 " }\n" 13246 " thirdBlock:^Foo(Bar *b) {\n" 13247 " // ...\n" 13248 " int i;\n" 13249 " }];", 13250 ZeroColumn); 13251 verifyFormat("f(^{\n" 13252 " @autoreleasepool {\n" 13253 " if (a) {\n" 13254 " g();\n" 13255 " }\n" 13256 " }\n" 13257 "});", 13258 ZeroColumn); 13259 verifyFormat("void (^largeBlock)(void) = ^{\n" 13260 " // ...\n" 13261 "};", 13262 ZeroColumn); 13263 13264 ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always; 13265 EXPECT_EQ("void (^largeBlock)(void) = ^{ int i; };", 13266 format("void (^largeBlock)(void) = ^{ int i; };", ZeroColumn)); 13267 ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Never; 13268 EXPECT_EQ("void (^largeBlock)(void) = ^{\n" 13269 " int i;\n" 13270 "};", 13271 format("void (^largeBlock)(void) = ^{ int i; };", ZeroColumn)); 13272 } 13273 13274 TEST_F(FormatTest, SupportsCRLF) { 13275 EXPECT_EQ("int a;\r\n" 13276 "int b;\r\n" 13277 "int c;\r\n", 13278 format("int a;\r\n" 13279 " int b;\r\n" 13280 " int c;\r\n", 13281 getLLVMStyle())); 13282 EXPECT_EQ("int a;\r\n" 13283 "int b;\r\n" 13284 "int c;\r\n", 13285 format("int a;\r\n" 13286 " int b;\n" 13287 " int c;\r\n", 13288 getLLVMStyle())); 13289 EXPECT_EQ("int a;\n" 13290 "int b;\n" 13291 "int c;\n", 13292 format("int a;\r\n" 13293 " int b;\n" 13294 " int c;\n", 13295 getLLVMStyle())); 13296 EXPECT_EQ("\"aaaaaaa \"\r\n" 13297 "\"bbbbbbb\";\r\n", 13298 format("\"aaaaaaa bbbbbbb\";\r\n", getLLVMStyleWithColumns(10))); 13299 EXPECT_EQ("#define A \\\r\n" 13300 " b; \\\r\n" 13301 " c; \\\r\n" 13302 " d;\r\n", 13303 format("#define A \\\r\n" 13304 " b; \\\r\n" 13305 " c; d; \r\n", 13306 getGoogleStyle())); 13307 13308 EXPECT_EQ("/*\r\n" 13309 "multi line block comments\r\n" 13310 "should not introduce\r\n" 13311 "an extra carriage return\r\n" 13312 "*/\r\n", 13313 format("/*\r\n" 13314 "multi line block comments\r\n" 13315 "should not introduce\r\n" 13316 "an extra carriage return\r\n" 13317 "*/\r\n")); 13318 EXPECT_EQ("/*\r\n" 13319 "\r\n" 13320 "*/", 13321 format("/*\r\n" 13322 " \r\r\r\n" 13323 "*/")); 13324 } 13325 13326 TEST_F(FormatTest, MunchSemicolonAfterBlocks) { 13327 verifyFormat("MY_CLASS(C) {\n" 13328 " int i;\n" 13329 " int j;\n" 13330 "};"); 13331 } 13332 13333 TEST_F(FormatTest, ConfigurableContinuationIndentWidth) { 13334 FormatStyle TwoIndent = getLLVMStyleWithColumns(15); 13335 TwoIndent.ContinuationIndentWidth = 2; 13336 13337 EXPECT_EQ("int i =\n" 13338 " longFunction(\n" 13339 " arg);", 13340 format("int i = longFunction(arg);", TwoIndent)); 13341 13342 FormatStyle SixIndent = getLLVMStyleWithColumns(20); 13343 SixIndent.ContinuationIndentWidth = 6; 13344 13345 EXPECT_EQ("int i =\n" 13346 " longFunction(\n" 13347 " arg);", 13348 format("int i = longFunction(arg);", SixIndent)); 13349 } 13350 13351 TEST_F(FormatTest, WrappedClosingParenthesisIndent) { 13352 FormatStyle Style = getLLVMStyle(); 13353 verifyFormat("int Foo::getter(\n" 13354 " //\n" 13355 ") const {\n" 13356 " return foo;\n" 13357 "}", 13358 Style); 13359 verifyFormat("void Foo::setter(\n" 13360 " //\n" 13361 ") {\n" 13362 " foo = 1;\n" 13363 "}", 13364 Style); 13365 } 13366 13367 TEST_F(FormatTest, SpacesInAngles) { 13368 FormatStyle Spaces = getLLVMStyle(); 13369 Spaces.SpacesInAngles = true; 13370 13371 verifyFormat("static_cast< int >(arg);", Spaces); 13372 verifyFormat("template < typename T0, typename T1 > void f() {}", Spaces); 13373 verifyFormat("f< int, float >();", Spaces); 13374 verifyFormat("template <> g() {}", Spaces); 13375 verifyFormat("template < std::vector< int > > f() {}", Spaces); 13376 verifyFormat("std::function< void(int, int) > fct;", Spaces); 13377 verifyFormat("void inFunction() { std::function< void(int, int) > fct; }", 13378 Spaces); 13379 13380 Spaces.Standard = FormatStyle::LS_Cpp03; 13381 Spaces.SpacesInAngles = true; 13382 verifyFormat("A< A< int > >();", Spaces); 13383 13384 Spaces.SpacesInAngles = false; 13385 verifyFormat("A<A<int> >();", Spaces); 13386 13387 Spaces.Standard = FormatStyle::LS_Cpp11; 13388 Spaces.SpacesInAngles = true; 13389 verifyFormat("A< A< int > >();", Spaces); 13390 13391 Spaces.SpacesInAngles = false; 13392 verifyFormat("A<A<int>>();", Spaces); 13393 } 13394 13395 TEST_F(FormatTest, SpaceAfterTemplateKeyword) { 13396 FormatStyle Style = getLLVMStyle(); 13397 Style.SpaceAfterTemplateKeyword = false; 13398 verifyFormat("template<int> void foo();", Style); 13399 } 13400 13401 TEST_F(FormatTest, TripleAngleBrackets) { 13402 verifyFormat("f<<<1, 1>>>();"); 13403 verifyFormat("f<<<1, 1, 1, s>>>();"); 13404 verifyFormat("f<<<a, b, c, d>>>();"); 13405 EXPECT_EQ("f<<<1, 1>>>();", format("f <<< 1, 1 >>> ();")); 13406 verifyFormat("f<param><<<1, 1>>>();"); 13407 verifyFormat("f<1><<<1, 1>>>();"); 13408 EXPECT_EQ("f<param><<<1, 1>>>();", format("f< param > <<< 1, 1 >>> ();")); 13409 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 13410 "aaaaaaaaaaa<<<\n 1, 1>>>();"); 13411 verifyFormat("aaaaaaaaaaaaaaa<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaa>\n" 13412 " <<<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaaaaaa>>>();"); 13413 } 13414 13415 TEST_F(FormatTest, MergeLessLessAtEnd) { 13416 verifyFormat("<<"); 13417 EXPECT_EQ("< < <", format("\\\n<<<")); 13418 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 13419 "aaallvm::outs() <<"); 13420 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 13421 "aaaallvm::outs()\n <<"); 13422 } 13423 13424 TEST_F(FormatTest, HandleUnbalancedImplicitBracesAcrossPPBranches) { 13425 std::string code = "#if A\n" 13426 "#if B\n" 13427 "a.\n" 13428 "#endif\n" 13429 " a = 1;\n" 13430 "#else\n" 13431 "#endif\n" 13432 "#if C\n" 13433 "#else\n" 13434 "#endif\n"; 13435 EXPECT_EQ(code, format(code)); 13436 } 13437 13438 TEST_F(FormatTest, HandleConflictMarkers) { 13439 // Git/SVN conflict markers. 13440 EXPECT_EQ("int a;\n" 13441 "void f() {\n" 13442 " callme(some(parameter1,\n" 13443 "<<<<<<< text by the vcs\n" 13444 " parameter2),\n" 13445 "||||||| text by the vcs\n" 13446 " parameter2),\n" 13447 " parameter3,\n" 13448 "======= text by the vcs\n" 13449 " parameter2, parameter3),\n" 13450 ">>>>>>> text by the vcs\n" 13451 " otherparameter);\n", 13452 format("int a;\n" 13453 "void f() {\n" 13454 " callme(some(parameter1,\n" 13455 "<<<<<<< text by the vcs\n" 13456 " parameter2),\n" 13457 "||||||| text by the vcs\n" 13458 " parameter2),\n" 13459 " parameter3,\n" 13460 "======= text by the vcs\n" 13461 " parameter2,\n" 13462 " parameter3),\n" 13463 ">>>>>>> text by the vcs\n" 13464 " otherparameter);\n")); 13465 13466 // Perforce markers. 13467 EXPECT_EQ("void f() {\n" 13468 " function(\n" 13469 ">>>> text by the vcs\n" 13470 " parameter,\n" 13471 "==== text by the vcs\n" 13472 " parameter,\n" 13473 "==== text by the vcs\n" 13474 " parameter,\n" 13475 "<<<< text by the vcs\n" 13476 " parameter);\n", 13477 format("void f() {\n" 13478 " function(\n" 13479 ">>>> text by the vcs\n" 13480 " parameter,\n" 13481 "==== text by the vcs\n" 13482 " parameter,\n" 13483 "==== text by the vcs\n" 13484 " parameter,\n" 13485 "<<<< text by the vcs\n" 13486 " parameter);\n")); 13487 13488 EXPECT_EQ("<<<<<<<\n" 13489 "|||||||\n" 13490 "=======\n" 13491 ">>>>>>>", 13492 format("<<<<<<<\n" 13493 "|||||||\n" 13494 "=======\n" 13495 ">>>>>>>")); 13496 13497 EXPECT_EQ("<<<<<<<\n" 13498 "|||||||\n" 13499 "int i;\n" 13500 "=======\n" 13501 ">>>>>>>", 13502 format("<<<<<<<\n" 13503 "|||||||\n" 13504 "int i;\n" 13505 "=======\n" 13506 ">>>>>>>")); 13507 13508 // FIXME: Handle parsing of macros around conflict markers correctly: 13509 EXPECT_EQ("#define Macro \\\n" 13510 "<<<<<<<\n" 13511 "Something \\\n" 13512 "|||||||\n" 13513 "Else \\\n" 13514 "=======\n" 13515 "Other \\\n" 13516 ">>>>>>>\n" 13517 " End int i;\n", 13518 format("#define Macro \\\n" 13519 "<<<<<<<\n" 13520 " Something \\\n" 13521 "|||||||\n" 13522 " Else \\\n" 13523 "=======\n" 13524 " Other \\\n" 13525 ">>>>>>>\n" 13526 " End\n" 13527 "int i;\n")); 13528 } 13529 13530 TEST_F(FormatTest, DisableRegions) { 13531 EXPECT_EQ("int i;\n" 13532 "// clang-format off\n" 13533 " int j;\n" 13534 "// clang-format on\n" 13535 "int k;", 13536 format(" int i;\n" 13537 " // clang-format off\n" 13538 " int j;\n" 13539 " // clang-format on\n" 13540 " int k;")); 13541 EXPECT_EQ("int i;\n" 13542 "/* clang-format off */\n" 13543 " int j;\n" 13544 "/* clang-format on */\n" 13545 "int k;", 13546 format(" int i;\n" 13547 " /* clang-format off */\n" 13548 " int j;\n" 13549 " /* clang-format on */\n" 13550 " int k;")); 13551 13552 // Don't reflow comments within disabled regions. 13553 EXPECT_EQ( 13554 "// clang-format off\n" 13555 "// long long long long long long line\n" 13556 "/* clang-format on */\n" 13557 "/* long long long\n" 13558 " * long long long\n" 13559 " * line */\n" 13560 "int i;\n" 13561 "/* clang-format off */\n" 13562 "/* long long long long long long line */\n", 13563 format("// clang-format off\n" 13564 "// long long long long long long line\n" 13565 "/* clang-format on */\n" 13566 "/* long long long long long long line */\n" 13567 "int i;\n" 13568 "/* clang-format off */\n" 13569 "/* long long long long long long line */\n", 13570 getLLVMStyleWithColumns(20))); 13571 } 13572 13573 TEST_F(FormatTest, DoNotCrashOnInvalidInput) { 13574 format("? ) ="); 13575 verifyNoCrash("#define a\\\n /**/}"); 13576 } 13577 13578 TEST_F(FormatTest, FormatsTableGenCode) { 13579 FormatStyle Style = getLLVMStyle(); 13580 Style.Language = FormatStyle::LK_TableGen; 13581 verifyFormat("include \"a.td\"\ninclude \"b.td\"", Style); 13582 } 13583 13584 TEST_F(FormatTest, ArrayOfTemplates) { 13585 EXPECT_EQ("auto a = new unique_ptr<int>[10];", 13586 format("auto a = new unique_ptr<int > [ 10];")); 13587 13588 FormatStyle Spaces = getLLVMStyle(); 13589 Spaces.SpacesInSquareBrackets = true; 13590 EXPECT_EQ("auto a = new unique_ptr<int>[ 10 ];", 13591 format("auto a = new unique_ptr<int > [10];", Spaces)); 13592 } 13593 13594 TEST_F(FormatTest, ArrayAsTemplateType) { 13595 EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[10]>;", 13596 format("auto a = unique_ptr < Foo < Bar>[ 10]> ;")); 13597 13598 FormatStyle Spaces = getLLVMStyle(); 13599 Spaces.SpacesInSquareBrackets = true; 13600 EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[ 10 ]>;", 13601 format("auto a = unique_ptr < Foo < Bar>[10]> ;", Spaces)); 13602 } 13603 13604 TEST_F(FormatTest, NoSpaceAfterSuper) { 13605 verifyFormat("__super::FooBar();"); 13606 } 13607 13608 TEST(FormatStyle, GetStyleWithEmptyFileName) { 13609 llvm::vfs::InMemoryFileSystem FS; 13610 auto Style1 = getStyle("file", "", "Google", "", &FS); 13611 ASSERT_TRUE((bool)Style1); 13612 ASSERT_EQ(*Style1, getGoogleStyle()); 13613 } 13614 13615 TEST(FormatStyle, GetStyleOfFile) { 13616 llvm::vfs::InMemoryFileSystem FS; 13617 // Test 1: format file in the same directory. 13618 ASSERT_TRUE( 13619 FS.addFile("/a/.clang-format", 0, 13620 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM"))); 13621 ASSERT_TRUE( 13622 FS.addFile("/a/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;"))); 13623 auto Style1 = getStyle("file", "/a/.clang-format", "Google", "", &FS); 13624 ASSERT_TRUE((bool)Style1); 13625 ASSERT_EQ(*Style1, getLLVMStyle()); 13626 13627 // Test 2.1: fallback to default. 13628 ASSERT_TRUE( 13629 FS.addFile("/b/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;"))); 13630 auto Style2 = getStyle("file", "/b/test.cpp", "Mozilla", "", &FS); 13631 ASSERT_TRUE((bool)Style2); 13632 ASSERT_EQ(*Style2, getMozillaStyle()); 13633 13634 // Test 2.2: no format on 'none' fallback style. 13635 Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS); 13636 ASSERT_TRUE((bool)Style2); 13637 ASSERT_EQ(*Style2, getNoStyle()); 13638 13639 // Test 2.3: format if config is found with no based style while fallback is 13640 // 'none'. 13641 ASSERT_TRUE(FS.addFile("/b/.clang-format", 0, 13642 llvm::MemoryBuffer::getMemBuffer("IndentWidth: 2"))); 13643 Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS); 13644 ASSERT_TRUE((bool)Style2); 13645 ASSERT_EQ(*Style2, getLLVMStyle()); 13646 13647 // Test 2.4: format if yaml with no based style, while fallback is 'none'. 13648 Style2 = getStyle("{}", "a.h", "none", "", &FS); 13649 ASSERT_TRUE((bool)Style2); 13650 ASSERT_EQ(*Style2, getLLVMStyle()); 13651 13652 // Test 3: format file in parent directory. 13653 ASSERT_TRUE( 13654 FS.addFile("/c/.clang-format", 0, 13655 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: Google"))); 13656 ASSERT_TRUE(FS.addFile("/c/sub/sub/sub/test.cpp", 0, 13657 llvm::MemoryBuffer::getMemBuffer("int i;"))); 13658 auto Style3 = getStyle("file", "/c/sub/sub/sub/test.cpp", "LLVM", "", &FS); 13659 ASSERT_TRUE((bool)Style3); 13660 ASSERT_EQ(*Style3, getGoogleStyle()); 13661 13662 // Test 4: error on invalid fallback style 13663 auto Style4 = getStyle("file", "a.h", "KungFu", "", &FS); 13664 ASSERT_FALSE((bool)Style4); 13665 llvm::consumeError(Style4.takeError()); 13666 13667 // Test 5: error on invalid yaml on command line 13668 auto Style5 = getStyle("{invalid_key=invalid_value}", "a.h", "LLVM", "", &FS); 13669 ASSERT_FALSE((bool)Style5); 13670 llvm::consumeError(Style5.takeError()); 13671 13672 // Test 6: error on invalid style 13673 auto Style6 = getStyle("KungFu", "a.h", "LLVM", "", &FS); 13674 ASSERT_FALSE((bool)Style6); 13675 llvm::consumeError(Style6.takeError()); 13676 13677 // Test 7: found config file, error on parsing it 13678 ASSERT_TRUE( 13679 FS.addFile("/d/.clang-format", 0, 13680 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM\n" 13681 "InvalidKey: InvalidValue"))); 13682 ASSERT_TRUE( 13683 FS.addFile("/d/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;"))); 13684 auto Style7 = getStyle("file", "/d/.clang-format", "LLVM", "", &FS); 13685 ASSERT_FALSE((bool)Style7); 13686 llvm::consumeError(Style7.takeError()); 13687 13688 // Test 8: inferred per-language defaults apply. 13689 auto StyleTd = getStyle("file", "x.td", "llvm", "", &FS); 13690 ASSERT_TRUE((bool)StyleTd); 13691 ASSERT_EQ(*StyleTd, getLLVMStyle(FormatStyle::LK_TableGen)); 13692 } 13693 13694 TEST_F(ReplacementTest, FormatCodeAfterReplacements) { 13695 // Column limit is 20. 13696 std::string Code = "Type *a =\n" 13697 " new Type();\n" 13698 "g(iiiii, 0, jjjjj,\n" 13699 " 0, kkkkk, 0, mm);\n" 13700 "int bad = format ;"; 13701 std::string Expected = "auto a = new Type();\n" 13702 "g(iiiii, nullptr,\n" 13703 " jjjjj, nullptr,\n" 13704 " kkkkk, nullptr,\n" 13705 " mm);\n" 13706 "int bad = format ;"; 13707 FileID ID = Context.createInMemoryFile("format.cpp", Code); 13708 tooling::Replacements Replaces = toReplacements( 13709 {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 6, 13710 "auto "), 13711 tooling::Replacement(Context.Sources, Context.getLocation(ID, 3, 10), 1, 13712 "nullptr"), 13713 tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 3), 1, 13714 "nullptr"), 13715 tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 13), 1, 13716 "nullptr")}); 13717 13718 format::FormatStyle Style = format::getLLVMStyle(); 13719 Style.ColumnLimit = 20; // Set column limit to 20 to increase readibility. 13720 auto FormattedReplaces = formatReplacements(Code, Replaces, Style); 13721 EXPECT_TRUE(static_cast<bool>(FormattedReplaces)) 13722 << llvm::toString(FormattedReplaces.takeError()) << "\n"; 13723 auto Result = applyAllReplacements(Code, *FormattedReplaces); 13724 EXPECT_TRUE(static_cast<bool>(Result)); 13725 EXPECT_EQ(Expected, *Result); 13726 } 13727 13728 TEST_F(ReplacementTest, SortIncludesAfterReplacement) { 13729 std::string Code = "#include \"a.h\"\n" 13730 "#include \"c.h\"\n" 13731 "\n" 13732 "int main() {\n" 13733 " return 0;\n" 13734 "}"; 13735 std::string Expected = "#include \"a.h\"\n" 13736 "#include \"b.h\"\n" 13737 "#include \"c.h\"\n" 13738 "\n" 13739 "int main() {\n" 13740 " return 0;\n" 13741 "}"; 13742 FileID ID = Context.createInMemoryFile("fix.cpp", Code); 13743 tooling::Replacements Replaces = toReplacements( 13744 {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 0, 13745 "#include \"b.h\"\n")}); 13746 13747 format::FormatStyle Style = format::getLLVMStyle(); 13748 Style.SortIncludes = true; 13749 auto FormattedReplaces = formatReplacements(Code, Replaces, Style); 13750 EXPECT_TRUE(static_cast<bool>(FormattedReplaces)) 13751 << llvm::toString(FormattedReplaces.takeError()) << "\n"; 13752 auto Result = applyAllReplacements(Code, *FormattedReplaces); 13753 EXPECT_TRUE(static_cast<bool>(Result)); 13754 EXPECT_EQ(Expected, *Result); 13755 } 13756 13757 TEST_F(FormatTest, FormatSortsUsingDeclarations) { 13758 EXPECT_EQ("using std::cin;\n" 13759 "using std::cout;", 13760 format("using std::cout;\n" 13761 "using std::cin;", getGoogleStyle())); 13762 } 13763 13764 TEST_F(FormatTest, UTF8CharacterLiteralCpp03) { 13765 format::FormatStyle Style = format::getLLVMStyle(); 13766 Style.Standard = FormatStyle::LS_Cpp03; 13767 // cpp03 recognize this string as identifier u8 and literal character 'a' 13768 EXPECT_EQ("auto c = u8 'a';", format("auto c = u8'a';", Style)); 13769 } 13770 13771 TEST_F(FormatTest, UTF8CharacterLiteralCpp11) { 13772 // u8'a' is a C++17 feature, utf8 literal character, LS_Cpp11 covers 13773 // all modes, including C++11, C++14 and C++17 13774 EXPECT_EQ("auto c = u8'a';", format("auto c = u8'a';")); 13775 } 13776 13777 TEST_F(FormatTest, DoNotFormatLikelyXml) { 13778 EXPECT_EQ("<!-- ;> -->", 13779 format("<!-- ;> -->", getGoogleStyle())); 13780 EXPECT_EQ(" <!-- >; -->", 13781 format(" <!-- >; -->", getGoogleStyle())); 13782 } 13783 13784 TEST_F(FormatTest, StructuredBindings) { 13785 // Structured bindings is a C++17 feature. 13786 // all modes, including C++11, C++14 and C++17 13787 verifyFormat("auto [a, b] = f();"); 13788 EXPECT_EQ("auto [a, b] = f();", format("auto[a, b] = f();")); 13789 EXPECT_EQ("const auto [a, b] = f();", format("const auto[a, b] = f();")); 13790 EXPECT_EQ("auto const [a, b] = f();", format("auto const[a, b] = f();")); 13791 EXPECT_EQ("auto const volatile [a, b] = f();", 13792 format("auto const volatile[a, b] = f();")); 13793 EXPECT_EQ("auto [a, b, c] = f();", format("auto [ a , b,c ] = f();")); 13794 EXPECT_EQ("auto &[a, b, c] = f();", 13795 format("auto &[ a , b,c ] = f();")); 13796 EXPECT_EQ("auto &&[a, b, c] = f();", 13797 format("auto &&[ a , b,c ] = f();")); 13798 EXPECT_EQ("auto const &[a, b] = f();", format("auto const&[a, b] = f();")); 13799 EXPECT_EQ("auto const volatile &&[a, b] = f();", 13800 format("auto const volatile &&[a, b] = f();")); 13801 EXPECT_EQ("auto const &&[a, b] = f();", format("auto const && [a, b] = f();")); 13802 EXPECT_EQ("const auto &[a, b] = f();", format("const auto & [a, b] = f();")); 13803 EXPECT_EQ("const auto volatile &&[a, b] = f();", 13804 format("const auto volatile &&[a, b] = f();")); 13805 EXPECT_EQ("volatile const auto &&[a, b] = f();", 13806 format("volatile const auto &&[a, b] = f();")); 13807 EXPECT_EQ("const auto &&[a, b] = f();", format("const auto && [a, b] = f();")); 13808 13809 // Make sure we don't mistake structured bindings for lambdas. 13810 FormatStyle PointerMiddle = getLLVMStyle(); 13811 PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle; 13812 verifyFormat("auto [a1, b]{A * i};", getGoogleStyle()); 13813 verifyFormat("auto [a2, b]{A * i};", getLLVMStyle()); 13814 verifyFormat("auto [a3, b]{A * i};", PointerMiddle); 13815 verifyFormat("auto const [a1, b]{A * i};", getGoogleStyle()); 13816 verifyFormat("auto const [a2, b]{A * i};", getLLVMStyle()); 13817 verifyFormat("auto const [a3, b]{A * i};", PointerMiddle); 13818 verifyFormat("auto const& [a1, b]{A * i};", getGoogleStyle()); 13819 verifyFormat("auto const &[a2, b]{A * i};", getLLVMStyle()); 13820 verifyFormat("auto const & [a3, b]{A * i};", PointerMiddle); 13821 verifyFormat("auto const&& [a1, b]{A * i};", getGoogleStyle()); 13822 verifyFormat("auto const &&[a2, b]{A * i};", getLLVMStyle()); 13823 verifyFormat("auto const && [a3, b]{A * i};", PointerMiddle); 13824 13825 EXPECT_EQ("for (const auto &&[a, b] : some_range) {\n}", 13826 format("for (const auto && [a, b] : some_range) {\n}")); 13827 EXPECT_EQ("for (const auto &[a, b] : some_range) {\n}", 13828 format("for (const auto & [a, b] : some_range) {\n}")); 13829 EXPECT_EQ("for (const auto [a, b] : some_range) {\n}", 13830 format("for (const auto[a, b] : some_range) {\n}")); 13831 EXPECT_EQ("auto [x, y](expr);", format("auto[x,y] (expr);")); 13832 EXPECT_EQ("auto &[x, y](expr);", format("auto & [x,y] (expr);")); 13833 EXPECT_EQ("auto &&[x, y](expr);", format("auto && [x,y] (expr);")); 13834 EXPECT_EQ("auto const &[x, y](expr);", format("auto const & [x,y] (expr);")); 13835 EXPECT_EQ("auto const &&[x, y](expr);", format("auto const && [x,y] (expr);")); 13836 EXPECT_EQ("auto [x, y]{expr};", format("auto[x,y] {expr};")); 13837 EXPECT_EQ("auto const &[x, y]{expr};", format("auto const & [x,y] {expr};")); 13838 EXPECT_EQ("auto const &&[x, y]{expr};", format("auto const && [x,y] {expr};")); 13839 13840 format::FormatStyle Spaces = format::getLLVMStyle(); 13841 Spaces.SpacesInSquareBrackets = true; 13842 verifyFormat("auto [ a, b ] = f();", Spaces); 13843 verifyFormat("auto &&[ a, b ] = f();", Spaces); 13844 verifyFormat("auto &[ a, b ] = f();", Spaces); 13845 verifyFormat("auto const &&[ a, b ] = f();", Spaces); 13846 verifyFormat("auto const &[ a, b ] = f();", Spaces); 13847 } 13848 13849 TEST_F(FormatTest, FileAndCode) { 13850 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.cc", "")); 13851 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.m", "")); 13852 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.mm", "")); 13853 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "")); 13854 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.h", "@interface Foo\n@end\n")); 13855 EXPECT_EQ( 13856 FormatStyle::LK_ObjC, 13857 guessLanguage("foo.h", "#define TRY(x, y) @try { x; } @finally { y; }")); 13858 EXPECT_EQ(FormatStyle::LK_ObjC, 13859 guessLanguage("foo.h", "#define AVAIL(x) @available(x, *))")); 13860 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.h", "@class Foo;")); 13861 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo", "")); 13862 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo", "@interface Foo\n@end\n")); 13863 EXPECT_EQ(FormatStyle::LK_ObjC, 13864 guessLanguage("foo.h", "int DoStuff(CGRect rect);\n")); 13865 EXPECT_EQ( 13866 FormatStyle::LK_ObjC, 13867 guessLanguage("foo.h", 13868 "#define MY_POINT_MAKE(x, y) CGPointMake((x), (y));\n")); 13869 EXPECT_EQ( 13870 FormatStyle::LK_Cpp, 13871 guessLanguage("foo.h", "#define FOO(...) auto bar = [] __VA_ARGS__;")); 13872 } 13873 13874 TEST_F(FormatTest, GuessLanguageWithCpp11AttributeSpecifiers) { 13875 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[noreturn]];")); 13876 EXPECT_EQ(FormatStyle::LK_ObjC, 13877 guessLanguage("foo.h", "array[[calculator getIndex]];")); 13878 EXPECT_EQ(FormatStyle::LK_Cpp, 13879 guessLanguage("foo.h", "[[noreturn, deprecated(\"so sorry\")]];")); 13880 EXPECT_EQ( 13881 FormatStyle::LK_Cpp, 13882 guessLanguage("foo.h", "[[noreturn, deprecated(\"gone, sorry\")]];")); 13883 EXPECT_EQ(FormatStyle::LK_ObjC, 13884 guessLanguage("foo.h", "[[noreturn foo] bar];")); 13885 EXPECT_EQ(FormatStyle::LK_Cpp, 13886 guessLanguage("foo.h", "[[clang::fallthrough]];")); 13887 EXPECT_EQ(FormatStyle::LK_ObjC, 13888 guessLanguage("foo.h", "[[clang:fallthrough] foo];")); 13889 EXPECT_EQ(FormatStyle::LK_Cpp, 13890 guessLanguage("foo.h", "[[gsl::suppress(\"type\")]];")); 13891 EXPECT_EQ(FormatStyle::LK_Cpp, 13892 guessLanguage("foo.h", "[[using clang: fallthrough]];")); 13893 EXPECT_EQ(FormatStyle::LK_ObjC, 13894 guessLanguage("foo.h", "[[abusing clang:fallthrough] bar];")); 13895 EXPECT_EQ(FormatStyle::LK_Cpp, 13896 guessLanguage("foo.h", "[[using gsl: suppress(\"type\")]];")); 13897 EXPECT_EQ( 13898 FormatStyle::LK_Cpp, 13899 guessLanguage("foo.h", "for (auto &&[endpoint, stream] : streams_)")); 13900 EXPECT_EQ( 13901 FormatStyle::LK_Cpp, 13902 guessLanguage("foo.h", 13903 "[[clang::callable_when(\"unconsumed\", \"unknown\")]]")); 13904 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[foo::bar, ...]]")); 13905 } 13906 13907 TEST_F(FormatTest, GuessLanguageWithCaret) { 13908 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^);")); 13909 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^, Bar);")); 13910 EXPECT_EQ(FormatStyle::LK_ObjC, 13911 guessLanguage("foo.h", "int(^)(char, float);")); 13912 EXPECT_EQ(FormatStyle::LK_ObjC, 13913 guessLanguage("foo.h", "int(^foo)(char, float);")); 13914 EXPECT_EQ(FormatStyle::LK_ObjC, 13915 guessLanguage("foo.h", "int(^foo[10])(char, float);")); 13916 EXPECT_EQ(FormatStyle::LK_ObjC, 13917 guessLanguage("foo.h", "int(^foo[kNumEntries])(char, float);")); 13918 EXPECT_EQ( 13919 FormatStyle::LK_ObjC, 13920 guessLanguage("foo.h", "int(^foo[(kNumEntries + 10)])(char, float);")); 13921 } 13922 13923 TEST_F(FormatTest, GuessedLanguageWithInlineAsmClobbers) { 13924 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", 13925 "void f() {\n" 13926 " asm (\"mov %[e], %[d]\"\n" 13927 " : [d] \"=rm\" (d)\n" 13928 " [e] \"rm\" (*e));\n" 13929 "}")); 13930 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", 13931 "void f() {\n" 13932 " _asm (\"mov %[e], %[d]\"\n" 13933 " : [d] \"=rm\" (d)\n" 13934 " [e] \"rm\" (*e));\n" 13935 "}")); 13936 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", 13937 "void f() {\n" 13938 " __asm (\"mov %[e], %[d]\"\n" 13939 " : [d] \"=rm\" (d)\n" 13940 " [e] \"rm\" (*e));\n" 13941 "}")); 13942 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", 13943 "void f() {\n" 13944 " __asm__ (\"mov %[e], %[d]\"\n" 13945 " : [d] \"=rm\" (d)\n" 13946 " [e] \"rm\" (*e));\n" 13947 "}")); 13948 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", 13949 "void f() {\n" 13950 " asm (\"mov %[e], %[d]\"\n" 13951 " : [d] \"=rm\" (d),\n" 13952 " [e] \"rm\" (*e));\n" 13953 "}")); 13954 EXPECT_EQ(FormatStyle::LK_Cpp, 13955 guessLanguage("foo.h", "void f() {\n" 13956 " asm volatile (\"mov %[e], %[d]\"\n" 13957 " : [d] \"=rm\" (d)\n" 13958 " [e] \"rm\" (*e));\n" 13959 "}")); 13960 } 13961 13962 TEST_F(FormatTest, GuessLanguageWithChildLines) { 13963 EXPECT_EQ(FormatStyle::LK_Cpp, 13964 guessLanguage("foo.h", "#define FOO ({ std::string s; })")); 13965 EXPECT_EQ(FormatStyle::LK_ObjC, 13966 guessLanguage("foo.h", "#define FOO ({ NSString *s; })")); 13967 EXPECT_EQ( 13968 FormatStyle::LK_Cpp, 13969 guessLanguage("foo.h", "#define FOO ({ foo(); ({ std::string s; }) })")); 13970 EXPECT_EQ( 13971 FormatStyle::LK_ObjC, 13972 guessLanguage("foo.h", "#define FOO ({ foo(); ({ NSString *s; }) })")); 13973 } 13974 13975 TEST_F(FormatTest, TypenameMacros) { 13976 std::vector<std::string> TypenameMacros = {"STACK_OF", "LIST", "TAILQ_ENTRY"}; 13977 13978 // Test case reported in https://bugs.llvm.org/show_bug.cgi?id=30353 13979 FormatStyle Google = getGoogleStyleWithColumns(0); 13980 Google.TypenameMacros = TypenameMacros; 13981 verifyFormat("struct foo {\n" 13982 " int bar;\n" 13983 " TAILQ_ENTRY(a) bleh;\n" 13984 "};", Google); 13985 13986 FormatStyle Macros = getLLVMStyle(); 13987 Macros.TypenameMacros = TypenameMacros; 13988 13989 verifyFormat("STACK_OF(int) a;", Macros); 13990 verifyFormat("STACK_OF(int) *a;", Macros); 13991 verifyFormat("STACK_OF(int const *) *a;", Macros); 13992 verifyFormat("STACK_OF(int *const) *a;", Macros); 13993 verifyFormat("STACK_OF(int, string) a;", Macros); 13994 verifyFormat("STACK_OF(LIST(int)) a;", Macros); 13995 verifyFormat("STACK_OF(LIST(int)) a, b;", Macros); 13996 verifyFormat("for (LIST(int) *a = NULL; a;) {\n}", Macros); 13997 verifyFormat("STACK_OF(int) f(LIST(int) *arg);", Macros); 13998 13999 Macros.PointerAlignment = FormatStyle::PAS_Left; 14000 verifyFormat("STACK_OF(int)* a;", Macros); 14001 verifyFormat("STACK_OF(int*)* a;", Macros); 14002 } 14003 14004 } // end namespace 14005 } // end namespace format 14006 } // end namespace clang 14007