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 { SC_ExpectComplete, SC_ExpectIncomplete, SC_DoNotCheck }; 33 34 std::string format(llvm::StringRef Code, 35 const FormatStyle &Style = getLLVMStyle(), 36 StatusCheck CheckComplete = SC_ExpectComplete) { 37 LLVM_DEBUG(llvm::errs() << "---\n"); 38 LLVM_DEBUG(llvm::errs() << Code << "\n\n"); 39 std::vector<tooling::Range> Ranges(1, tooling::Range(0, Code.size())); 40 FormattingAttemptStatus Status; 41 tooling::Replacements Replaces = 42 reformat(Style, Code, Ranges, "<stdin>", &Status); 43 if (CheckComplete != SC_DoNotCheck) { 44 bool ExpectedCompleteFormat = CheckComplete == SC_ExpectComplete; 45 EXPECT_EQ(ExpectedCompleteFormat, Status.FormatComplete) 46 << Code << "\n\n"; 47 } 48 ReplacementCount = Replaces.size(); 49 auto Result = applyAllReplacements(Code, Replaces); 50 EXPECT_TRUE(static_cast<bool>(Result)); 51 LLVM_DEBUG(llvm::errs() << "\n" << *Result << "\n\n"); 52 return *Result; 53 } 54 55 FormatStyle getStyleWithColumns(FormatStyle Style, unsigned ColumnLimit) { 56 Style.ColumnLimit = ColumnLimit; 57 return Style; 58 } 59 60 FormatStyle getLLVMStyleWithColumns(unsigned ColumnLimit) { 61 return getStyleWithColumns(getLLVMStyle(), ColumnLimit); 62 } 63 64 FormatStyle getGoogleStyleWithColumns(unsigned ColumnLimit) { 65 return getStyleWithColumns(getGoogleStyle(), ColumnLimit); 66 } 67 68 void verifyFormat(llvm::StringRef Expected, llvm::StringRef Code, 69 const FormatStyle &Style = getLLVMStyle()) { 70 EXPECT_EQ(Expected.str(), format(Expected, Style)) 71 << "Expected code is not stable"; 72 EXPECT_EQ(Expected.str(), format(Code, Style)); 73 if (Style.Language == FormatStyle::LK_Cpp) { 74 // Objective-C++ is a superset of C++, so everything checked for C++ 75 // needs to be checked for Objective-C++ as well. 76 FormatStyle ObjCStyle = Style; 77 ObjCStyle.Language = FormatStyle::LK_ObjC; 78 EXPECT_EQ(Expected.str(), format(test::messUp(Code), ObjCStyle)); 79 } 80 } 81 82 void verifyFormat(llvm::StringRef Code, 83 const FormatStyle &Style = getLLVMStyle()) { 84 verifyFormat(Code, test::messUp(Code), Style); 85 } 86 87 void verifyIncompleteFormat(llvm::StringRef Code, 88 const FormatStyle &Style = getLLVMStyle()) { 89 EXPECT_EQ(Code.str(), 90 format(test::messUp(Code), Style, SC_ExpectIncomplete)); 91 } 92 93 void verifyGoogleFormat(llvm::StringRef Code) { 94 verifyFormat(Code, getGoogleStyle()); 95 } 96 97 void verifyIndependentOfContext(llvm::StringRef text) { 98 verifyFormat(text); 99 verifyFormat(llvm::Twine("void f() { " + text + " }").str()); 100 } 101 102 /// \brief Verify that clang-format does not crash on the given input. 103 void verifyNoCrash(llvm::StringRef Code, 104 const FormatStyle &Style = getLLVMStyle()) { 105 format(Code, Style, SC_DoNotCheck); 106 } 107 108 int ReplacementCount; 109 }; 110 111 TEST_F(FormatTest, MessUp) { 112 EXPECT_EQ("1 2 3", test::messUp("1 2 3")); 113 EXPECT_EQ("1 2 3\n", test::messUp("1\n2\n3\n")); 114 EXPECT_EQ("a\n//b\nc", test::messUp("a\n//b\nc")); 115 EXPECT_EQ("a\n#b\nc", test::messUp("a\n#b\nc")); 116 EXPECT_EQ("a\n#b c d\ne", test::messUp("a\n#b\\\nc\\\nd\ne")); 117 } 118 119 TEST_F(FormatTest, DefaultLLVMStyleIsCpp) { 120 EXPECT_EQ(FormatStyle::LK_Cpp, getLLVMStyle().Language); 121 } 122 123 TEST_F(FormatTest, LLVMStyleOverride) { 124 EXPECT_EQ(FormatStyle::LK_Proto, 125 getLLVMStyle(FormatStyle::LK_Proto).Language); 126 } 127 128 //===----------------------------------------------------------------------===// 129 // Basic function tests. 130 //===----------------------------------------------------------------------===// 131 132 TEST_F(FormatTest, DoesNotChangeCorrectlyFormattedCode) { 133 EXPECT_EQ(";", format(";")); 134 } 135 136 TEST_F(FormatTest, FormatsGlobalStatementsAt0) { 137 EXPECT_EQ("int i;", format(" int i;")); 138 EXPECT_EQ("\nint i;", format(" \n\t \v \f int i;")); 139 EXPECT_EQ("int i;\nint j;", format(" int i; int j;")); 140 EXPECT_EQ("int i;\nint j;", format(" int i;\n int j;")); 141 } 142 143 TEST_F(FormatTest, FormatsUnwrappedLinesAtFirstFormat) { 144 EXPECT_EQ("int i;", format("int\ni;")); 145 } 146 147 TEST_F(FormatTest, FormatsNestedBlockStatements) { 148 EXPECT_EQ("{\n {\n {}\n }\n}", format("{{{}}}")); 149 } 150 151 TEST_F(FormatTest, FormatsNestedCall) { 152 verifyFormat("Method(f1, f2(f3));"); 153 verifyFormat("Method(f1(f2, f3()));"); 154 verifyFormat("Method(f1(f2, (f3())));"); 155 } 156 157 TEST_F(FormatTest, NestedNameSpecifiers) { 158 verifyFormat("vector<::Type> v;"); 159 verifyFormat("::ns::SomeFunction(::ns::SomeOtherFunction())"); 160 verifyFormat("static constexpr bool Bar = decltype(bar())::value;"); 161 verifyFormat("bool a = 2 < ::SomeFunction();"); 162 verifyFormat("ALWAYS_INLINE ::std::string getName();"); 163 verifyFormat("some::string getName();"); 164 } 165 166 TEST_F(FormatTest, OnlyGeneratesNecessaryReplacements) { 167 EXPECT_EQ("if (a) {\n" 168 " f();\n" 169 "}", 170 format("if(a){f();}")); 171 EXPECT_EQ(4, ReplacementCount); 172 EXPECT_EQ("if (a) {\n" 173 " f();\n" 174 "}", 175 format("if (a) {\n" 176 " f();\n" 177 "}")); 178 EXPECT_EQ(0, ReplacementCount); 179 EXPECT_EQ("/*\r\n" 180 "\r\n" 181 "*/\r\n", 182 format("/*\r\n" 183 "\r\n" 184 "*/\r\n")); 185 EXPECT_EQ(0, ReplacementCount); 186 } 187 188 TEST_F(FormatTest, RemovesEmptyLines) { 189 EXPECT_EQ("class C {\n" 190 " int i;\n" 191 "};", 192 format("class C {\n" 193 " int i;\n" 194 "\n" 195 "};")); 196 197 // Don't remove empty lines at the start of namespaces or extern "C" blocks. 198 EXPECT_EQ("namespace N {\n" 199 "\n" 200 "int i;\n" 201 "}", 202 format("namespace N {\n" 203 "\n" 204 "int i;\n" 205 "}", 206 getGoogleStyle())); 207 EXPECT_EQ("/* something */ namespace N {\n" 208 "\n" 209 "int i;\n" 210 "}", 211 format("/* something */ namespace N {\n" 212 "\n" 213 "int i;\n" 214 "}", 215 getGoogleStyle())); 216 EXPECT_EQ("inline namespace N {\n" 217 "\n" 218 "int i;\n" 219 "}", 220 format("inline namespace N {\n" 221 "\n" 222 "int i;\n" 223 "}", 224 getGoogleStyle())); 225 EXPECT_EQ("/* something */ inline namespace N {\n" 226 "\n" 227 "int i;\n" 228 "}", 229 format("/* something */ inline namespace N {\n" 230 "\n" 231 "int i;\n" 232 "}", 233 getGoogleStyle())); 234 EXPECT_EQ("export namespace N {\n" 235 "\n" 236 "int i;\n" 237 "}", 238 format("export namespace N {\n" 239 "\n" 240 "int i;\n" 241 "}", 242 getGoogleStyle())); 243 EXPECT_EQ("extern /**/ \"C\" /**/ {\n" 244 "\n" 245 "int i;\n" 246 "}", 247 format("extern /**/ \"C\" /**/ {\n" 248 "\n" 249 "int i;\n" 250 "}", 251 getGoogleStyle())); 252 253 // ...but do keep inlining and removing empty lines for non-block extern "C" 254 // functions. 255 verifyFormat("extern \"C\" int f() { return 42; }", getGoogleStyle()); 256 EXPECT_EQ("extern \"C\" int f() {\n" 257 " int i = 42;\n" 258 " return i;\n" 259 "}", 260 format("extern \"C\" int f() {\n" 261 "\n" 262 " int i = 42;\n" 263 " return i;\n" 264 "}", 265 getGoogleStyle())); 266 267 // Remove empty lines at the beginning and end of blocks. 268 EXPECT_EQ("void f() {\n" 269 "\n" 270 " if (a) {\n" 271 "\n" 272 " f();\n" 273 " }\n" 274 "}", 275 format("void f() {\n" 276 "\n" 277 " if (a) {\n" 278 "\n" 279 " f();\n" 280 "\n" 281 " }\n" 282 "\n" 283 "}", 284 getLLVMStyle())); 285 EXPECT_EQ("void f() {\n" 286 " if (a) {\n" 287 " f();\n" 288 " }\n" 289 "}", 290 format("void f() {\n" 291 "\n" 292 " if (a) {\n" 293 "\n" 294 " f();\n" 295 "\n" 296 " }\n" 297 "\n" 298 "}", 299 getGoogleStyle())); 300 301 // Don't remove empty lines in more complex control statements. 302 EXPECT_EQ("void f() {\n" 303 " if (a) {\n" 304 " f();\n" 305 "\n" 306 " } else if (b) {\n" 307 " f();\n" 308 " }\n" 309 "}", 310 format("void f() {\n" 311 " if (a) {\n" 312 " f();\n" 313 "\n" 314 " } else if (b) {\n" 315 " f();\n" 316 "\n" 317 " }\n" 318 "\n" 319 "}")); 320 321 // Don't remove empty lines before namespace endings. 322 FormatStyle LLVMWithNoNamespaceFix = getLLVMStyle(); 323 LLVMWithNoNamespaceFix.FixNamespaceComments = false; 324 EXPECT_EQ("namespace {\n" 325 "int i;\n" 326 "\n" 327 "}", 328 format("namespace {\n" 329 "int i;\n" 330 "\n" 331 "}", 332 LLVMWithNoNamespaceFix)); 333 EXPECT_EQ("namespace {\n" 334 "int i;\n" 335 "}", 336 format("namespace {\n" 337 "int i;\n" 338 "}", 339 LLVMWithNoNamespaceFix)); 340 EXPECT_EQ("namespace {\n" 341 "int i;\n" 342 "\n" 343 "};", 344 format("namespace {\n" 345 "int i;\n" 346 "\n" 347 "};", 348 LLVMWithNoNamespaceFix)); 349 EXPECT_EQ("namespace {\n" 350 "int i;\n" 351 "};", 352 format("namespace {\n" 353 "int i;\n" 354 "};", 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 = 648 FormatStyle::BWACS_Always; 649 650 verifyFormat("if (true) {}", AllowSimpleBracedStatements); 651 verifyFormat("if constexpr (true) {}", AllowSimpleBracedStatements); 652 verifyFormat("if CONSTEXPR (true) {}", AllowSimpleBracedStatements); 653 verifyFormat("while (true) {}", AllowSimpleBracedStatements); 654 verifyFormat("for (;;) {}", AllowSimpleBracedStatements); 655 verifyFormat("if (true) { f(); }", AllowSimpleBracedStatements); 656 verifyFormat("if constexpr (true) { f(); }", AllowSimpleBracedStatements); 657 verifyFormat("if CONSTEXPR (true) { f(); }", AllowSimpleBracedStatements); 658 verifyFormat("while (true) { f(); }", AllowSimpleBracedStatements); 659 verifyFormat("for (;;) { f(); }", AllowSimpleBracedStatements); 660 verifyFormat("if (true)\n" 661 "{\n" 662 " ffffffffffffffffffffffffffffffffffffffffffffffffffffff();\n" 663 "}", 664 AllowSimpleBracedStatements); 665 verifyFormat("if (true)\n" 666 "{ //\n" 667 " f();\n" 668 "}", 669 AllowSimpleBracedStatements); 670 verifyFormat("if (true)\n" 671 "{\n" 672 " f();\n" 673 " f();\n" 674 "}", 675 AllowSimpleBracedStatements); 676 verifyFormat("if (true)\n" 677 "{\n" 678 " f();\n" 679 "} else\n" 680 "{\n" 681 " f();\n" 682 "}", 683 AllowSimpleBracedStatements); 684 685 AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = 686 FormatStyle::SIS_Never; 687 verifyFormat("if (true) {}", AllowSimpleBracedStatements); 688 verifyFormat("if (true)\n" 689 "{\n" 690 " f();\n" 691 "}", 692 AllowSimpleBracedStatements); 693 verifyFormat("if (true)\n" 694 "{\n" 695 " f();\n" 696 "} else\n" 697 "{\n" 698 " f();\n" 699 "}", 700 AllowSimpleBracedStatements); 701 702 AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = false; 703 verifyFormat("while (true) {}", AllowSimpleBracedStatements); 704 verifyFormat("while (true)\n" 705 "{\n" 706 " f();\n" 707 "}", 708 AllowSimpleBracedStatements); 709 verifyFormat("for (;;) {}", AllowSimpleBracedStatements); 710 verifyFormat("for (;;)\n" 711 "{\n" 712 " f();\n" 713 "}", 714 AllowSimpleBracedStatements); 715 } 716 717 TEST_F(FormatTest, ShortBlocksInMacrosDontMergeWithCodeAfterMacro) { 718 FormatStyle Style = getLLVMStyleWithColumns(60); 719 Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always; 720 Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_WithoutElse; 721 Style.BreakBeforeBraces = FormatStyle::BS_Allman; 722 EXPECT_EQ("#define A \\\n" 723 " if (HANDLEwernufrnuLwrmviferuvnierv) \\\n" 724 " { RET_ERR1_ANUIREUINERUIFNIOAerwfwrvnuier; }\n" 725 "X;", 726 format("#define A \\\n" 727 " if (HANDLEwernufrnuLwrmviferuvnierv) { \\\n" 728 " RET_ERR1_ANUIREUINERUIFNIOAerwfwrvnuier; \\\n" 729 " }\n" 730 "X;", 731 Style)); 732 } 733 734 TEST_F(FormatTest, ParseIfElse) { 735 verifyFormat("if (true)\n" 736 " if (true)\n" 737 " if (true)\n" 738 " f();\n" 739 " else\n" 740 " g();\n" 741 " else\n" 742 " h();\n" 743 "else\n" 744 " i();"); 745 verifyFormat("if (true)\n" 746 " if (true)\n" 747 " if (true) {\n" 748 " if (true)\n" 749 " f();\n" 750 " } else {\n" 751 " g();\n" 752 " }\n" 753 " else\n" 754 " h();\n" 755 "else {\n" 756 " i();\n" 757 "}"); 758 verifyFormat("if (true)\n" 759 " if constexpr (true)\n" 760 " if (true) {\n" 761 " if constexpr (true)\n" 762 " f();\n" 763 " } else {\n" 764 " g();\n" 765 " }\n" 766 " else\n" 767 " h();\n" 768 "else {\n" 769 " i();\n" 770 "}"); 771 verifyFormat("if (true)\n" 772 " if CONSTEXPR (true)\n" 773 " if (true) {\n" 774 " if CONSTEXPR (true)\n" 775 " f();\n" 776 " } else {\n" 777 " g();\n" 778 " }\n" 779 " else\n" 780 " h();\n" 781 "else {\n" 782 " i();\n" 783 "}"); 784 verifyFormat("void f() {\n" 785 " if (a) {\n" 786 " } else {\n" 787 " }\n" 788 "}"); 789 } 790 791 TEST_F(FormatTest, ElseIf) { 792 verifyFormat("if (a) {\n} else if (b) {\n}"); 793 verifyFormat("if (a)\n" 794 " f();\n" 795 "else if (b)\n" 796 " g();\n" 797 "else\n" 798 " h();"); 799 verifyFormat("if constexpr (a)\n" 800 " f();\n" 801 "else if constexpr (b)\n" 802 " g();\n" 803 "else\n" 804 " h();"); 805 verifyFormat("if CONSTEXPR (a)\n" 806 " f();\n" 807 "else if CONSTEXPR (b)\n" 808 " g();\n" 809 "else\n" 810 " h();"); 811 verifyFormat("if (a) {\n" 812 " f();\n" 813 "}\n" 814 "// or else ..\n" 815 "else {\n" 816 " g()\n" 817 "}"); 818 819 verifyFormat("if (a) {\n" 820 "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 821 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n" 822 "}"); 823 verifyFormat("if (a) {\n" 824 "} else if constexpr (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 825 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n" 826 "}"); 827 verifyFormat("if (a) {\n" 828 "} else if CONSTEXPR (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 829 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n" 830 "}"); 831 verifyFormat("if (a) {\n" 832 "} else if (\n" 833 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 834 "}", 835 getLLVMStyleWithColumns(62)); 836 verifyFormat("if (a) {\n" 837 "} else if constexpr (\n" 838 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 839 "}", 840 getLLVMStyleWithColumns(62)); 841 verifyFormat("if (a) {\n" 842 "} else if CONSTEXPR (\n" 843 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 844 "}", 845 getLLVMStyleWithColumns(62)); 846 } 847 848 TEST_F(FormatTest, FormatsForLoop) { 849 verifyFormat( 850 "for (int VeryVeryLongLoopVariable = 0; VeryVeryLongLoopVariable < 10;\n" 851 " ++VeryVeryLongLoopVariable)\n" 852 " ;"); 853 verifyFormat("for (;;)\n" 854 " f();"); 855 verifyFormat("for (;;) {\n}"); 856 verifyFormat("for (;;) {\n" 857 " f();\n" 858 "}"); 859 verifyFormat("for (int i = 0; (i < 10); ++i) {\n}"); 860 861 verifyFormat( 862 "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n" 863 " E = UnwrappedLines.end();\n" 864 " I != E; ++I) {\n}"); 865 866 verifyFormat( 867 "for (MachineFun::iterator IIII = PrevIt, EEEE = F.end(); IIII != EEEE;\n" 868 " ++IIIII) {\n}"); 869 verifyFormat("for (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaa =\n" 870 " aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa;\n" 871 " aaaaaaaaaaa != aaaaaaaaaaaaaaaaaaa; ++aaaaaaaaaaa) {\n}"); 872 verifyFormat("for (llvm::ArrayRef<NamedDecl *>::iterator\n" 873 " I = FD->getDeclsInPrototypeScope().begin(),\n" 874 " E = FD->getDeclsInPrototypeScope().end();\n" 875 " I != E; ++I) {\n}"); 876 verifyFormat("for (SmallVectorImpl<TemplateIdAnnotationn *>::iterator\n" 877 " I = Container.begin(),\n" 878 " E = Container.end();\n" 879 " I != E; ++I) {\n}", 880 getLLVMStyleWithColumns(76)); 881 882 verifyFormat( 883 "for (aaaaaaaaaaaaaaaaa aaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n" 884 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa !=\n" 885 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 886 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 887 " ++aaaaaaaaaaa) {\n}"); 888 verifyFormat("for (int i = 0; i < aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 889 " bbbbbbbbbbbbbbbbbbbb < ccccccccccccccc;\n" 890 " ++i) {\n}"); 891 verifyFormat("for (int aaaaaaaaaaa = 1; aaaaaaaaaaa <= bbbbbbbbbbbbbbb;\n" 892 " aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n" 893 "}"); 894 verifyFormat("for (some_namespace::SomeIterator iter( // force break\n" 895 " aaaaaaaaaa);\n" 896 " iter; ++iter) {\n" 897 "}"); 898 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 899 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 900 " aaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbbbbbbb;\n" 901 " ++aaaaaaaaaaaaaaaaaaaaaaaaaaa) {"); 902 903 // These should not be formatted as Objective-C for-in loops. 904 verifyFormat("for (Foo *x = 0; x != in; x++) {\n}"); 905 verifyFormat("Foo *x;\nfor (x = 0; x != in; x++) {\n}"); 906 verifyFormat("Foo *x;\nfor (x in y) {\n}"); 907 verifyFormat( 908 "for (const Foo<Bar> &baz = in.value(); !baz.at_end(); ++baz) {\n}"); 909 910 FormatStyle NoBinPacking = getLLVMStyle(); 911 NoBinPacking.BinPackParameters = false; 912 verifyFormat("for (int aaaaaaaaaaa = 1;\n" 913 " aaaaaaaaaaa <= aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa,\n" 914 " aaaaaaaaaaaaaaaa,\n" 915 " aaaaaaaaaaaaaaaa,\n" 916 " aaaaaaaaaaaaaaaa);\n" 917 " aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n" 918 "}", 919 NoBinPacking); 920 verifyFormat( 921 "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n" 922 " E = UnwrappedLines.end();\n" 923 " I != E;\n" 924 " ++I) {\n}", 925 NoBinPacking); 926 927 FormatStyle AlignLeft = getLLVMStyle(); 928 AlignLeft.PointerAlignment = FormatStyle::PAS_Left; 929 verifyFormat("for (A* a = start; a < end; ++a, ++value) {\n}", AlignLeft); 930 } 931 932 TEST_F(FormatTest, RangeBasedForLoops) { 933 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 934 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 935 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaa :\n" 936 " aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa, aaaaaaaaaaaaa)) {\n}"); 937 verifyFormat("for (const aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaa :\n" 938 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 939 verifyFormat("for (aaaaaaaaa aaaaaaaaaaaaaaaaaaaaa :\n" 940 " aaaaaaaaaaaa.aaaaaaaaaaaa().aaaaaaaaa().a()) {\n}"); 941 } 942 943 TEST_F(FormatTest, ForEachLoops) { 944 verifyFormat("void f() {\n" 945 " foreach (Item *item, itemlist) {}\n" 946 " Q_FOREACH (Item *item, itemlist) {}\n" 947 " BOOST_FOREACH (Item *item, itemlist) {}\n" 948 " UNKNOWN_FORACH(Item * item, itemlist) {}\n" 949 "}"); 950 951 // As function-like macros. 952 verifyFormat("#define foreach(x, y)\n" 953 "#define Q_FOREACH(x, y)\n" 954 "#define BOOST_FOREACH(x, y)\n" 955 "#define UNKNOWN_FOREACH(x, y)\n"); 956 957 // Not as function-like macros. 958 verifyFormat("#define foreach (x, y)\n" 959 "#define Q_FOREACH (x, y)\n" 960 "#define BOOST_FOREACH (x, y)\n" 961 "#define UNKNOWN_FOREACH (x, y)\n"); 962 } 963 964 TEST_F(FormatTest, FormatsWhileLoop) { 965 verifyFormat("while (true) {\n}"); 966 verifyFormat("while (true)\n" 967 " f();"); 968 verifyFormat("while () {\n}"); 969 verifyFormat("while () {\n" 970 " f();\n" 971 "}"); 972 } 973 974 TEST_F(FormatTest, FormatsDoWhile) { 975 verifyFormat("do {\n" 976 " do_something();\n" 977 "} while (something());"); 978 verifyFormat("do\n" 979 " do_something();\n" 980 "while (something());"); 981 } 982 983 TEST_F(FormatTest, FormatsSwitchStatement) { 984 verifyFormat("switch (x) {\n" 985 "case 1:\n" 986 " f();\n" 987 " break;\n" 988 "case kFoo:\n" 989 "case ns::kBar:\n" 990 "case kBaz:\n" 991 " break;\n" 992 "default:\n" 993 " g();\n" 994 " break;\n" 995 "}"); 996 verifyFormat("switch (x) {\n" 997 "case 1: {\n" 998 " f();\n" 999 " break;\n" 1000 "}\n" 1001 "case 2: {\n" 1002 " break;\n" 1003 "}\n" 1004 "}"); 1005 verifyFormat("switch (x) {\n" 1006 "case 1: {\n" 1007 " f();\n" 1008 " {\n" 1009 " g();\n" 1010 " h();\n" 1011 " }\n" 1012 " break;\n" 1013 "}\n" 1014 "}"); 1015 verifyFormat("switch (x) {\n" 1016 "case 1: {\n" 1017 " f();\n" 1018 " if (foo) {\n" 1019 " g();\n" 1020 " h();\n" 1021 " }\n" 1022 " break;\n" 1023 "}\n" 1024 "}"); 1025 verifyFormat("switch (x) {\n" 1026 "case 1: {\n" 1027 " f();\n" 1028 " g();\n" 1029 "} break;\n" 1030 "}"); 1031 verifyFormat("switch (test)\n" 1032 " ;"); 1033 verifyFormat("switch (x) {\n" 1034 "default: {\n" 1035 " // Do nothing.\n" 1036 "}\n" 1037 "}"); 1038 verifyFormat("switch (x) {\n" 1039 "// comment\n" 1040 "// if 1, do f()\n" 1041 "case 1:\n" 1042 " f();\n" 1043 "}"); 1044 verifyFormat("switch (x) {\n" 1045 "case 1:\n" 1046 " // Do amazing stuff\n" 1047 " {\n" 1048 " f();\n" 1049 " g();\n" 1050 " }\n" 1051 " break;\n" 1052 "}"); 1053 verifyFormat("#define A \\\n" 1054 " switch (x) { \\\n" 1055 " case a: \\\n" 1056 " foo = b; \\\n" 1057 " }", 1058 getLLVMStyleWithColumns(20)); 1059 verifyFormat("#define OPERATION_CASE(name) \\\n" 1060 " case OP_name: \\\n" 1061 " return operations::Operation##name\n", 1062 getLLVMStyleWithColumns(40)); 1063 verifyFormat("switch (x) {\n" 1064 "case 1:;\n" 1065 "default:;\n" 1066 " int i;\n" 1067 "}"); 1068 1069 verifyGoogleFormat("switch (x) {\n" 1070 " case 1:\n" 1071 " f();\n" 1072 " break;\n" 1073 " case kFoo:\n" 1074 " case ns::kBar:\n" 1075 " case kBaz:\n" 1076 " break;\n" 1077 " default:\n" 1078 " g();\n" 1079 " break;\n" 1080 "}"); 1081 verifyGoogleFormat("switch (x) {\n" 1082 " case 1: {\n" 1083 " f();\n" 1084 " break;\n" 1085 " }\n" 1086 "}"); 1087 verifyGoogleFormat("switch (test)\n" 1088 " ;"); 1089 1090 verifyGoogleFormat("#define OPERATION_CASE(name) \\\n" 1091 " case OP_name: \\\n" 1092 " return operations::Operation##name\n"); 1093 verifyGoogleFormat("Operation codeToOperation(OperationCode OpCode) {\n" 1094 " // Get the correction operation class.\n" 1095 " switch (OpCode) {\n" 1096 " CASE(Add);\n" 1097 " CASE(Subtract);\n" 1098 " default:\n" 1099 " return operations::Unknown;\n" 1100 " }\n" 1101 "#undef OPERATION_CASE\n" 1102 "}"); 1103 verifyFormat("DEBUG({\n" 1104 " switch (x) {\n" 1105 " case A:\n" 1106 " f();\n" 1107 " break;\n" 1108 " // fallthrough\n" 1109 " case B:\n" 1110 " g();\n" 1111 " break;\n" 1112 " }\n" 1113 "});"); 1114 EXPECT_EQ("DEBUG({\n" 1115 " switch (x) {\n" 1116 " case A:\n" 1117 " f();\n" 1118 " break;\n" 1119 " // On B:\n" 1120 " case B:\n" 1121 " g();\n" 1122 " break;\n" 1123 " }\n" 1124 "});", 1125 format("DEBUG({\n" 1126 " switch (x) {\n" 1127 " case A:\n" 1128 " f();\n" 1129 " break;\n" 1130 " // On B:\n" 1131 " case B:\n" 1132 " g();\n" 1133 " break;\n" 1134 " }\n" 1135 "});", 1136 getLLVMStyle())); 1137 EXPECT_EQ("switch (n) {\n" 1138 "case 0: {\n" 1139 " return false;\n" 1140 "}\n" 1141 "default: {\n" 1142 " return true;\n" 1143 "}\n" 1144 "}", 1145 format("switch (n)\n" 1146 "{\n" 1147 "case 0: {\n" 1148 " return false;\n" 1149 "}\n" 1150 "default: {\n" 1151 " return true;\n" 1152 "}\n" 1153 "}", 1154 getLLVMStyle())); 1155 verifyFormat("switch (a) {\n" 1156 "case (b):\n" 1157 " return;\n" 1158 "}"); 1159 1160 verifyFormat("switch (a) {\n" 1161 "case some_namespace::\n" 1162 " some_constant:\n" 1163 " return;\n" 1164 "}", 1165 getLLVMStyleWithColumns(34)); 1166 1167 FormatStyle Style = getLLVMStyle(); 1168 Style.IndentCaseLabels = true; 1169 Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Never; 1170 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 1171 Style.BraceWrapping.AfterCaseLabel = true; 1172 Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always; 1173 EXPECT_EQ("switch (n)\n" 1174 "{\n" 1175 " case 0:\n" 1176 " {\n" 1177 " return false;\n" 1178 " }\n" 1179 " default:\n" 1180 " {\n" 1181 " return true;\n" 1182 " }\n" 1183 "}", 1184 format("switch (n) {\n" 1185 " case 0: {\n" 1186 " return false;\n" 1187 " }\n" 1188 " default: {\n" 1189 " return true;\n" 1190 " }\n" 1191 "}", 1192 Style)); 1193 Style.BraceWrapping.AfterCaseLabel = false; 1194 EXPECT_EQ("switch (n)\n" 1195 "{\n" 1196 " case 0: {\n" 1197 " return false;\n" 1198 " }\n" 1199 " default: {\n" 1200 " return true;\n" 1201 " }\n" 1202 "}", 1203 format("switch (n) {\n" 1204 " case 0:\n" 1205 " {\n" 1206 " return false;\n" 1207 " }\n" 1208 " default:\n" 1209 " {\n" 1210 " return true;\n" 1211 " }\n" 1212 "}", 1213 Style)); 1214 } 1215 1216 TEST_F(FormatTest, CaseRanges) { 1217 verifyFormat("switch (x) {\n" 1218 "case 'A' ... 'Z':\n" 1219 "case 1 ... 5:\n" 1220 "case a ... b:\n" 1221 " break;\n" 1222 "}"); 1223 } 1224 1225 TEST_F(FormatTest, ShortCaseLabels) { 1226 FormatStyle Style = getLLVMStyle(); 1227 Style.AllowShortCaseLabelsOnASingleLine = true; 1228 verifyFormat("switch (a) {\n" 1229 "case 1: x = 1; break;\n" 1230 "case 2: return;\n" 1231 "case 3:\n" 1232 "case 4:\n" 1233 "case 5: return;\n" 1234 "case 6: // comment\n" 1235 " return;\n" 1236 "case 7:\n" 1237 " // comment\n" 1238 " return;\n" 1239 "case 8:\n" 1240 " x = 8; // comment\n" 1241 " break;\n" 1242 "default: y = 1; break;\n" 1243 "}", 1244 Style); 1245 verifyFormat("switch (a) {\n" 1246 "case 0: return; // comment\n" 1247 "case 1: break; // comment\n" 1248 "case 2: return;\n" 1249 "// comment\n" 1250 "case 3: return;\n" 1251 "// comment 1\n" 1252 "// comment 2\n" 1253 "// comment 3\n" 1254 "case 4: break; /* comment */\n" 1255 "case 5:\n" 1256 " // comment\n" 1257 " break;\n" 1258 "case 6: /* comment */ x = 1; break;\n" 1259 "case 7: x = /* comment */ 1; break;\n" 1260 "case 8:\n" 1261 " x = 1; /* comment */\n" 1262 " break;\n" 1263 "case 9:\n" 1264 " break; // comment line 1\n" 1265 " // comment line 2\n" 1266 "}", 1267 Style); 1268 EXPECT_EQ("switch (a) {\n" 1269 "case 1:\n" 1270 " x = 8;\n" 1271 " // fall through\n" 1272 "case 2: x = 8;\n" 1273 "// comment\n" 1274 "case 3:\n" 1275 " return; /* comment line 1\n" 1276 " * comment line 2 */\n" 1277 "case 4: i = 8;\n" 1278 "// something else\n" 1279 "#if FOO\n" 1280 "case 5: break;\n" 1281 "#endif\n" 1282 "}", 1283 format("switch (a) {\n" 1284 "case 1: x = 8;\n" 1285 " // fall through\n" 1286 "case 2:\n" 1287 " x = 8;\n" 1288 "// comment\n" 1289 "case 3:\n" 1290 " return; /* comment line 1\n" 1291 " * comment line 2 */\n" 1292 "case 4:\n" 1293 " i = 8;\n" 1294 "// something else\n" 1295 "#if FOO\n" 1296 "case 5: break;\n" 1297 "#endif\n" 1298 "}", 1299 Style)); 1300 EXPECT_EQ("switch (a) {\n" 1301 "case 0:\n" 1302 " return; // long long long long long long long long long long " 1303 "long long comment\n" 1304 " // line\n" 1305 "}", 1306 format("switch (a) {\n" 1307 "case 0: return; // long long long long long long long long " 1308 "long long long long comment line\n" 1309 "}", 1310 Style)); 1311 EXPECT_EQ("switch (a) {\n" 1312 "case 0:\n" 1313 " return; /* long long long long long long long long long long " 1314 "long long comment\n" 1315 " line */\n" 1316 "}", 1317 format("switch (a) {\n" 1318 "case 0: return; /* long long long long long long long long " 1319 "long long long long comment line */\n" 1320 "}", 1321 Style)); 1322 verifyFormat("switch (a) {\n" 1323 "#if FOO\n" 1324 "case 0: return 0;\n" 1325 "#endif\n" 1326 "}", 1327 Style); 1328 verifyFormat("switch (a) {\n" 1329 "case 1: {\n" 1330 "}\n" 1331 "case 2: {\n" 1332 " return;\n" 1333 "}\n" 1334 "case 3: {\n" 1335 " x = 1;\n" 1336 " return;\n" 1337 "}\n" 1338 "case 4:\n" 1339 " if (x)\n" 1340 " return;\n" 1341 "}", 1342 Style); 1343 Style.ColumnLimit = 21; 1344 verifyFormat("switch (a) {\n" 1345 "case 1: x = 1; break;\n" 1346 "case 2: return;\n" 1347 "case 3:\n" 1348 "case 4:\n" 1349 "case 5: return;\n" 1350 "default:\n" 1351 " y = 1;\n" 1352 " break;\n" 1353 "}", 1354 Style); 1355 Style.ColumnLimit = 80; 1356 Style.AllowShortCaseLabelsOnASingleLine = false; 1357 Style.IndentCaseLabels = true; 1358 EXPECT_EQ("switch (n) {\n" 1359 " default /*comments*/:\n" 1360 " return true;\n" 1361 " case 0:\n" 1362 " return false;\n" 1363 "}", 1364 format("switch (n) {\n" 1365 "default/*comments*/:\n" 1366 " return true;\n" 1367 "case 0:\n" 1368 " return false;\n" 1369 "}", 1370 Style)); 1371 Style.AllowShortCaseLabelsOnASingleLine = true; 1372 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 1373 Style.BraceWrapping.AfterCaseLabel = true; 1374 Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always; 1375 EXPECT_EQ("switch (n)\n" 1376 "{\n" 1377 " case 0:\n" 1378 " {\n" 1379 " return false;\n" 1380 " }\n" 1381 " default:\n" 1382 " {\n" 1383 " return true;\n" 1384 " }\n" 1385 "}", 1386 format("switch (n) {\n" 1387 " case 0: {\n" 1388 " return false;\n" 1389 " }\n" 1390 " default:\n" 1391 " {\n" 1392 " return true;\n" 1393 " }\n" 1394 "}", 1395 Style)); 1396 } 1397 1398 TEST_F(FormatTest, FormatsLabels) { 1399 verifyFormat("void f() {\n" 1400 " some_code();\n" 1401 "test_label:\n" 1402 " some_other_code();\n" 1403 " {\n" 1404 " some_more_code();\n" 1405 " another_label:\n" 1406 " some_more_code();\n" 1407 " }\n" 1408 "}"); 1409 verifyFormat("{\n" 1410 " some_code();\n" 1411 "test_label:\n" 1412 " some_other_code();\n" 1413 "}"); 1414 verifyFormat("{\n" 1415 " some_code();\n" 1416 "test_label:;\n" 1417 " int i = 0;\n" 1418 "}"); 1419 FormatStyle Style = getLLVMStyle(); 1420 Style.IndentGotoLabels = false; 1421 verifyFormat("void f() {\n" 1422 " some_code();\n" 1423 "test_label:\n" 1424 " some_other_code();\n" 1425 " {\n" 1426 " some_more_code();\n" 1427 "another_label:\n" 1428 " some_more_code();\n" 1429 " }\n" 1430 "}", 1431 Style); 1432 verifyFormat("{\n" 1433 " some_code();\n" 1434 "test_label:\n" 1435 " some_other_code();\n" 1436 "}", 1437 Style); 1438 verifyFormat("{\n" 1439 " some_code();\n" 1440 "test_label:;\n" 1441 " int i = 0;\n" 1442 "}"); 1443 } 1444 1445 TEST_F(FormatTest, MultiLineControlStatements) { 1446 FormatStyle Style = getLLVMStyle(); 1447 Style.BreakBeforeBraces = FormatStyle::BraceBreakingStyle::BS_Custom; 1448 Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_MultiLine; 1449 Style.ColumnLimit = 20; 1450 // Short lines should keep opening brace on same line. 1451 EXPECT_EQ("if (foo) {\n" 1452 " bar();\n" 1453 "}", 1454 format("if(foo){bar();}", Style)); 1455 EXPECT_EQ("if (foo) {\n" 1456 " bar();\n" 1457 "} else {\n" 1458 " baz();\n" 1459 "}", 1460 format("if(foo){bar();}else{baz();}", Style)); 1461 EXPECT_EQ("if (foo && bar) {\n" 1462 " baz();\n" 1463 "}", 1464 format("if(foo&&bar){baz();}", Style)); 1465 EXPECT_EQ("if (foo) {\n" 1466 " bar();\n" 1467 "} else if (baz) {\n" 1468 " quux();\n" 1469 "}", 1470 format("if(foo){bar();}else if(baz){quux();}", Style)); 1471 EXPECT_EQ( 1472 "if (foo) {\n" 1473 " bar();\n" 1474 "} else if (baz) {\n" 1475 " quux();\n" 1476 "} else {\n" 1477 " foobar();\n" 1478 "}", 1479 format("if(foo){bar();}else if(baz){quux();}else{foobar();}", Style)); 1480 EXPECT_EQ("for (;;) {\n" 1481 " foo();\n" 1482 "}", 1483 format("for(;;){foo();}")); 1484 EXPECT_EQ("while (1) {\n" 1485 " foo();\n" 1486 "}", 1487 format("while(1){foo();}", Style)); 1488 EXPECT_EQ("switch (foo) {\n" 1489 "case bar:\n" 1490 " return;\n" 1491 "}", 1492 format("switch(foo){case bar:return;}", Style)); 1493 EXPECT_EQ("try {\n" 1494 " foo();\n" 1495 "} catch (...) {\n" 1496 " bar();\n" 1497 "}", 1498 format("try{foo();}catch(...){bar();}", Style)); 1499 EXPECT_EQ("do {\n" 1500 " foo();\n" 1501 "} while (bar &&\n" 1502 " baz);", 1503 format("do{foo();}while(bar&&baz);", Style)); 1504 // Long lines should put opening brace on new line. 1505 EXPECT_EQ("if (foo && bar &&\n" 1506 " baz)\n" 1507 "{\n" 1508 " quux();\n" 1509 "}", 1510 format("if(foo&&bar&&baz){quux();}", Style)); 1511 EXPECT_EQ("if (foo && bar &&\n" 1512 " baz)\n" 1513 "{\n" 1514 " quux();\n" 1515 "}", 1516 format("if (foo && bar &&\n" 1517 " baz) {\n" 1518 " quux();\n" 1519 "}", 1520 Style)); 1521 EXPECT_EQ("if (foo) {\n" 1522 " bar();\n" 1523 "} else if (baz ||\n" 1524 " quux)\n" 1525 "{\n" 1526 " foobar();\n" 1527 "}", 1528 format("if(foo){bar();}else if(baz||quux){foobar();}", Style)); 1529 EXPECT_EQ( 1530 "if (foo) {\n" 1531 " bar();\n" 1532 "} else if (baz ||\n" 1533 " quux)\n" 1534 "{\n" 1535 " foobar();\n" 1536 "} else {\n" 1537 " barbaz();\n" 1538 "}", 1539 format("if(foo){bar();}else if(baz||quux){foobar();}else{barbaz();}", 1540 Style)); 1541 EXPECT_EQ("for (int i = 0;\n" 1542 " i < 10; ++i)\n" 1543 "{\n" 1544 " foo();\n" 1545 "}", 1546 format("for(int i=0;i<10;++i){foo();}", Style)); 1547 EXPECT_EQ("while (foo || bar ||\n" 1548 " baz)\n" 1549 "{\n" 1550 " quux();\n" 1551 "}", 1552 format("while(foo||bar||baz){quux();}", Style)); 1553 EXPECT_EQ("switch (\n" 1554 " foo = barbaz)\n" 1555 "{\n" 1556 "case quux:\n" 1557 " return;\n" 1558 "}", 1559 format("switch(foo=barbaz){case quux:return;}", Style)); 1560 EXPECT_EQ("try {\n" 1561 " foo();\n" 1562 "} catch (\n" 1563 " Exception &bar)\n" 1564 "{\n" 1565 " baz();\n" 1566 "}", 1567 format("try{foo();}catch(Exception&bar){baz();}", Style)); 1568 } 1569 1570 //===----------------------------------------------------------------------===// 1571 // Tests for classes, namespaces, etc. 1572 //===----------------------------------------------------------------------===// 1573 1574 TEST_F(FormatTest, DoesNotBreakSemiAfterClassDecl) { 1575 verifyFormat("class A {};"); 1576 } 1577 1578 TEST_F(FormatTest, UnderstandsAccessSpecifiers) { 1579 verifyFormat("class A {\n" 1580 "public:\n" 1581 "public: // comment\n" 1582 "protected:\n" 1583 "private:\n" 1584 " void f() {}\n" 1585 "};"); 1586 verifyFormat("export class A {\n" 1587 "public:\n" 1588 "public: // comment\n" 1589 "protected:\n" 1590 "private:\n" 1591 " void f() {}\n" 1592 "};"); 1593 verifyGoogleFormat("class A {\n" 1594 " public:\n" 1595 " protected:\n" 1596 " private:\n" 1597 " void f() {}\n" 1598 "};"); 1599 verifyGoogleFormat("export class A {\n" 1600 " public:\n" 1601 " protected:\n" 1602 " private:\n" 1603 " void f() {}\n" 1604 "};"); 1605 verifyFormat("class A {\n" 1606 "public slots:\n" 1607 " void f1() {}\n" 1608 "public Q_SLOTS:\n" 1609 " void f2() {}\n" 1610 "protected slots:\n" 1611 " void f3() {}\n" 1612 "protected Q_SLOTS:\n" 1613 " void f4() {}\n" 1614 "private slots:\n" 1615 " void f5() {}\n" 1616 "private Q_SLOTS:\n" 1617 " void f6() {}\n" 1618 "signals:\n" 1619 " void g1();\n" 1620 "Q_SIGNALS:\n" 1621 " void g2();\n" 1622 "};"); 1623 1624 // Don't interpret 'signals' the wrong way. 1625 verifyFormat("signals.set();"); 1626 verifyFormat("for (Signals signals : f()) {\n}"); 1627 verifyFormat("{\n" 1628 " signals.set(); // This needs indentation.\n" 1629 "}"); 1630 verifyFormat("void f() {\n" 1631 "label:\n" 1632 " signals.baz();\n" 1633 "}"); 1634 } 1635 1636 TEST_F(FormatTest, SeparatesLogicalBlocks) { 1637 EXPECT_EQ("class A {\n" 1638 "public:\n" 1639 " void f();\n" 1640 "\n" 1641 "private:\n" 1642 " void g() {}\n" 1643 " // test\n" 1644 "protected:\n" 1645 " int h;\n" 1646 "};", 1647 format("class A {\n" 1648 "public:\n" 1649 "void f();\n" 1650 "private:\n" 1651 "void g() {}\n" 1652 "// test\n" 1653 "protected:\n" 1654 "int h;\n" 1655 "};")); 1656 EXPECT_EQ("class A {\n" 1657 "protected:\n" 1658 "public:\n" 1659 " void f();\n" 1660 "};", 1661 format("class A {\n" 1662 "protected:\n" 1663 "\n" 1664 "public:\n" 1665 "\n" 1666 " void f();\n" 1667 "};")); 1668 1669 // Even ensure proper spacing inside macros. 1670 EXPECT_EQ("#define B \\\n" 1671 " class A { \\\n" 1672 " protected: \\\n" 1673 " public: \\\n" 1674 " void f(); \\\n" 1675 " };", 1676 format("#define B \\\n" 1677 " class A { \\\n" 1678 " protected: \\\n" 1679 " \\\n" 1680 " public: \\\n" 1681 " \\\n" 1682 " void f(); \\\n" 1683 " };", 1684 getGoogleStyle())); 1685 // But don't remove empty lines after macros ending in access specifiers. 1686 EXPECT_EQ("#define A private:\n" 1687 "\n" 1688 "int i;", 1689 format("#define A private:\n" 1690 "\n" 1691 "int i;")); 1692 } 1693 1694 TEST_F(FormatTest, FormatsClasses) { 1695 verifyFormat("class A : public B {};"); 1696 verifyFormat("class A : public ::B {};"); 1697 1698 verifyFormat( 1699 "class AAAAAAAAAAAAAAAAAAAA : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n" 1700 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};"); 1701 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n" 1702 " : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n" 1703 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};"); 1704 verifyFormat( 1705 "class A : public B, public C, public D, public E, public F {};"); 1706 verifyFormat("class AAAAAAAAAAAA : public B,\n" 1707 " public C,\n" 1708 " public D,\n" 1709 " public E,\n" 1710 " public F,\n" 1711 " public G {};"); 1712 1713 verifyFormat("class\n" 1714 " ReallyReallyLongClassName {\n" 1715 " int i;\n" 1716 "};", 1717 getLLVMStyleWithColumns(32)); 1718 verifyFormat("struct aaaaaaaaaaaaa : public aaaaaaaaaaaaaaaaaaa< // break\n" 1719 " aaaaaaaaaaaaaaaa> {};"); 1720 verifyFormat("struct aaaaaaaaaaaaaaaaaaaa\n" 1721 " : public aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaa,\n" 1722 " aaaaaaaaaaaaaaaaaaaaaa> {};"); 1723 verifyFormat("template <class R, class C>\n" 1724 "struct Aaaaaaaaaaaaaaaaa<R (C::*)(int) const>\n" 1725 " : Aaaaaaaaaaaaaaaaa<R (C::*)(int)> {};"); 1726 verifyFormat("class ::A::B {};"); 1727 } 1728 1729 TEST_F(FormatTest, BreakInheritanceStyle) { 1730 FormatStyle StyleWithInheritanceBreakBeforeComma = getLLVMStyle(); 1731 StyleWithInheritanceBreakBeforeComma.BreakInheritanceList = 1732 FormatStyle::BILS_BeforeComma; 1733 verifyFormat("class MyClass : public X {};", 1734 StyleWithInheritanceBreakBeforeComma); 1735 verifyFormat("class MyClass\n" 1736 " : public X\n" 1737 " , public Y {};", 1738 StyleWithInheritanceBreakBeforeComma); 1739 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAA\n" 1740 " : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n" 1741 " , public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};", 1742 StyleWithInheritanceBreakBeforeComma); 1743 verifyFormat("struct aaaaaaaaaaaaa\n" 1744 " : public aaaaaaaaaaaaaaaaaaa< // break\n" 1745 " aaaaaaaaaaaaaaaa> {};", 1746 StyleWithInheritanceBreakBeforeComma); 1747 1748 FormatStyle StyleWithInheritanceBreakAfterColon = getLLVMStyle(); 1749 StyleWithInheritanceBreakAfterColon.BreakInheritanceList = 1750 FormatStyle::BILS_AfterColon; 1751 verifyFormat("class MyClass : public X {};", 1752 StyleWithInheritanceBreakAfterColon); 1753 verifyFormat("class MyClass : public X, public Y {};", 1754 StyleWithInheritanceBreakAfterColon); 1755 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAA :\n" 1756 " public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n" 1757 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};", 1758 StyleWithInheritanceBreakAfterColon); 1759 verifyFormat("struct aaaaaaaaaaaaa :\n" 1760 " public aaaaaaaaaaaaaaaaaaa< // break\n" 1761 " aaaaaaaaaaaaaaaa> {};", 1762 StyleWithInheritanceBreakAfterColon); 1763 } 1764 1765 TEST_F(FormatTest, FormatsVariableDeclarationsAfterStructOrClass) { 1766 verifyFormat("class A {\n} a, b;"); 1767 verifyFormat("struct A {\n} a, b;"); 1768 verifyFormat("union A {\n} a;"); 1769 } 1770 1771 TEST_F(FormatTest, FormatsEnum) { 1772 verifyFormat("enum {\n" 1773 " Zero,\n" 1774 " One = 1,\n" 1775 " Two = One + 1,\n" 1776 " Three = (One + Two),\n" 1777 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1778 " Five = (One, Two, Three, Four, 5)\n" 1779 "};"); 1780 verifyGoogleFormat("enum {\n" 1781 " Zero,\n" 1782 " One = 1,\n" 1783 " Two = One + 1,\n" 1784 " Three = (One + Two),\n" 1785 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1786 " Five = (One, Two, Three, Four, 5)\n" 1787 "};"); 1788 verifyFormat("enum Enum {};"); 1789 verifyFormat("enum {};"); 1790 verifyFormat("enum X E {} d;"); 1791 verifyFormat("enum __attribute__((...)) E {} d;"); 1792 verifyFormat("enum __declspec__((...)) E {} d;"); 1793 verifyFormat("enum {\n" 1794 " Bar = Foo<int, int>::value\n" 1795 "};", 1796 getLLVMStyleWithColumns(30)); 1797 1798 verifyFormat("enum ShortEnum { A, B, C };"); 1799 verifyGoogleFormat("enum ShortEnum { A, B, C };"); 1800 1801 EXPECT_EQ("enum KeepEmptyLines {\n" 1802 " ONE,\n" 1803 "\n" 1804 " TWO,\n" 1805 "\n" 1806 " THREE\n" 1807 "}", 1808 format("enum KeepEmptyLines {\n" 1809 " ONE,\n" 1810 "\n" 1811 " TWO,\n" 1812 "\n" 1813 "\n" 1814 " THREE\n" 1815 "}")); 1816 verifyFormat("enum E { // comment\n" 1817 " ONE,\n" 1818 " TWO\n" 1819 "};\n" 1820 "int i;"); 1821 // Not enums. 1822 verifyFormat("enum X f() {\n" 1823 " a();\n" 1824 " return 42;\n" 1825 "}"); 1826 verifyFormat("enum X Type::f() {\n" 1827 " a();\n" 1828 " return 42;\n" 1829 "}"); 1830 verifyFormat("enum ::X f() {\n" 1831 " a();\n" 1832 " return 42;\n" 1833 "}"); 1834 verifyFormat("enum ns::X f() {\n" 1835 " a();\n" 1836 " return 42;\n" 1837 "}"); 1838 } 1839 1840 TEST_F(FormatTest, FormatsEnumsWithErrors) { 1841 verifyFormat("enum Type {\n" 1842 " One = 0; // These semicolons should be commas.\n" 1843 " Two = 1;\n" 1844 "};"); 1845 verifyFormat("namespace n {\n" 1846 "enum Type {\n" 1847 " One,\n" 1848 " Two, // missing };\n" 1849 " int i;\n" 1850 "}\n" 1851 "void g() {}"); 1852 } 1853 1854 TEST_F(FormatTest, FormatsEnumStruct) { 1855 verifyFormat("enum struct {\n" 1856 " Zero,\n" 1857 " One = 1,\n" 1858 " Two = One + 1,\n" 1859 " Three = (One + Two),\n" 1860 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1861 " Five = (One, Two, Three, Four, 5)\n" 1862 "};"); 1863 verifyFormat("enum struct Enum {};"); 1864 verifyFormat("enum struct {};"); 1865 verifyFormat("enum struct X E {} d;"); 1866 verifyFormat("enum struct __attribute__((...)) E {} d;"); 1867 verifyFormat("enum struct __declspec__((...)) E {} d;"); 1868 verifyFormat("enum struct X f() {\n a();\n return 42;\n}"); 1869 } 1870 1871 TEST_F(FormatTest, FormatsEnumClass) { 1872 verifyFormat("enum class {\n" 1873 " Zero,\n" 1874 " One = 1,\n" 1875 " Two = One + 1,\n" 1876 " Three = (One + Two),\n" 1877 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1878 " Five = (One, Two, Three, Four, 5)\n" 1879 "};"); 1880 verifyFormat("enum class Enum {};"); 1881 verifyFormat("enum class {};"); 1882 verifyFormat("enum class X E {} d;"); 1883 verifyFormat("enum class __attribute__((...)) E {} d;"); 1884 verifyFormat("enum class __declspec__((...)) E {} d;"); 1885 verifyFormat("enum class X f() {\n a();\n return 42;\n}"); 1886 } 1887 1888 TEST_F(FormatTest, FormatsEnumTypes) { 1889 verifyFormat("enum X : int {\n" 1890 " A, // Force multiple lines.\n" 1891 " B\n" 1892 "};"); 1893 verifyFormat("enum X : int { A, B };"); 1894 verifyFormat("enum X : std::uint32_t { A, B };"); 1895 } 1896 1897 TEST_F(FormatTest, FormatsTypedefEnum) { 1898 FormatStyle Style = getLLVMStyle(); 1899 Style.ColumnLimit = 40; 1900 verifyFormat("typedef enum {} EmptyEnum;"); 1901 verifyFormat("typedef enum { A, B, C } ShortEnum;"); 1902 verifyFormat("typedef enum {\n" 1903 " ZERO = 0,\n" 1904 " ONE = 1,\n" 1905 " TWO = 2,\n" 1906 " THREE = 3\n" 1907 "} LongEnum;", 1908 Style); 1909 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 1910 Style.BraceWrapping.AfterEnum = true; 1911 verifyFormat("typedef enum {} EmptyEnum;"); 1912 verifyFormat("typedef enum { A, B, C } ShortEnum;"); 1913 verifyFormat("typedef enum\n" 1914 "{\n" 1915 " ZERO = 0,\n" 1916 " ONE = 1,\n" 1917 " TWO = 2,\n" 1918 " THREE = 3\n" 1919 "} LongEnum;", 1920 Style); 1921 } 1922 1923 TEST_F(FormatTest, FormatsNSEnums) { 1924 verifyGoogleFormat("typedef NS_ENUM(NSInteger, SomeName) { AAA, BBB }"); 1925 verifyGoogleFormat( 1926 "typedef NS_CLOSED_ENUM(NSInteger, SomeName) { AAA, BBB }"); 1927 verifyGoogleFormat("typedef NS_ENUM(NSInteger, MyType) {\n" 1928 " // Information about someDecentlyLongValue.\n" 1929 " someDecentlyLongValue,\n" 1930 " // Information about anotherDecentlyLongValue.\n" 1931 " anotherDecentlyLongValue,\n" 1932 " // Information about aThirdDecentlyLongValue.\n" 1933 " aThirdDecentlyLongValue\n" 1934 "};"); 1935 verifyGoogleFormat("typedef NS_CLOSED_ENUM(NSInteger, MyType) {\n" 1936 " // Information about someDecentlyLongValue.\n" 1937 " someDecentlyLongValue,\n" 1938 " // Information about anotherDecentlyLongValue.\n" 1939 " anotherDecentlyLongValue,\n" 1940 " // Information about aThirdDecentlyLongValue.\n" 1941 " aThirdDecentlyLongValue\n" 1942 "};"); 1943 verifyGoogleFormat("typedef NS_OPTIONS(NSInteger, MyType) {\n" 1944 " a = 1,\n" 1945 " b = 2,\n" 1946 " c = 3,\n" 1947 "};"); 1948 verifyGoogleFormat("typedef CF_ENUM(NSInteger, MyType) {\n" 1949 " a = 1,\n" 1950 " b = 2,\n" 1951 " c = 3,\n" 1952 "};"); 1953 verifyGoogleFormat("typedef CF_CLOSED_ENUM(NSInteger, MyType) {\n" 1954 " a = 1,\n" 1955 " b = 2,\n" 1956 " c = 3,\n" 1957 "};"); 1958 verifyGoogleFormat("typedef CF_OPTIONS(NSInteger, MyType) {\n" 1959 " a = 1,\n" 1960 " b = 2,\n" 1961 " c = 3,\n" 1962 "};"); 1963 } 1964 1965 TEST_F(FormatTest, FormatsBitfields) { 1966 verifyFormat("struct Bitfields {\n" 1967 " unsigned sClass : 8;\n" 1968 " unsigned ValueKind : 2;\n" 1969 "};"); 1970 verifyFormat("struct A {\n" 1971 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa : 1,\n" 1972 " bbbbbbbbbbbbbbbbbbbbbbbbb;\n" 1973 "};"); 1974 verifyFormat("struct MyStruct {\n" 1975 " uchar data;\n" 1976 " uchar : 8;\n" 1977 " uchar : 8;\n" 1978 " uchar other;\n" 1979 "};"); 1980 } 1981 1982 TEST_F(FormatTest, FormatsNamespaces) { 1983 FormatStyle LLVMWithNoNamespaceFix = getLLVMStyle(); 1984 LLVMWithNoNamespaceFix.FixNamespaceComments = false; 1985 1986 verifyFormat("namespace some_namespace {\n" 1987 "class A {};\n" 1988 "void f() { f(); }\n" 1989 "}", 1990 LLVMWithNoNamespaceFix); 1991 verifyFormat("namespace N::inline D {\n" 1992 "class A {};\n" 1993 "void f() { f(); }\n" 1994 "}", 1995 LLVMWithNoNamespaceFix); 1996 verifyFormat("namespace N::inline D::E {\n" 1997 "class A {};\n" 1998 "void f() { f(); }\n" 1999 "}", 2000 LLVMWithNoNamespaceFix); 2001 verifyFormat("namespace [[deprecated(\"foo[bar\")]] some_namespace {\n" 2002 "class A {};\n" 2003 "void f() { f(); }\n" 2004 "}", 2005 LLVMWithNoNamespaceFix); 2006 verifyFormat("/* something */ namespace some_namespace {\n" 2007 "class A {};\n" 2008 "void f() { f(); }\n" 2009 "}", 2010 LLVMWithNoNamespaceFix); 2011 verifyFormat("namespace {\n" 2012 "class A {};\n" 2013 "void f() { f(); }\n" 2014 "}", 2015 LLVMWithNoNamespaceFix); 2016 verifyFormat("/* something */ namespace {\n" 2017 "class A {};\n" 2018 "void f() { f(); }\n" 2019 "}", 2020 LLVMWithNoNamespaceFix); 2021 verifyFormat("inline namespace X {\n" 2022 "class A {};\n" 2023 "void f() { f(); }\n" 2024 "}", 2025 LLVMWithNoNamespaceFix); 2026 verifyFormat("/* something */ inline namespace X {\n" 2027 "class A {};\n" 2028 "void f() { f(); }\n" 2029 "}", 2030 LLVMWithNoNamespaceFix); 2031 verifyFormat("export namespace X {\n" 2032 "class A {};\n" 2033 "void f() { f(); }\n" 2034 "}", 2035 LLVMWithNoNamespaceFix); 2036 verifyFormat("using namespace some_namespace;\n" 2037 "class A {};\n" 2038 "void f() { f(); }", 2039 LLVMWithNoNamespaceFix); 2040 2041 // This code is more common than we thought; if we 2042 // layout this correctly the semicolon will go into 2043 // its own line, which is undesirable. 2044 verifyFormat("namespace {};", LLVMWithNoNamespaceFix); 2045 verifyFormat("namespace {\n" 2046 "class A {};\n" 2047 "};", 2048 LLVMWithNoNamespaceFix); 2049 2050 verifyFormat("namespace {\n" 2051 "int SomeVariable = 0; // comment\n" 2052 "} // namespace", 2053 LLVMWithNoNamespaceFix); 2054 EXPECT_EQ("#ifndef HEADER_GUARD\n" 2055 "#define HEADER_GUARD\n" 2056 "namespace my_namespace {\n" 2057 "int i;\n" 2058 "} // my_namespace\n" 2059 "#endif // HEADER_GUARD", 2060 format("#ifndef HEADER_GUARD\n" 2061 " #define HEADER_GUARD\n" 2062 " namespace my_namespace {\n" 2063 "int i;\n" 2064 "} // my_namespace\n" 2065 "#endif // HEADER_GUARD", 2066 LLVMWithNoNamespaceFix)); 2067 2068 EXPECT_EQ("namespace A::B {\n" 2069 "class C {};\n" 2070 "}", 2071 format("namespace A::B {\n" 2072 "class C {};\n" 2073 "}", 2074 LLVMWithNoNamespaceFix)); 2075 2076 FormatStyle Style = getLLVMStyle(); 2077 Style.NamespaceIndentation = FormatStyle::NI_All; 2078 EXPECT_EQ("namespace out {\n" 2079 " int i;\n" 2080 " namespace in {\n" 2081 " int i;\n" 2082 " } // namespace in\n" 2083 "} // namespace out", 2084 format("namespace out {\n" 2085 "int i;\n" 2086 "namespace in {\n" 2087 "int i;\n" 2088 "} // namespace in\n" 2089 "} // namespace out", 2090 Style)); 2091 2092 Style.NamespaceIndentation = FormatStyle::NI_Inner; 2093 EXPECT_EQ("namespace out {\n" 2094 "int i;\n" 2095 "namespace in {\n" 2096 " int i;\n" 2097 "} // namespace in\n" 2098 "} // namespace out", 2099 format("namespace out {\n" 2100 "int i;\n" 2101 "namespace in {\n" 2102 "int i;\n" 2103 "} // namespace in\n" 2104 "} // namespace out", 2105 Style)); 2106 } 2107 2108 TEST_F(FormatTest, NamespaceMacros) { 2109 FormatStyle Style = getLLVMStyle(); 2110 Style.NamespaceMacros.push_back("TESTSUITE"); 2111 2112 verifyFormat("TESTSUITE(A) {\n" 2113 "int foo();\n" 2114 "} // TESTSUITE(A)", 2115 Style); 2116 2117 verifyFormat("TESTSUITE(A, B) {\n" 2118 "int foo();\n" 2119 "} // TESTSUITE(A)", 2120 Style); 2121 2122 // Properly indent according to NamespaceIndentation style 2123 Style.NamespaceIndentation = FormatStyle::NI_All; 2124 verifyFormat("TESTSUITE(A) {\n" 2125 " int foo();\n" 2126 "} // TESTSUITE(A)", 2127 Style); 2128 verifyFormat("TESTSUITE(A) {\n" 2129 " namespace B {\n" 2130 " int foo();\n" 2131 " } // namespace B\n" 2132 "} // TESTSUITE(A)", 2133 Style); 2134 verifyFormat("namespace A {\n" 2135 " TESTSUITE(B) {\n" 2136 " int foo();\n" 2137 " } // TESTSUITE(B)\n" 2138 "} // namespace A", 2139 Style); 2140 2141 Style.NamespaceIndentation = FormatStyle::NI_Inner; 2142 verifyFormat("TESTSUITE(A) {\n" 2143 "TESTSUITE(B) {\n" 2144 " int foo();\n" 2145 "} // TESTSUITE(B)\n" 2146 "} // TESTSUITE(A)", 2147 Style); 2148 verifyFormat("TESTSUITE(A) {\n" 2149 "namespace B {\n" 2150 " int foo();\n" 2151 "} // namespace B\n" 2152 "} // TESTSUITE(A)", 2153 Style); 2154 verifyFormat("namespace A {\n" 2155 "TESTSUITE(B) {\n" 2156 " int foo();\n" 2157 "} // TESTSUITE(B)\n" 2158 "} // namespace A", 2159 Style); 2160 2161 // Properly merge namespace-macros blocks in CompactNamespaces mode 2162 Style.NamespaceIndentation = FormatStyle::NI_None; 2163 Style.CompactNamespaces = true; 2164 verifyFormat("TESTSUITE(A) { TESTSUITE(B) {\n" 2165 "}} // TESTSUITE(A::B)", 2166 Style); 2167 2168 EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n" 2169 "}} // TESTSUITE(out::in)", 2170 format("TESTSUITE(out) {\n" 2171 "TESTSUITE(in) {\n" 2172 "} // TESTSUITE(in)\n" 2173 "} // TESTSUITE(out)", 2174 Style)); 2175 2176 EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n" 2177 "}} // TESTSUITE(out::in)", 2178 format("TESTSUITE(out) {\n" 2179 "TESTSUITE(in) {\n" 2180 "} // TESTSUITE(in)\n" 2181 "} // TESTSUITE(out)", 2182 Style)); 2183 2184 // Do not merge different namespaces/macros 2185 EXPECT_EQ("namespace out {\n" 2186 "TESTSUITE(in) {\n" 2187 "} // TESTSUITE(in)\n" 2188 "} // namespace out", 2189 format("namespace out {\n" 2190 "TESTSUITE(in) {\n" 2191 "} // TESTSUITE(in)\n" 2192 "} // namespace out", 2193 Style)); 2194 EXPECT_EQ("TESTSUITE(out) {\n" 2195 "namespace in {\n" 2196 "} // namespace in\n" 2197 "} // TESTSUITE(out)", 2198 format("TESTSUITE(out) {\n" 2199 "namespace in {\n" 2200 "} // namespace in\n" 2201 "} // TESTSUITE(out)", 2202 Style)); 2203 Style.NamespaceMacros.push_back("FOOBAR"); 2204 EXPECT_EQ("TESTSUITE(out) {\n" 2205 "FOOBAR(in) {\n" 2206 "} // FOOBAR(in)\n" 2207 "} // TESTSUITE(out)", 2208 format("TESTSUITE(out) {\n" 2209 "FOOBAR(in) {\n" 2210 "} // FOOBAR(in)\n" 2211 "} // TESTSUITE(out)", 2212 Style)); 2213 } 2214 2215 TEST_F(FormatTest, FormatsCompactNamespaces) { 2216 FormatStyle Style = getLLVMStyle(); 2217 Style.CompactNamespaces = true; 2218 Style.NamespaceMacros.push_back("TESTSUITE"); 2219 2220 verifyFormat("namespace A { namespace B {\n" 2221 "}} // namespace A::B", 2222 Style); 2223 2224 EXPECT_EQ("namespace out { namespace in {\n" 2225 "}} // namespace out::in", 2226 format("namespace out {\n" 2227 "namespace in {\n" 2228 "} // namespace in\n" 2229 "} // namespace out", 2230 Style)); 2231 2232 // Only namespaces which have both consecutive opening and end get compacted 2233 EXPECT_EQ("namespace out {\n" 2234 "namespace in1 {\n" 2235 "} // namespace in1\n" 2236 "namespace in2 {\n" 2237 "} // namespace in2\n" 2238 "} // namespace out", 2239 format("namespace out {\n" 2240 "namespace in1 {\n" 2241 "} // namespace in1\n" 2242 "namespace in2 {\n" 2243 "} // namespace in2\n" 2244 "} // namespace out", 2245 Style)); 2246 2247 EXPECT_EQ("namespace out {\n" 2248 "int i;\n" 2249 "namespace in {\n" 2250 "int j;\n" 2251 "} // namespace in\n" 2252 "int k;\n" 2253 "} // namespace out", 2254 format("namespace out { int i;\n" 2255 "namespace in { int j; } // namespace in\n" 2256 "int k; } // namespace out", 2257 Style)); 2258 2259 EXPECT_EQ("namespace A { namespace B { namespace C {\n" 2260 "}}} // namespace A::B::C\n", 2261 format("namespace A { namespace B {\n" 2262 "namespace C {\n" 2263 "}} // namespace B::C\n" 2264 "} // namespace A\n", 2265 Style)); 2266 2267 Style.ColumnLimit = 40; 2268 EXPECT_EQ("namespace aaaaaaaaaa {\n" 2269 "namespace bbbbbbbbbb {\n" 2270 "}} // namespace aaaaaaaaaa::bbbbbbbbbb", 2271 format("namespace aaaaaaaaaa {\n" 2272 "namespace bbbbbbbbbb {\n" 2273 "} // namespace bbbbbbbbbb\n" 2274 "} // namespace aaaaaaaaaa", 2275 Style)); 2276 2277 EXPECT_EQ("namespace aaaaaa { namespace bbbbbb {\n" 2278 "namespace cccccc {\n" 2279 "}}} // namespace aaaaaa::bbbbbb::cccccc", 2280 format("namespace aaaaaa {\n" 2281 "namespace bbbbbb {\n" 2282 "namespace cccccc {\n" 2283 "} // namespace cccccc\n" 2284 "} // namespace bbbbbb\n" 2285 "} // namespace aaaaaa", 2286 Style)); 2287 Style.ColumnLimit = 80; 2288 2289 // Extra semicolon after 'inner' closing brace prevents merging 2290 EXPECT_EQ("namespace out { namespace in {\n" 2291 "}; } // namespace out::in", 2292 format("namespace out {\n" 2293 "namespace in {\n" 2294 "}; // namespace in\n" 2295 "} // namespace out", 2296 Style)); 2297 2298 // Extra semicolon after 'outer' closing brace is conserved 2299 EXPECT_EQ("namespace out { namespace in {\n" 2300 "}}; // namespace out::in", 2301 format("namespace out {\n" 2302 "namespace in {\n" 2303 "} // namespace in\n" 2304 "}; // namespace out", 2305 Style)); 2306 2307 Style.NamespaceIndentation = FormatStyle::NI_All; 2308 EXPECT_EQ("namespace out { namespace in {\n" 2309 " int i;\n" 2310 "}} // namespace out::in", 2311 format("namespace out {\n" 2312 "namespace in {\n" 2313 "int i;\n" 2314 "} // namespace in\n" 2315 "} // namespace out", 2316 Style)); 2317 EXPECT_EQ("namespace out { namespace mid {\n" 2318 " namespace in {\n" 2319 " int j;\n" 2320 " } // namespace in\n" 2321 " int k;\n" 2322 "}} // namespace out::mid", 2323 format("namespace out { namespace mid {\n" 2324 "namespace in { int j; } // namespace in\n" 2325 "int k; }} // namespace out::mid", 2326 Style)); 2327 2328 Style.NamespaceIndentation = FormatStyle::NI_Inner; 2329 EXPECT_EQ("namespace out { namespace in {\n" 2330 " int i;\n" 2331 "}} // namespace out::in", 2332 format("namespace out {\n" 2333 "namespace in {\n" 2334 "int i;\n" 2335 "} // namespace in\n" 2336 "} // namespace out", 2337 Style)); 2338 EXPECT_EQ("namespace out { namespace mid { namespace in {\n" 2339 " int i;\n" 2340 "}}} // namespace out::mid::in", 2341 format("namespace out {\n" 2342 "namespace mid {\n" 2343 "namespace in {\n" 2344 "int i;\n" 2345 "} // namespace in\n" 2346 "} // namespace mid\n" 2347 "} // namespace out", 2348 Style)); 2349 } 2350 2351 TEST_F(FormatTest, FormatsExternC) { 2352 verifyFormat("extern \"C\" {\nint a;"); 2353 verifyFormat("extern \"C\" {}"); 2354 verifyFormat("extern \"C\" {\n" 2355 "int foo();\n" 2356 "}"); 2357 verifyFormat("extern \"C\" int foo() {}"); 2358 verifyFormat("extern \"C\" int foo();"); 2359 verifyFormat("extern \"C\" int foo() {\n" 2360 " int i = 42;\n" 2361 " return i;\n" 2362 "}"); 2363 2364 FormatStyle Style = getLLVMStyle(); 2365 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 2366 Style.BraceWrapping.AfterFunction = true; 2367 verifyFormat("extern \"C\" int foo() {}", Style); 2368 verifyFormat("extern \"C\" int foo();", Style); 2369 verifyFormat("extern \"C\" int foo()\n" 2370 "{\n" 2371 " int i = 42;\n" 2372 " return i;\n" 2373 "}", 2374 Style); 2375 2376 Style.BraceWrapping.AfterExternBlock = true; 2377 Style.BraceWrapping.SplitEmptyRecord = false; 2378 verifyFormat("extern \"C\"\n" 2379 "{}", 2380 Style); 2381 verifyFormat("extern \"C\"\n" 2382 "{\n" 2383 " int foo();\n" 2384 "}", 2385 Style); 2386 } 2387 2388 TEST_F(FormatTest, FormatsInlineASM) { 2389 verifyFormat("asm(\"xyz\" : \"=a\"(a), \"=d\"(b) : \"a\"(data));"); 2390 verifyFormat("asm(\"nop\" ::: \"memory\");"); 2391 verifyFormat( 2392 "asm(\"movq\\t%%rbx, %%rsi\\n\\t\"\n" 2393 " \"cpuid\\n\\t\"\n" 2394 " \"xchgq\\t%%rbx, %%rsi\\n\\t\"\n" 2395 " : \"=a\"(*rEAX), \"=S\"(*rEBX), \"=c\"(*rECX), \"=d\"(*rEDX)\n" 2396 " : \"a\"(value));"); 2397 EXPECT_EQ( 2398 "void NS_InvokeByIndex(void *that, unsigned int methodIndex) {\n" 2399 " __asm {\n" 2400 " mov edx,[that] // vtable in edx\n" 2401 " mov eax,methodIndex\n" 2402 " call [edx][eax*4] // stdcall\n" 2403 " }\n" 2404 "}", 2405 format("void NS_InvokeByIndex(void *that, unsigned int methodIndex) {\n" 2406 " __asm {\n" 2407 " mov edx,[that] // vtable in edx\n" 2408 " mov eax,methodIndex\n" 2409 " call [edx][eax*4] // stdcall\n" 2410 " }\n" 2411 "}")); 2412 EXPECT_EQ("_asm {\n" 2413 " xor eax, eax;\n" 2414 " cpuid;\n" 2415 "}", 2416 format("_asm {\n" 2417 " xor eax, eax;\n" 2418 " cpuid;\n" 2419 "}")); 2420 verifyFormat("void function() {\n" 2421 " // comment\n" 2422 " asm(\"\");\n" 2423 "}"); 2424 EXPECT_EQ("__asm {\n" 2425 "}\n" 2426 "int i;", 2427 format("__asm {\n" 2428 "}\n" 2429 "int i;")); 2430 } 2431 2432 TEST_F(FormatTest, FormatTryCatch) { 2433 verifyFormat("try {\n" 2434 " throw a * b;\n" 2435 "} catch (int a) {\n" 2436 " // Do nothing.\n" 2437 "} catch (...) {\n" 2438 " exit(42);\n" 2439 "}"); 2440 2441 // Function-level try statements. 2442 verifyFormat("int f() try { return 4; } catch (...) {\n" 2443 " return 5;\n" 2444 "}"); 2445 verifyFormat("class A {\n" 2446 " int a;\n" 2447 " A() try : a(0) {\n" 2448 " } catch (...) {\n" 2449 " throw;\n" 2450 " }\n" 2451 "};\n"); 2452 2453 // Incomplete try-catch blocks. 2454 verifyIncompleteFormat("try {} catch ("); 2455 } 2456 2457 TEST_F(FormatTest, FormatSEHTryCatch) { 2458 verifyFormat("__try {\n" 2459 " int a = b * c;\n" 2460 "} __except (EXCEPTION_EXECUTE_HANDLER) {\n" 2461 " // Do nothing.\n" 2462 "}"); 2463 2464 verifyFormat("__try {\n" 2465 " int a = b * c;\n" 2466 "} __finally {\n" 2467 " // Do nothing.\n" 2468 "}"); 2469 2470 verifyFormat("DEBUG({\n" 2471 " __try {\n" 2472 " } __finally {\n" 2473 " }\n" 2474 "});\n"); 2475 } 2476 2477 TEST_F(FormatTest, IncompleteTryCatchBlocks) { 2478 verifyFormat("try {\n" 2479 " f();\n" 2480 "} catch {\n" 2481 " g();\n" 2482 "}"); 2483 verifyFormat("try {\n" 2484 " f();\n" 2485 "} catch (A a) MACRO(x) {\n" 2486 " g();\n" 2487 "} catch (B b) MACRO(x) {\n" 2488 " g();\n" 2489 "}"); 2490 } 2491 2492 TEST_F(FormatTest, FormatTryCatchBraceStyles) { 2493 FormatStyle Style = getLLVMStyle(); 2494 for (auto BraceStyle : {FormatStyle::BS_Attach, FormatStyle::BS_Mozilla, 2495 FormatStyle::BS_WebKit}) { 2496 Style.BreakBeforeBraces = BraceStyle; 2497 verifyFormat("try {\n" 2498 " // something\n" 2499 "} catch (...) {\n" 2500 " // something\n" 2501 "}", 2502 Style); 2503 } 2504 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 2505 verifyFormat("try {\n" 2506 " // something\n" 2507 "}\n" 2508 "catch (...) {\n" 2509 " // something\n" 2510 "}", 2511 Style); 2512 verifyFormat("__try {\n" 2513 " // something\n" 2514 "}\n" 2515 "__finally {\n" 2516 " // something\n" 2517 "}", 2518 Style); 2519 verifyFormat("@try {\n" 2520 " // something\n" 2521 "}\n" 2522 "@finally {\n" 2523 " // something\n" 2524 "}", 2525 Style); 2526 Style.BreakBeforeBraces = FormatStyle::BS_Allman; 2527 verifyFormat("try\n" 2528 "{\n" 2529 " // something\n" 2530 "}\n" 2531 "catch (...)\n" 2532 "{\n" 2533 " // something\n" 2534 "}", 2535 Style); 2536 Style.BreakBeforeBraces = FormatStyle::BS_Whitesmiths; 2537 verifyFormat("try\n" 2538 " {\n" 2539 " // something white\n" 2540 " }\n" 2541 "catch (...)\n" 2542 " {\n" 2543 " // something white\n" 2544 " }", 2545 Style); 2546 Style.BreakBeforeBraces = FormatStyle::BS_GNU; 2547 verifyFormat("try\n" 2548 " {\n" 2549 " // something\n" 2550 " }\n" 2551 "catch (...)\n" 2552 " {\n" 2553 " // something\n" 2554 " }", 2555 Style); 2556 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 2557 Style.BraceWrapping.BeforeCatch = true; 2558 verifyFormat("try {\n" 2559 " // something\n" 2560 "}\n" 2561 "catch (...) {\n" 2562 " // something\n" 2563 "}", 2564 Style); 2565 } 2566 2567 TEST_F(FormatTest, StaticInitializers) { 2568 verifyFormat("static SomeClass SC = {1, 'a'};"); 2569 2570 verifyFormat("static SomeClass WithALoooooooooooooooooooongName = {\n" 2571 " 100000000, " 2572 "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"};"); 2573 2574 // Here, everything other than the "}" would fit on a line. 2575 verifyFormat("static int LooooooooooooooooooooooooongVariable[1] = {\n" 2576 " 10000000000000000000000000};"); 2577 EXPECT_EQ("S s = {a,\n" 2578 "\n" 2579 " b};", 2580 format("S s = {\n" 2581 " a,\n" 2582 "\n" 2583 " b\n" 2584 "};")); 2585 2586 // FIXME: This would fit into the column limit if we'd fit "{ {" on the first 2587 // line. However, the formatting looks a bit off and this probably doesn't 2588 // happen often in practice. 2589 verifyFormat("static int Variable[1] = {\n" 2590 " {1000000000000000000000000000000000000}};", 2591 getLLVMStyleWithColumns(40)); 2592 } 2593 2594 TEST_F(FormatTest, DesignatedInitializers) { 2595 verifyFormat("const struct A a = {.a = 1, .b = 2};"); 2596 verifyFormat("const struct A a = {.aaaaaaaaaa = 1,\n" 2597 " .bbbbbbbbbb = 2,\n" 2598 " .cccccccccc = 3,\n" 2599 " .dddddddddd = 4,\n" 2600 " .eeeeeeeeee = 5};"); 2601 verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n" 2602 " .aaaaaaaaaaaaaaaaaaaaaaaaaaa = 1,\n" 2603 " .bbbbbbbbbbbbbbbbbbbbbbbbbbb = 2,\n" 2604 " .ccccccccccccccccccccccccccc = 3,\n" 2605 " .ddddddddddddddddddddddddddd = 4,\n" 2606 " .eeeeeeeeeeeeeeeeeeeeeeeeeee = 5};"); 2607 2608 verifyGoogleFormat("const struct A a = {.a = 1, .b = 2};"); 2609 2610 verifyFormat("const struct A a = {[0] = 1, [1] = 2};"); 2611 verifyFormat("const struct A a = {[1] = aaaaaaaaaa,\n" 2612 " [2] = bbbbbbbbbb,\n" 2613 " [3] = cccccccccc,\n" 2614 " [4] = dddddddddd,\n" 2615 " [5] = eeeeeeeeee};"); 2616 verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n" 2617 " [1] = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 2618 " [2] = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" 2619 " [3] = cccccccccccccccccccccccccccccccccccccc,\n" 2620 " [4] = dddddddddddddddddddddddddddddddddddddd,\n" 2621 " [5] = eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee};"); 2622 } 2623 2624 TEST_F(FormatTest, NestedStaticInitializers) { 2625 verifyFormat("static A x = {{{}}};\n"); 2626 verifyFormat("static A x = {{{init1, init2, init3, init4},\n" 2627 " {init1, init2, init3, init4}}};", 2628 getLLVMStyleWithColumns(50)); 2629 2630 verifyFormat("somes Status::global_reps[3] = {\n" 2631 " {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n" 2632 " {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n" 2633 " {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};", 2634 getLLVMStyleWithColumns(60)); 2635 verifyGoogleFormat("SomeType Status::global_reps[3] = {\n" 2636 " {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n" 2637 " {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n" 2638 " {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};"); 2639 verifyFormat("CGRect cg_rect = {{rect.fLeft, rect.fTop},\n" 2640 " {rect.fRight - rect.fLeft, rect.fBottom - " 2641 "rect.fTop}};"); 2642 2643 verifyFormat( 2644 "SomeArrayOfSomeType a = {\n" 2645 " {{1, 2, 3},\n" 2646 " {1, 2, 3},\n" 2647 " {111111111111111111111111111111, 222222222222222222222222222222,\n" 2648 " 333333333333333333333333333333},\n" 2649 " {1, 2, 3},\n" 2650 " {1, 2, 3}}};"); 2651 verifyFormat( 2652 "SomeArrayOfSomeType a = {\n" 2653 " {{1, 2, 3}},\n" 2654 " {{1, 2, 3}},\n" 2655 " {{111111111111111111111111111111, 222222222222222222222222222222,\n" 2656 " 333333333333333333333333333333}},\n" 2657 " {{1, 2, 3}},\n" 2658 " {{1, 2, 3}}};"); 2659 2660 verifyFormat("struct {\n" 2661 " unsigned bit;\n" 2662 " const char *const name;\n" 2663 "} kBitsToOs[] = {{kOsMac, \"Mac\"},\n" 2664 " {kOsWin, \"Windows\"},\n" 2665 " {kOsLinux, \"Linux\"},\n" 2666 " {kOsCrOS, \"Chrome OS\"}};"); 2667 verifyFormat("struct {\n" 2668 " unsigned bit;\n" 2669 " const char *const name;\n" 2670 "} kBitsToOs[] = {\n" 2671 " {kOsMac, \"Mac\"},\n" 2672 " {kOsWin, \"Windows\"},\n" 2673 " {kOsLinux, \"Linux\"},\n" 2674 " {kOsCrOS, \"Chrome OS\"},\n" 2675 "};"); 2676 } 2677 2678 TEST_F(FormatTest, FormatsSmallMacroDefinitionsInSingleLine) { 2679 verifyFormat("#define ALooooooooooooooooooooooooooooooooooooooongMacro(" 2680 " \\\n" 2681 " aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)"); 2682 } 2683 2684 TEST_F(FormatTest, DoesNotBreakPureVirtualFunctionDefinition) { 2685 verifyFormat("virtual void write(ELFWriter *writerrr,\n" 2686 " OwningPtr<FileOutputBuffer> &buffer) = 0;"); 2687 2688 // Do break defaulted and deleted functions. 2689 verifyFormat("virtual void ~Deeeeeeeestructor() =\n" 2690 " default;", 2691 getLLVMStyleWithColumns(40)); 2692 verifyFormat("virtual void ~Deeeeeeeestructor() =\n" 2693 " delete;", 2694 getLLVMStyleWithColumns(40)); 2695 } 2696 2697 TEST_F(FormatTest, BreaksStringLiteralsOnlyInDefine) { 2698 verifyFormat("# 1111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\" 2 3", 2699 getLLVMStyleWithColumns(40)); 2700 verifyFormat("#line 11111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"", 2701 getLLVMStyleWithColumns(40)); 2702 EXPECT_EQ("#define Q \\\n" 2703 " \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/\" \\\n" 2704 " \"aaaaaaaa.cpp\"", 2705 format("#define Q \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"", 2706 getLLVMStyleWithColumns(40))); 2707 } 2708 2709 TEST_F(FormatTest, UnderstandsLinePPDirective) { 2710 EXPECT_EQ("# 123 \"A string literal\"", 2711 format(" # 123 \"A string literal\"")); 2712 } 2713 2714 TEST_F(FormatTest, LayoutUnknownPPDirective) { 2715 EXPECT_EQ("#;", format("#;")); 2716 verifyFormat("#\n;\n;\n;"); 2717 } 2718 2719 TEST_F(FormatTest, UnescapedEndOfLineEndsPPDirective) { 2720 EXPECT_EQ("#line 42 \"test\"\n", 2721 format("# \\\n line \\\n 42 \\\n \"test\"\n")); 2722 EXPECT_EQ("#define A B\n", format("# \\\n define \\\n A \\\n B\n", 2723 getLLVMStyleWithColumns(12))); 2724 } 2725 2726 TEST_F(FormatTest, EndOfFileEndsPPDirective) { 2727 EXPECT_EQ("#line 42 \"test\"", 2728 format("# \\\n line \\\n 42 \\\n \"test\"")); 2729 EXPECT_EQ("#define A B", format("# \\\n define \\\n A \\\n B")); 2730 } 2731 2732 TEST_F(FormatTest, DoesntRemoveUnknownTokens) { 2733 verifyFormat("#define A \\x20"); 2734 verifyFormat("#define A \\ x20"); 2735 EXPECT_EQ("#define A \\ x20", format("#define A \\ x20")); 2736 verifyFormat("#define A ''"); 2737 verifyFormat("#define A ''qqq"); 2738 verifyFormat("#define A `qqq"); 2739 verifyFormat("f(\"aaaa, bbbb, \"\\\"ccccc\\\"\");"); 2740 EXPECT_EQ("const char *c = STRINGIFY(\n" 2741 "\\na : b);", 2742 format("const char * c = STRINGIFY(\n" 2743 "\\na : b);")); 2744 2745 verifyFormat("a\r\\"); 2746 verifyFormat("a\v\\"); 2747 verifyFormat("a\f\\"); 2748 } 2749 2750 TEST_F(FormatTest, IndentsPPDirectiveInReducedSpace) { 2751 verifyFormat("#define A(BB)", getLLVMStyleWithColumns(13)); 2752 verifyFormat("#define A( \\\n BB)", getLLVMStyleWithColumns(12)); 2753 verifyFormat("#define A( \\\n A, B)", getLLVMStyleWithColumns(12)); 2754 // FIXME: We never break before the macro name. 2755 verifyFormat("#define AA( \\\n B)", getLLVMStyleWithColumns(12)); 2756 2757 verifyFormat("#define A A\n#define A A"); 2758 verifyFormat("#define A(X) A\n#define A A"); 2759 2760 verifyFormat("#define Something Other", getLLVMStyleWithColumns(23)); 2761 verifyFormat("#define Something \\\n Other", getLLVMStyleWithColumns(22)); 2762 } 2763 2764 TEST_F(FormatTest, HandlePreprocessorDirectiveContext) { 2765 EXPECT_EQ("// somecomment\n" 2766 "#include \"a.h\"\n" 2767 "#define A( \\\n" 2768 " A, B)\n" 2769 "#include \"b.h\"\n" 2770 "// somecomment\n", 2771 format(" // somecomment\n" 2772 " #include \"a.h\"\n" 2773 "#define A(A,\\\n" 2774 " B)\n" 2775 " #include \"b.h\"\n" 2776 " // somecomment\n", 2777 getLLVMStyleWithColumns(13))); 2778 } 2779 2780 TEST_F(FormatTest, LayoutSingleHash) { EXPECT_EQ("#\na;", format("#\na;")); } 2781 2782 TEST_F(FormatTest, LayoutCodeInMacroDefinitions) { 2783 EXPECT_EQ("#define A \\\n" 2784 " c; \\\n" 2785 " e;\n" 2786 "f;", 2787 format("#define A c; e;\n" 2788 "f;", 2789 getLLVMStyleWithColumns(14))); 2790 } 2791 2792 TEST_F(FormatTest, LayoutRemainingTokens) { EXPECT_EQ("{}", format("{}")); } 2793 2794 TEST_F(FormatTest, MacroDefinitionInsideStatement) { 2795 EXPECT_EQ("int x,\n" 2796 "#define A\n" 2797 " y;", 2798 format("int x,\n#define A\ny;")); 2799 } 2800 2801 TEST_F(FormatTest, HashInMacroDefinition) { 2802 EXPECT_EQ("#define A(c) L#c", format("#define A(c) L#c", getLLVMStyle())); 2803 verifyFormat("#define A \\\n b #c;", getLLVMStyleWithColumns(11)); 2804 verifyFormat("#define A \\\n" 2805 " { \\\n" 2806 " f(#c); \\\n" 2807 " }", 2808 getLLVMStyleWithColumns(11)); 2809 2810 verifyFormat("#define A(X) \\\n" 2811 " void function##X()", 2812 getLLVMStyleWithColumns(22)); 2813 2814 verifyFormat("#define A(a, b, c) \\\n" 2815 " void a##b##c()", 2816 getLLVMStyleWithColumns(22)); 2817 2818 verifyFormat("#define A void # ## #", getLLVMStyleWithColumns(22)); 2819 } 2820 2821 TEST_F(FormatTest, RespectWhitespaceInMacroDefinitions) { 2822 EXPECT_EQ("#define A (x)", format("#define A (x)")); 2823 EXPECT_EQ("#define A(x)", format("#define A(x)")); 2824 2825 FormatStyle Style = getLLVMStyle(); 2826 Style.SpaceBeforeParens = FormatStyle::SBPO_Never; 2827 verifyFormat("#define true ((foo)1)", Style); 2828 Style.SpaceBeforeParens = FormatStyle::SBPO_Always; 2829 verifyFormat("#define false((foo)0)", Style); 2830 } 2831 2832 TEST_F(FormatTest, EmptyLinesInMacroDefinitions) { 2833 EXPECT_EQ("#define A b;", format("#define A \\\n" 2834 " \\\n" 2835 " b;", 2836 getLLVMStyleWithColumns(25))); 2837 EXPECT_EQ("#define A \\\n" 2838 " \\\n" 2839 " a; \\\n" 2840 " b;", 2841 format("#define A \\\n" 2842 " \\\n" 2843 " a; \\\n" 2844 " b;", 2845 getLLVMStyleWithColumns(11))); 2846 EXPECT_EQ("#define A \\\n" 2847 " a; \\\n" 2848 " \\\n" 2849 " b;", 2850 format("#define A \\\n" 2851 " a; \\\n" 2852 " \\\n" 2853 " b;", 2854 getLLVMStyleWithColumns(11))); 2855 } 2856 2857 TEST_F(FormatTest, MacroDefinitionsWithIncompleteCode) { 2858 verifyIncompleteFormat("#define A :"); 2859 verifyFormat("#define SOMECASES \\\n" 2860 " case 1: \\\n" 2861 " case 2\n", 2862 getLLVMStyleWithColumns(20)); 2863 verifyFormat("#define MACRO(a) \\\n" 2864 " if (a) \\\n" 2865 " f(); \\\n" 2866 " else \\\n" 2867 " g()", 2868 getLLVMStyleWithColumns(18)); 2869 verifyFormat("#define A template <typename T>"); 2870 verifyIncompleteFormat("#define STR(x) #x\n" 2871 "f(STR(this_is_a_string_literal{));"); 2872 verifyFormat("#pragma omp threadprivate( \\\n" 2873 " y)), // expected-warning", 2874 getLLVMStyleWithColumns(28)); 2875 verifyFormat("#d, = };"); 2876 verifyFormat("#if \"a"); 2877 verifyIncompleteFormat("({\n" 2878 "#define b \\\n" 2879 " } \\\n" 2880 " a\n" 2881 "a", 2882 getLLVMStyleWithColumns(15)); 2883 verifyFormat("#define A \\\n" 2884 " { \\\n" 2885 " {\n" 2886 "#define B \\\n" 2887 " } \\\n" 2888 " }", 2889 getLLVMStyleWithColumns(15)); 2890 verifyNoCrash("#if a\na(\n#else\n#endif\n{a"); 2891 verifyNoCrash("a={0,1\n#if a\n#else\n;\n#endif\n}"); 2892 verifyNoCrash("#if a\na(\n#else\n#endif\n) a {a,b,c,d,f,g};"); 2893 verifyNoCrash("#ifdef A\n a(\n #else\n #endif\n) = []() { \n)}"); 2894 } 2895 2896 TEST_F(FormatTest, MacrosWithoutTrailingSemicolon) { 2897 verifyFormat("SOME_TYPE_NAME abc;"); // Gated on the newline. 2898 EXPECT_EQ("class A : public QObject {\n" 2899 " Q_OBJECT\n" 2900 "\n" 2901 " A() {}\n" 2902 "};", 2903 format("class A : public QObject {\n" 2904 " Q_OBJECT\n" 2905 "\n" 2906 " A() {\n}\n" 2907 "} ;")); 2908 EXPECT_EQ("MACRO\n" 2909 "/*static*/ int i;", 2910 format("MACRO\n" 2911 " /*static*/ int i;")); 2912 EXPECT_EQ("SOME_MACRO\n" 2913 "namespace {\n" 2914 "void f();\n" 2915 "} // namespace", 2916 format("SOME_MACRO\n" 2917 " namespace {\n" 2918 "void f( );\n" 2919 "} // namespace")); 2920 // Only if the identifier contains at least 5 characters. 2921 EXPECT_EQ("HTTP f();", format("HTTP\nf();")); 2922 EXPECT_EQ("MACRO\nf();", format("MACRO\nf();")); 2923 // Only if everything is upper case. 2924 EXPECT_EQ("class A : public QObject {\n" 2925 " Q_Object A() {}\n" 2926 "};", 2927 format("class A : public QObject {\n" 2928 " Q_Object\n" 2929 " A() {\n}\n" 2930 "} ;")); 2931 2932 // Only if the next line can actually start an unwrapped line. 2933 EXPECT_EQ("SOME_WEIRD_LOG_MACRO << SomeThing;", 2934 format("SOME_WEIRD_LOG_MACRO\n" 2935 "<< SomeThing;")); 2936 2937 verifyFormat("VISIT_GL_CALL(GenBuffers, void, (GLsizei n, GLuint* buffers), " 2938 "(n, buffers))\n", 2939 getChromiumStyle(FormatStyle::LK_Cpp)); 2940 2941 // See PR41483 2942 EXPECT_EQ("/**/ FOO(a)\n" 2943 "FOO(b)", 2944 format("/**/ FOO(a)\n" 2945 "FOO(b)")); 2946 } 2947 2948 TEST_F(FormatTest, MacroCallsWithoutTrailingSemicolon) { 2949 EXPECT_EQ("INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n" 2950 "INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n" 2951 "INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n" 2952 "class X {};\n" 2953 "INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n" 2954 "int *createScopDetectionPass() { return 0; }", 2955 format(" INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n" 2956 " INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n" 2957 " INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n" 2958 " class X {};\n" 2959 " INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n" 2960 " int *createScopDetectionPass() { return 0; }")); 2961 // FIXME: We could probably treat IPC_BEGIN_MESSAGE_MAP/IPC_END_MESSAGE_MAP as 2962 // braces, so that inner block is indented one level more. 2963 EXPECT_EQ("int q() {\n" 2964 " IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n" 2965 " IPC_MESSAGE_HANDLER(xxx, qqq)\n" 2966 " IPC_END_MESSAGE_MAP()\n" 2967 "}", 2968 format("int q() {\n" 2969 " IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n" 2970 " IPC_MESSAGE_HANDLER(xxx, qqq)\n" 2971 " IPC_END_MESSAGE_MAP()\n" 2972 "}")); 2973 2974 // Same inside macros. 2975 EXPECT_EQ("#define LIST(L) \\\n" 2976 " L(A) \\\n" 2977 " L(B) \\\n" 2978 " L(C)", 2979 format("#define LIST(L) \\\n" 2980 " L(A) \\\n" 2981 " L(B) \\\n" 2982 " L(C)", 2983 getGoogleStyle())); 2984 2985 // These must not be recognized as macros. 2986 EXPECT_EQ("int q() {\n" 2987 " f(x);\n" 2988 " f(x) {}\n" 2989 " f(x)->g();\n" 2990 " f(x)->*g();\n" 2991 " f(x).g();\n" 2992 " f(x) = x;\n" 2993 " f(x) += x;\n" 2994 " f(x) -= x;\n" 2995 " f(x) *= x;\n" 2996 " f(x) /= x;\n" 2997 " f(x) %= x;\n" 2998 " f(x) &= x;\n" 2999 " f(x) |= x;\n" 3000 " f(x) ^= x;\n" 3001 " f(x) >>= x;\n" 3002 " f(x) <<= x;\n" 3003 " f(x)[y].z();\n" 3004 " LOG(INFO) << x;\n" 3005 " ifstream(x) >> x;\n" 3006 "}\n", 3007 format("int q() {\n" 3008 " f(x)\n;\n" 3009 " f(x)\n {}\n" 3010 " f(x)\n->g();\n" 3011 " f(x)\n->*g();\n" 3012 " f(x)\n.g();\n" 3013 " f(x)\n = x;\n" 3014 " f(x)\n += x;\n" 3015 " f(x)\n -= x;\n" 3016 " f(x)\n *= x;\n" 3017 " f(x)\n /= x;\n" 3018 " f(x)\n %= x;\n" 3019 " f(x)\n &= x;\n" 3020 " f(x)\n |= x;\n" 3021 " f(x)\n ^= x;\n" 3022 " f(x)\n >>= x;\n" 3023 " f(x)\n <<= x;\n" 3024 " f(x)\n[y].z();\n" 3025 " LOG(INFO)\n << x;\n" 3026 " ifstream(x)\n >> x;\n" 3027 "}\n")); 3028 EXPECT_EQ("int q() {\n" 3029 " F(x)\n" 3030 " if (1) {\n" 3031 " }\n" 3032 " F(x)\n" 3033 " while (1) {\n" 3034 " }\n" 3035 " F(x)\n" 3036 " G(x);\n" 3037 " F(x)\n" 3038 " try {\n" 3039 " Q();\n" 3040 " } catch (...) {\n" 3041 " }\n" 3042 "}\n", 3043 format("int q() {\n" 3044 "F(x)\n" 3045 "if (1) {}\n" 3046 "F(x)\n" 3047 "while (1) {}\n" 3048 "F(x)\n" 3049 "G(x);\n" 3050 "F(x)\n" 3051 "try { Q(); } catch (...) {}\n" 3052 "}\n")); 3053 EXPECT_EQ("class A {\n" 3054 " A() : t(0) {}\n" 3055 " A(int i) noexcept() : {}\n" 3056 " A(X x)\n" // FIXME: function-level try blocks are broken. 3057 " try : t(0) {\n" 3058 " } catch (...) {\n" 3059 " }\n" 3060 "};", 3061 format("class A {\n" 3062 " A()\n : t(0) {}\n" 3063 " A(int i)\n noexcept() : {}\n" 3064 " A(X x)\n" 3065 " try : t(0) {} catch (...) {}\n" 3066 "};")); 3067 FormatStyle Style = getLLVMStyle(); 3068 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 3069 Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always; 3070 Style.BraceWrapping.AfterFunction = true; 3071 EXPECT_EQ("void f()\n" 3072 "try\n" 3073 "{\n" 3074 "}", 3075 format("void f() try {\n" 3076 "}", 3077 Style)); 3078 EXPECT_EQ("class SomeClass {\n" 3079 "public:\n" 3080 " SomeClass() EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 3081 "};", 3082 format("class SomeClass {\n" 3083 "public:\n" 3084 " SomeClass()\n" 3085 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 3086 "};")); 3087 EXPECT_EQ("class SomeClass {\n" 3088 "public:\n" 3089 " SomeClass()\n" 3090 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 3091 "};", 3092 format("class SomeClass {\n" 3093 "public:\n" 3094 " SomeClass()\n" 3095 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 3096 "};", 3097 getLLVMStyleWithColumns(40))); 3098 3099 verifyFormat("MACRO(>)"); 3100 3101 // Some macros contain an implicit semicolon. 3102 Style = getLLVMStyle(); 3103 Style.StatementMacros.push_back("FOO"); 3104 verifyFormat("FOO(a) int b = 0;"); 3105 verifyFormat("FOO(a)\n" 3106 "int b = 0;", 3107 Style); 3108 verifyFormat("FOO(a);\n" 3109 "int b = 0;", 3110 Style); 3111 verifyFormat("FOO(argc, argv, \"4.0.2\")\n" 3112 "int b = 0;", 3113 Style); 3114 verifyFormat("FOO()\n" 3115 "int b = 0;", 3116 Style); 3117 verifyFormat("FOO\n" 3118 "int b = 0;", 3119 Style); 3120 verifyFormat("void f() {\n" 3121 " FOO(a)\n" 3122 " return a;\n" 3123 "}", 3124 Style); 3125 verifyFormat("FOO(a)\n" 3126 "FOO(b)", 3127 Style); 3128 verifyFormat("int a = 0;\n" 3129 "FOO(b)\n" 3130 "int c = 0;", 3131 Style); 3132 verifyFormat("int a = 0;\n" 3133 "int x = FOO(a)\n" 3134 "int b = 0;", 3135 Style); 3136 verifyFormat("void foo(int a) { FOO(a) }\n" 3137 "uint32_t bar() {}", 3138 Style); 3139 } 3140 3141 TEST_F(FormatTest, LayoutMacroDefinitionsStatementsSpanningBlocks) { 3142 verifyFormat("#define A \\\n" 3143 " f({ \\\n" 3144 " g(); \\\n" 3145 " });", 3146 getLLVMStyleWithColumns(11)); 3147 } 3148 3149 TEST_F(FormatTest, IndentPreprocessorDirectives) { 3150 FormatStyle Style = getLLVMStyle(); 3151 Style.IndentPPDirectives = FormatStyle::PPDIS_None; 3152 Style.ColumnLimit = 40; 3153 verifyFormat("#ifdef _WIN32\n" 3154 "#define A 0\n" 3155 "#ifdef VAR2\n" 3156 "#define B 1\n" 3157 "#include <someheader.h>\n" 3158 "#define MACRO \\\n" 3159 " some_very_long_func_aaaaaaaaaa();\n" 3160 "#endif\n" 3161 "#else\n" 3162 "#define A 1\n" 3163 "#endif", 3164 Style); 3165 Style.IndentPPDirectives = FormatStyle::PPDIS_AfterHash; 3166 verifyFormat("#ifdef _WIN32\n" 3167 "# define A 0\n" 3168 "# ifdef VAR2\n" 3169 "# define B 1\n" 3170 "# include <someheader.h>\n" 3171 "# define MACRO \\\n" 3172 " some_very_long_func_aaaaaaaaaa();\n" 3173 "# endif\n" 3174 "#else\n" 3175 "# define A 1\n" 3176 "#endif", 3177 Style); 3178 verifyFormat("#if A\n" 3179 "# define MACRO \\\n" 3180 " void a(int x) { \\\n" 3181 " b(); \\\n" 3182 " c(); \\\n" 3183 " d(); \\\n" 3184 " e(); \\\n" 3185 " f(); \\\n" 3186 " }\n" 3187 "#endif", 3188 Style); 3189 // Comments before include guard. 3190 verifyFormat("// file comment\n" 3191 "// file comment\n" 3192 "#ifndef HEADER_H\n" 3193 "#define HEADER_H\n" 3194 "code();\n" 3195 "#endif", 3196 Style); 3197 // Test with include guards. 3198 verifyFormat("#ifndef HEADER_H\n" 3199 "#define HEADER_H\n" 3200 "code();\n" 3201 "#endif", 3202 Style); 3203 // Include guards must have a #define with the same variable immediately 3204 // after #ifndef. 3205 verifyFormat("#ifndef NOT_GUARD\n" 3206 "# define FOO\n" 3207 "code();\n" 3208 "#endif", 3209 Style); 3210 3211 // Include guards must cover the entire file. 3212 verifyFormat("code();\n" 3213 "code();\n" 3214 "#ifndef NOT_GUARD\n" 3215 "# define NOT_GUARD\n" 3216 "code();\n" 3217 "#endif", 3218 Style); 3219 verifyFormat("#ifndef NOT_GUARD\n" 3220 "# define NOT_GUARD\n" 3221 "code();\n" 3222 "#endif\n" 3223 "code();", 3224 Style); 3225 // Test with trailing blank lines. 3226 verifyFormat("#ifndef HEADER_H\n" 3227 "#define HEADER_H\n" 3228 "code();\n" 3229 "#endif\n", 3230 Style); 3231 // Include guards don't have #else. 3232 verifyFormat("#ifndef NOT_GUARD\n" 3233 "# define NOT_GUARD\n" 3234 "code();\n" 3235 "#else\n" 3236 "#endif", 3237 Style); 3238 verifyFormat("#ifndef NOT_GUARD\n" 3239 "# define NOT_GUARD\n" 3240 "code();\n" 3241 "#elif FOO\n" 3242 "#endif", 3243 Style); 3244 // Non-identifier #define after potential include guard. 3245 verifyFormat("#ifndef FOO\n" 3246 "# define 1\n" 3247 "#endif\n", 3248 Style); 3249 // #if closes past last non-preprocessor line. 3250 verifyFormat("#ifndef FOO\n" 3251 "#define FOO\n" 3252 "#if 1\n" 3253 "int i;\n" 3254 "# define A 0\n" 3255 "#endif\n" 3256 "#endif\n", 3257 Style); 3258 // Don't crash if there is an #elif directive without a condition. 3259 verifyFormat("#if 1\n" 3260 "int x;\n" 3261 "#elif\n" 3262 "int y;\n" 3263 "#else\n" 3264 "int z;\n" 3265 "#endif", 3266 Style); 3267 // FIXME: This doesn't handle the case where there's code between the 3268 // #ifndef and #define but all other conditions hold. This is because when 3269 // the #define line is parsed, UnwrappedLineParser::Lines doesn't hold the 3270 // previous code line yet, so we can't detect it. 3271 EXPECT_EQ("#ifndef NOT_GUARD\n" 3272 "code();\n" 3273 "#define NOT_GUARD\n" 3274 "code();\n" 3275 "#endif", 3276 format("#ifndef NOT_GUARD\n" 3277 "code();\n" 3278 "# define NOT_GUARD\n" 3279 "code();\n" 3280 "#endif", 3281 Style)); 3282 // FIXME: This doesn't handle cases where legitimate preprocessor lines may 3283 // be outside an include guard. Examples are #pragma once and 3284 // #pragma GCC diagnostic, or anything else that does not change the meaning 3285 // of the file if it's included multiple times. 3286 EXPECT_EQ("#ifdef WIN32\n" 3287 "# pragma once\n" 3288 "#endif\n" 3289 "#ifndef HEADER_H\n" 3290 "# define HEADER_H\n" 3291 "code();\n" 3292 "#endif", 3293 format("#ifdef WIN32\n" 3294 "# pragma once\n" 3295 "#endif\n" 3296 "#ifndef HEADER_H\n" 3297 "#define HEADER_H\n" 3298 "code();\n" 3299 "#endif", 3300 Style)); 3301 // FIXME: This does not detect when there is a single non-preprocessor line 3302 // in front of an include-guard-like structure where other conditions hold 3303 // because ScopedLineState hides the line. 3304 EXPECT_EQ("code();\n" 3305 "#ifndef HEADER_H\n" 3306 "#define HEADER_H\n" 3307 "code();\n" 3308 "#endif", 3309 format("code();\n" 3310 "#ifndef HEADER_H\n" 3311 "# define HEADER_H\n" 3312 "code();\n" 3313 "#endif", 3314 Style)); 3315 // Keep comments aligned with #, otherwise indent comments normally. These 3316 // tests cannot use verifyFormat because messUp manipulates leading 3317 // whitespace. 3318 { 3319 const char *Expected = "" 3320 "void f() {\n" 3321 "#if 1\n" 3322 "// Preprocessor aligned.\n" 3323 "# define A 0\n" 3324 " // Code. Separated by blank line.\n" 3325 "\n" 3326 "# define B 0\n" 3327 " // Code. Not aligned with #\n" 3328 "# define C 0\n" 3329 "#endif"; 3330 const char *ToFormat = "" 3331 "void f() {\n" 3332 "#if 1\n" 3333 "// Preprocessor aligned.\n" 3334 "# define A 0\n" 3335 "// Code. Separated by blank line.\n" 3336 "\n" 3337 "# define B 0\n" 3338 " // Code. Not aligned with #\n" 3339 "# define C 0\n" 3340 "#endif"; 3341 EXPECT_EQ(Expected, format(ToFormat, Style)); 3342 EXPECT_EQ(Expected, format(Expected, Style)); 3343 } 3344 // Keep block quotes aligned. 3345 { 3346 const char *Expected = "" 3347 "void f() {\n" 3348 "#if 1\n" 3349 "/* Preprocessor aligned. */\n" 3350 "# define A 0\n" 3351 " /* Code. Separated by blank line. */\n" 3352 "\n" 3353 "# define B 0\n" 3354 " /* Code. Not aligned with # */\n" 3355 "# define C 0\n" 3356 "#endif"; 3357 const char *ToFormat = "" 3358 "void f() {\n" 3359 "#if 1\n" 3360 "/* Preprocessor aligned. */\n" 3361 "# define A 0\n" 3362 "/* Code. Separated by blank line. */\n" 3363 "\n" 3364 "# define B 0\n" 3365 " /* Code. Not aligned with # */\n" 3366 "# define C 0\n" 3367 "#endif"; 3368 EXPECT_EQ(Expected, format(ToFormat, Style)); 3369 EXPECT_EQ(Expected, format(Expected, Style)); 3370 } 3371 // Keep comments aligned with un-indented directives. 3372 { 3373 const char *Expected = "" 3374 "void f() {\n" 3375 "// Preprocessor aligned.\n" 3376 "#define A 0\n" 3377 " // Code. Separated by blank line.\n" 3378 "\n" 3379 "#define B 0\n" 3380 " // Code. Not aligned with #\n" 3381 "#define C 0\n"; 3382 const char *ToFormat = "" 3383 "void f() {\n" 3384 "// Preprocessor aligned.\n" 3385 "#define A 0\n" 3386 "// Code. Separated by blank line.\n" 3387 "\n" 3388 "#define B 0\n" 3389 " // Code. Not aligned with #\n" 3390 "#define C 0\n"; 3391 EXPECT_EQ(Expected, format(ToFormat, Style)); 3392 EXPECT_EQ(Expected, format(Expected, Style)); 3393 } 3394 // Test AfterHash with tabs. 3395 { 3396 FormatStyle Tabbed = Style; 3397 Tabbed.UseTab = FormatStyle::UT_Always; 3398 Tabbed.IndentWidth = 8; 3399 Tabbed.TabWidth = 8; 3400 verifyFormat("#ifdef _WIN32\n" 3401 "#\tdefine A 0\n" 3402 "#\tifdef VAR2\n" 3403 "#\t\tdefine B 1\n" 3404 "#\t\tinclude <someheader.h>\n" 3405 "#\t\tdefine MACRO \\\n" 3406 "\t\t\tsome_very_long_func_aaaaaaaaaa();\n" 3407 "#\tendif\n" 3408 "#else\n" 3409 "#\tdefine A 1\n" 3410 "#endif", 3411 Tabbed); 3412 } 3413 3414 // Regression test: Multiline-macro inside include guards. 3415 verifyFormat("#ifndef HEADER_H\n" 3416 "#define HEADER_H\n" 3417 "#define A() \\\n" 3418 " int i; \\\n" 3419 " int j;\n" 3420 "#endif // HEADER_H", 3421 getLLVMStyleWithColumns(20)); 3422 3423 Style.IndentPPDirectives = FormatStyle::PPDIS_BeforeHash; 3424 // Basic before hash indent tests 3425 verifyFormat("#ifdef _WIN32\n" 3426 " #define A 0\n" 3427 " #ifdef VAR2\n" 3428 " #define B 1\n" 3429 " #include <someheader.h>\n" 3430 " #define MACRO \\\n" 3431 " some_very_long_func_aaaaaaaaaa();\n" 3432 " #endif\n" 3433 "#else\n" 3434 " #define A 1\n" 3435 "#endif", 3436 Style); 3437 verifyFormat("#if A\n" 3438 " #define MACRO \\\n" 3439 " void a(int x) { \\\n" 3440 " b(); \\\n" 3441 " c(); \\\n" 3442 " d(); \\\n" 3443 " e(); \\\n" 3444 " f(); \\\n" 3445 " }\n" 3446 "#endif", 3447 Style); 3448 // Keep comments aligned with indented directives. These 3449 // tests cannot use verifyFormat because messUp manipulates leading 3450 // whitespace. 3451 { 3452 const char *Expected = "void f() {\n" 3453 "// Aligned to preprocessor.\n" 3454 "#if 1\n" 3455 " // Aligned to code.\n" 3456 " int a;\n" 3457 " #if 1\n" 3458 " // Aligned to preprocessor.\n" 3459 " #define A 0\n" 3460 " // Aligned to code.\n" 3461 " int b;\n" 3462 " #endif\n" 3463 "#endif\n" 3464 "}"; 3465 const char *ToFormat = "void f() {\n" 3466 "// Aligned to preprocessor.\n" 3467 "#if 1\n" 3468 "// Aligned to code.\n" 3469 "int a;\n" 3470 "#if 1\n" 3471 "// Aligned to preprocessor.\n" 3472 "#define A 0\n" 3473 "// Aligned to code.\n" 3474 "int b;\n" 3475 "#endif\n" 3476 "#endif\n" 3477 "}"; 3478 EXPECT_EQ(Expected, format(ToFormat, Style)); 3479 EXPECT_EQ(Expected, format(Expected, Style)); 3480 } 3481 { 3482 const char *Expected = "void f() {\n" 3483 "/* Aligned to preprocessor. */\n" 3484 "#if 1\n" 3485 " /* Aligned to code. */\n" 3486 " int a;\n" 3487 " #if 1\n" 3488 " /* Aligned to preprocessor. */\n" 3489 " #define A 0\n" 3490 " /* Aligned to code. */\n" 3491 " int b;\n" 3492 " #endif\n" 3493 "#endif\n" 3494 "}"; 3495 const char *ToFormat = "void f() {\n" 3496 "/* Aligned to preprocessor. */\n" 3497 "#if 1\n" 3498 "/* Aligned to code. */\n" 3499 "int a;\n" 3500 "#if 1\n" 3501 "/* Aligned to preprocessor. */\n" 3502 "#define A 0\n" 3503 "/* Aligned to code. */\n" 3504 "int b;\n" 3505 "#endif\n" 3506 "#endif\n" 3507 "}"; 3508 EXPECT_EQ(Expected, format(ToFormat, Style)); 3509 EXPECT_EQ(Expected, format(Expected, Style)); 3510 } 3511 3512 // Test single comment before preprocessor 3513 verifyFormat("// Comment\n" 3514 "\n" 3515 "#if 1\n" 3516 "#endif", 3517 Style); 3518 } 3519 3520 TEST_F(FormatTest, FormatHashIfNotAtStartOfLine) { 3521 verifyFormat("{\n { a #c; }\n}"); 3522 } 3523 3524 TEST_F(FormatTest, FormatUnbalancedStructuralElements) { 3525 EXPECT_EQ("#define A \\\n { \\\n {\nint i;", 3526 format("#define A { {\nint i;", getLLVMStyleWithColumns(11))); 3527 EXPECT_EQ("#define A \\\n } \\\n }\nint i;", 3528 format("#define A } }\nint i;", getLLVMStyleWithColumns(11))); 3529 } 3530 3531 TEST_F(FormatTest, EscapedNewlines) { 3532 FormatStyle Narrow = getLLVMStyleWithColumns(11); 3533 EXPECT_EQ("#define A \\\n int i; \\\n int j;", 3534 format("#define A \\\nint i;\\\n int j;", Narrow)); 3535 EXPECT_EQ("#define A\n\nint i;", format("#define A \\\n\n int i;")); 3536 EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();")); 3537 EXPECT_EQ("/* \\ \\ \\\n */", format("\\\n/* \\ \\ \\\n */")); 3538 EXPECT_EQ("<a\n\\\\\n>", format("<a\n\\\\\n>")); 3539 3540 FormatStyle AlignLeft = getLLVMStyle(); 3541 AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left; 3542 EXPECT_EQ("#define MACRO(x) \\\n" 3543 "private: \\\n" 3544 " int x(int a);\n", 3545 format("#define MACRO(x) \\\n" 3546 "private: \\\n" 3547 " int x(int a);\n", 3548 AlignLeft)); 3549 3550 // CRLF line endings 3551 EXPECT_EQ("#define A \\\r\n int i; \\\r\n int j;", 3552 format("#define A \\\r\nint i;\\\r\n int j;", Narrow)); 3553 EXPECT_EQ("#define A\r\n\r\nint i;", format("#define A \\\r\n\r\n int i;")); 3554 EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();")); 3555 EXPECT_EQ("/* \\ \\ \\\r\n */", format("\\\r\n/* \\ \\ \\\r\n */")); 3556 EXPECT_EQ("<a\r\n\\\\\r\n>", format("<a\r\n\\\\\r\n>")); 3557 EXPECT_EQ("#define MACRO(x) \\\r\n" 3558 "private: \\\r\n" 3559 " int x(int a);\r\n", 3560 format("#define MACRO(x) \\\r\n" 3561 "private: \\\r\n" 3562 " int x(int a);\r\n", 3563 AlignLeft)); 3564 3565 FormatStyle DontAlign = getLLVMStyle(); 3566 DontAlign.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign; 3567 DontAlign.MaxEmptyLinesToKeep = 3; 3568 // FIXME: can't use verifyFormat here because the newline before 3569 // "public:" is not inserted the first time it's reformatted 3570 EXPECT_EQ("#define A \\\n" 3571 " class Foo { \\\n" 3572 " void bar(); \\\n" 3573 "\\\n" 3574 "\\\n" 3575 "\\\n" 3576 " public: \\\n" 3577 " void baz(); \\\n" 3578 " };", 3579 format("#define A \\\n" 3580 " class Foo { \\\n" 3581 " void bar(); \\\n" 3582 "\\\n" 3583 "\\\n" 3584 "\\\n" 3585 " public: \\\n" 3586 " void baz(); \\\n" 3587 " };", 3588 DontAlign)); 3589 } 3590 3591 TEST_F(FormatTest, CalculateSpaceOnConsecutiveLinesInMacro) { 3592 verifyFormat("#define A \\\n" 3593 " int v( \\\n" 3594 " a); \\\n" 3595 " int i;", 3596 getLLVMStyleWithColumns(11)); 3597 } 3598 3599 TEST_F(FormatTest, MixingPreprocessorDirectivesAndNormalCode) { 3600 EXPECT_EQ( 3601 "#define ALooooooooooooooooooooooooooooooooooooooongMacro(" 3602 " \\\n" 3603 " aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n" 3604 "\n" 3605 "AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n" 3606 " aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n", 3607 format(" #define ALooooooooooooooooooooooooooooooooooooooongMacro(" 3608 "\\\n" 3609 "aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n" 3610 " \n" 3611 " AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n" 3612 " aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n")); 3613 } 3614 3615 TEST_F(FormatTest, LayoutStatementsAroundPreprocessorDirectives) { 3616 EXPECT_EQ("int\n" 3617 "#define A\n" 3618 " a;", 3619 format("int\n#define A\na;")); 3620 verifyFormat("functionCallTo(\n" 3621 " someOtherFunction(\n" 3622 " withSomeParameters, whichInSequence,\n" 3623 " areLongerThanALine(andAnotherCall,\n" 3624 "#define A B\n" 3625 " withMoreParamters,\n" 3626 " whichStronglyInfluenceTheLayout),\n" 3627 " andMoreParameters),\n" 3628 " trailing);", 3629 getLLVMStyleWithColumns(69)); 3630 verifyFormat("Foo::Foo()\n" 3631 "#ifdef BAR\n" 3632 " : baz(0)\n" 3633 "#endif\n" 3634 "{\n" 3635 "}"); 3636 verifyFormat("void f() {\n" 3637 " if (true)\n" 3638 "#ifdef A\n" 3639 " f(42);\n" 3640 " x();\n" 3641 "#else\n" 3642 " g();\n" 3643 " x();\n" 3644 "#endif\n" 3645 "}"); 3646 verifyFormat("void f(param1, param2,\n" 3647 " param3,\n" 3648 "#ifdef A\n" 3649 " param4(param5,\n" 3650 "#ifdef A1\n" 3651 " param6,\n" 3652 "#ifdef A2\n" 3653 " param7),\n" 3654 "#else\n" 3655 " param8),\n" 3656 " param9,\n" 3657 "#endif\n" 3658 " param10,\n" 3659 "#endif\n" 3660 " param11)\n" 3661 "#else\n" 3662 " param12)\n" 3663 "#endif\n" 3664 "{\n" 3665 " x();\n" 3666 "}", 3667 getLLVMStyleWithColumns(28)); 3668 verifyFormat("#if 1\n" 3669 "int i;"); 3670 verifyFormat("#if 1\n" 3671 "#endif\n" 3672 "#if 1\n" 3673 "#else\n" 3674 "#endif\n"); 3675 verifyFormat("DEBUG({\n" 3676 " return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3677 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n" 3678 "});\n" 3679 "#if a\n" 3680 "#else\n" 3681 "#endif"); 3682 3683 verifyIncompleteFormat("void f(\n" 3684 "#if A\n" 3685 ");\n" 3686 "#else\n" 3687 "#endif"); 3688 } 3689 3690 TEST_F(FormatTest, GraciouslyHandleIncorrectPreprocessorConditions) { 3691 verifyFormat("#endif\n" 3692 "#if B"); 3693 } 3694 3695 TEST_F(FormatTest, FormatsJoinedLinesOnSubsequentRuns) { 3696 FormatStyle SingleLine = getLLVMStyle(); 3697 SingleLine.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_WithoutElse; 3698 verifyFormat("#if 0\n" 3699 "#elif 1\n" 3700 "#endif\n" 3701 "void foo() {\n" 3702 " if (test) foo2();\n" 3703 "}", 3704 SingleLine); 3705 } 3706 3707 TEST_F(FormatTest, LayoutBlockInsideParens) { 3708 verifyFormat("functionCall({ int i; });"); 3709 verifyFormat("functionCall({\n" 3710 " int i;\n" 3711 " int j;\n" 3712 "});"); 3713 verifyFormat("functionCall(\n" 3714 " {\n" 3715 " int i;\n" 3716 " int j;\n" 3717 " },\n" 3718 " aaaa, bbbb, cccc);"); 3719 verifyFormat("functionA(functionB({\n" 3720 " int i;\n" 3721 " int j;\n" 3722 " }),\n" 3723 " aaaa, bbbb, cccc);"); 3724 verifyFormat("functionCall(\n" 3725 " {\n" 3726 " int i;\n" 3727 " int j;\n" 3728 " },\n" 3729 " aaaa, bbbb, // comment\n" 3730 " cccc);"); 3731 verifyFormat("functionA(functionB({\n" 3732 " int i;\n" 3733 " int j;\n" 3734 " }),\n" 3735 " aaaa, bbbb, // comment\n" 3736 " cccc);"); 3737 verifyFormat("functionCall(aaaa, bbbb, { int i; });"); 3738 verifyFormat("functionCall(aaaa, bbbb, {\n" 3739 " int i;\n" 3740 " int j;\n" 3741 "});"); 3742 verifyFormat( 3743 "Aaa(\n" // FIXME: There shouldn't be a linebreak here. 3744 " {\n" 3745 " int i; // break\n" 3746 " },\n" 3747 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" 3748 " ccccccccccccccccc));"); 3749 verifyFormat("DEBUG({\n" 3750 " if (a)\n" 3751 " f();\n" 3752 "});"); 3753 } 3754 3755 TEST_F(FormatTest, LayoutBlockInsideStatement) { 3756 EXPECT_EQ("SOME_MACRO { int i; }\n" 3757 "int i;", 3758 format(" SOME_MACRO {int i;} int i;")); 3759 } 3760 3761 TEST_F(FormatTest, LayoutNestedBlocks) { 3762 verifyFormat("void AddOsStrings(unsigned bitmask) {\n" 3763 " struct s {\n" 3764 " int i;\n" 3765 " };\n" 3766 " s kBitsToOs[] = {{10}};\n" 3767 " for (int i = 0; i < 10; ++i)\n" 3768 " return;\n" 3769 "}"); 3770 verifyFormat("call(parameter, {\n" 3771 " something();\n" 3772 " // Comment using all columns.\n" 3773 " somethingelse();\n" 3774 "});", 3775 getLLVMStyleWithColumns(40)); 3776 verifyFormat("DEBUG( //\n" 3777 " { f(); }, a);"); 3778 verifyFormat("DEBUG( //\n" 3779 " {\n" 3780 " f(); //\n" 3781 " },\n" 3782 " a);"); 3783 3784 EXPECT_EQ("call(parameter, {\n" 3785 " something();\n" 3786 " // Comment too\n" 3787 " // looooooooooong.\n" 3788 " somethingElse();\n" 3789 "});", 3790 format("call(parameter, {\n" 3791 " something();\n" 3792 " // Comment too looooooooooong.\n" 3793 " somethingElse();\n" 3794 "});", 3795 getLLVMStyleWithColumns(29))); 3796 EXPECT_EQ("DEBUG({ int i; });", format("DEBUG({ int i; });")); 3797 EXPECT_EQ("DEBUG({ // comment\n" 3798 " int i;\n" 3799 "});", 3800 format("DEBUG({ // comment\n" 3801 "int i;\n" 3802 "});")); 3803 EXPECT_EQ("DEBUG({\n" 3804 " int i;\n" 3805 "\n" 3806 " // comment\n" 3807 " int j;\n" 3808 "});", 3809 format("DEBUG({\n" 3810 " int i;\n" 3811 "\n" 3812 " // comment\n" 3813 " int j;\n" 3814 "});")); 3815 3816 verifyFormat("DEBUG({\n" 3817 " if (a)\n" 3818 " return;\n" 3819 "});"); 3820 verifyGoogleFormat("DEBUG({\n" 3821 " if (a) return;\n" 3822 "});"); 3823 FormatStyle Style = getGoogleStyle(); 3824 Style.ColumnLimit = 45; 3825 verifyFormat("Debug(\n" 3826 " aaaaa,\n" 3827 " {\n" 3828 " if (aaaaaaaaaaaaaaaaaaaaaaaa) return;\n" 3829 " },\n" 3830 " a);", 3831 Style); 3832 3833 verifyFormat("SomeFunction({MACRO({ return output; }), b});"); 3834 3835 verifyNoCrash("^{v^{a}}"); 3836 } 3837 3838 TEST_F(FormatTest, FormatNestedBlocksInMacros) { 3839 EXPECT_EQ("#define MACRO() \\\n" 3840 " Debug(aaa, /* force line break */ \\\n" 3841 " { \\\n" 3842 " int i; \\\n" 3843 " int j; \\\n" 3844 " })", 3845 format("#define MACRO() Debug(aaa, /* force line break */ \\\n" 3846 " { int i; int j; })", 3847 getGoogleStyle())); 3848 3849 EXPECT_EQ("#define A \\\n" 3850 " [] { \\\n" 3851 " xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n" 3852 " xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); \\\n" 3853 " }", 3854 format("#define A [] { xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n" 3855 "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); }", 3856 getGoogleStyle())); 3857 } 3858 3859 TEST_F(FormatTest, PutEmptyBlocksIntoOneLine) { 3860 EXPECT_EQ("{}", format("{}")); 3861 verifyFormat("enum E {};"); 3862 verifyFormat("enum E {}"); 3863 FormatStyle Style = getLLVMStyle(); 3864 Style.SpaceInEmptyBlock = true; 3865 EXPECT_EQ("void f() { }", format("void f() {}", Style)); 3866 Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty; 3867 EXPECT_EQ("while (true) { }", format("while (true) {}", Style)); 3868 } 3869 3870 TEST_F(FormatTest, FormatBeginBlockEndMacros) { 3871 FormatStyle Style = getLLVMStyle(); 3872 Style.MacroBlockBegin = "^[A-Z_]+_BEGIN$"; 3873 Style.MacroBlockEnd = "^[A-Z_]+_END$"; 3874 verifyFormat("FOO_BEGIN\n" 3875 " FOO_ENTRY\n" 3876 "FOO_END", 3877 Style); 3878 verifyFormat("FOO_BEGIN\n" 3879 " NESTED_FOO_BEGIN\n" 3880 " NESTED_FOO_ENTRY\n" 3881 " NESTED_FOO_END\n" 3882 "FOO_END", 3883 Style); 3884 verifyFormat("FOO_BEGIN(Foo, Bar)\n" 3885 " int x;\n" 3886 " x = 1;\n" 3887 "FOO_END(Baz)", 3888 Style); 3889 } 3890 3891 //===----------------------------------------------------------------------===// 3892 // Line break tests. 3893 //===----------------------------------------------------------------------===// 3894 3895 TEST_F(FormatTest, PreventConfusingIndents) { 3896 verifyFormat( 3897 "void f() {\n" 3898 " SomeLongMethodName(SomeReallyLongMethod(CallOtherReallyLongMethod(\n" 3899 " parameter, parameter, parameter)),\n" 3900 " SecondLongCall(parameter));\n" 3901 "}"); 3902 verifyFormat( 3903 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3904 " aaaaaaaaaaaaaaaaaaaaaaaa(\n" 3905 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 3906 " aaaaaaaaaaaaaaaaaaaaaaaa);"); 3907 verifyFormat( 3908 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3909 " [aaaaaaaaaaaaaaaaaaaaaaaa\n" 3910 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n" 3911 " [aaaaaaaaaaaaaaaaaaaaaaaa]];"); 3912 verifyFormat( 3913 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n" 3914 " aaaaaaaaaaaaaaaaaaaaaaaa<\n" 3915 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>,\n" 3916 " aaaaaaaaaaaaaaaaaaaaaaaa>;"); 3917 verifyFormat("int a = bbbb && ccc &&\n" 3918 " fffff(\n" 3919 "#define A Just forcing a new line\n" 3920 " ddd);"); 3921 } 3922 3923 TEST_F(FormatTest, LineBreakingInBinaryExpressions) { 3924 verifyFormat( 3925 "bool aaaaaaa =\n" 3926 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() ||\n" 3927 " bbbbbbbb();"); 3928 verifyFormat( 3929 "bool aaaaaaa =\n" 3930 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() or\n" 3931 " bbbbbbbb();"); 3932 3933 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n" 3934 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb &&\n" 3935 " ccccccccc == ddddddddddd;"); 3936 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n" 3937 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb and\n" 3938 " ccccccccc == ddddddddddd;"); 3939 verifyFormat( 3940 "bool aaaaaaaaaaaaaaaaaaaaa =\n" 3941 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa not_eq bbbbbbbbbbbbbbbbbb and\n" 3942 " ccccccccc == ddddddddddd;"); 3943 3944 verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n" 3945 " aaaaaa) &&\n" 3946 " bbbbbb && cccccc;"); 3947 verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n" 3948 " aaaaaa) >>\n" 3949 " bbbbbb;"); 3950 verifyFormat("aa = Whitespaces.addUntouchableComment(\n" 3951 " SourceMgr.getSpellingColumnNumber(\n" 3952 " TheLine.Last->FormatTok.Tok.getLocation()) -\n" 3953 " 1);"); 3954 3955 verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 3956 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaaaaaaa\n" 3957 " cccccc) {\n}"); 3958 verifyFormat("if constexpr ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 3959 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaa\n" 3960 " cccccc) {\n}"); 3961 verifyFormat("if CONSTEXPR ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 3962 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaa\n" 3963 " cccccc) {\n}"); 3964 verifyFormat("b = a &&\n" 3965 " // Comment\n" 3966 " b.c && d;"); 3967 3968 // If the LHS of a comparison is not a binary expression itself, the 3969 // additional linebreak confuses many people. 3970 verifyFormat( 3971 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3972 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) > 5) {\n" 3973 "}"); 3974 verifyFormat( 3975 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3976 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n" 3977 "}"); 3978 verifyFormat( 3979 "if (aaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaa(\n" 3980 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n" 3981 "}"); 3982 verifyFormat( 3983 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3984 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) <=> 5) {\n" 3985 "}"); 3986 // Even explicit parentheses stress the precedence enough to make the 3987 // additional break unnecessary. 3988 verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3989 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n" 3990 "}"); 3991 // This cases is borderline, but with the indentation it is still readable. 3992 verifyFormat( 3993 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3994 " aaaaaaaaaaaaaaa) > aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3995 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 3996 "}", 3997 getLLVMStyleWithColumns(75)); 3998 3999 // If the LHS is a binary expression, we should still use the additional break 4000 // as otherwise the formatting hides the operator precedence. 4001 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4002 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 4003 " 5) {\n" 4004 "}"); 4005 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4006 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa <=>\n" 4007 " 5) {\n" 4008 "}"); 4009 4010 FormatStyle OnePerLine = getLLVMStyle(); 4011 OnePerLine.BinPackParameters = false; 4012 verifyFormat( 4013 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 4014 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 4015 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}", 4016 OnePerLine); 4017 4018 verifyFormat("int i = someFunction(aaaaaaa, 0)\n" 4019 " .aaa(aaaaaaaaaaaaa) *\n" 4020 " aaaaaaa +\n" 4021 " aaaaaaa;", 4022 getLLVMStyleWithColumns(40)); 4023 } 4024 4025 TEST_F(FormatTest, ExpressionIndentation) { 4026 verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4027 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4028 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 4029 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 4030 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb +\n" 4031 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb &&\n" 4032 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 4033 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >\n" 4034 " ccccccccccccccccccccccccccccccccccccccccc;"); 4035 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 4036 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4037 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 4038 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); 4039 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4040 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 4041 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 4042 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); 4043 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 4044 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 4045 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4046 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); 4047 verifyFormat("if () {\n" 4048 "} else if (aaaaa && bbbbb > // break\n" 4049 " ccccc) {\n" 4050 "}"); 4051 verifyFormat("if () {\n" 4052 "} else if constexpr (aaaaa && bbbbb > // break\n" 4053 " ccccc) {\n" 4054 "}"); 4055 verifyFormat("if () {\n" 4056 "} else if CONSTEXPR (aaaaa && bbbbb > // break\n" 4057 " ccccc) {\n" 4058 "}"); 4059 verifyFormat("if () {\n" 4060 "} else if (aaaaa &&\n" 4061 " bbbbb > // break\n" 4062 " ccccc &&\n" 4063 " ddddd) {\n" 4064 "}"); 4065 4066 // Presence of a trailing comment used to change indentation of b. 4067 verifyFormat("return aaaaaaaaaaaaaaaaaaa +\n" 4068 " b;\n" 4069 "return aaaaaaaaaaaaaaaaaaa +\n" 4070 " b; //", 4071 getLLVMStyleWithColumns(30)); 4072 } 4073 4074 TEST_F(FormatTest, ExpressionIndentationBreakingBeforeOperators) { 4075 // Not sure what the best system is here. Like this, the LHS can be found 4076 // immediately above an operator (everything with the same or a higher 4077 // indent). The RHS is aligned right of the operator and so compasses 4078 // everything until something with the same indent as the operator is found. 4079 // FIXME: Is this a good system? 4080 FormatStyle Style = getLLVMStyle(); 4081 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 4082 verifyFormat( 4083 "bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4084 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4085 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4086 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4087 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4088 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4089 " && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4090 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4091 " > ccccccccccccccccccccccccccccccccccccccccc;", 4092 Style); 4093 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4094 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4095 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4096 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 4097 Style); 4098 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4099 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4100 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4101 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 4102 Style); 4103 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4104 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4105 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4106 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 4107 Style); 4108 verifyFormat("if () {\n" 4109 "} else if (aaaaa\n" 4110 " && bbbbb // break\n" 4111 " > ccccc) {\n" 4112 "}", 4113 Style); 4114 verifyFormat("return (a)\n" 4115 " // comment\n" 4116 " + b;", 4117 Style); 4118 verifyFormat( 4119 "int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4120 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4121 " + cc;", 4122 Style); 4123 4124 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4125 " = aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 4126 Style); 4127 4128 // Forced by comments. 4129 verifyFormat( 4130 "unsigned ContentSize =\n" 4131 " sizeof(int16_t) // DWARF ARange version number\n" 4132 " + sizeof(int32_t) // Offset of CU in the .debug_info section\n" 4133 " + sizeof(int8_t) // Pointer Size (in bytes)\n" 4134 " + sizeof(int8_t); // Segment Size (in bytes)"); 4135 4136 verifyFormat("return boost::fusion::at_c<0>(iiii).second\n" 4137 " == boost::fusion::at_c<1>(iiii).second;", 4138 Style); 4139 4140 Style.ColumnLimit = 60; 4141 verifyFormat("zzzzzzzzzz\n" 4142 " = bbbbbbbbbbbbbbbbb\n" 4143 " >> aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa);", 4144 Style); 4145 4146 Style.ColumnLimit = 80; 4147 Style.IndentWidth = 4; 4148 Style.TabWidth = 4; 4149 Style.UseTab = FormatStyle::UT_Always; 4150 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 4151 Style.AlignOperands = false; 4152 EXPECT_EQ("return someVeryVeryLongConditionThatBarelyFitsOnALine\n" 4153 "\t&& (someOtherLongishConditionPart1\n" 4154 "\t\t|| someOtherEvenLongerNestedConditionPart2);", 4155 format("return someVeryVeryLongConditionThatBarelyFitsOnALine && " 4156 "(someOtherLongishConditionPart1 || " 4157 "someOtherEvenLongerNestedConditionPart2);", 4158 Style)); 4159 } 4160 4161 TEST_F(FormatTest, EnforcedOperatorWraps) { 4162 // Here we'd like to wrap after the || operators, but a comment is forcing an 4163 // earlier wrap. 4164 verifyFormat("bool x = aaaaa //\n" 4165 " || bbbbb\n" 4166 " //\n" 4167 " || cccc;"); 4168 } 4169 4170 TEST_F(FormatTest, NoOperandAlignment) { 4171 FormatStyle Style = getLLVMStyle(); 4172 Style.AlignOperands = false; 4173 verifyFormat("aaaaaaaaaaaaaa(aaaaaaaaaaaa,\n" 4174 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4175 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 4176 Style); 4177 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment; 4178 verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4179 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4180 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4181 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4182 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4183 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4184 " && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4185 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4186 " > ccccccccccccccccccccccccccccccccccccccccc;", 4187 Style); 4188 4189 verifyFormat("int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4190 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4191 " + cc;", 4192 Style); 4193 verifyFormat("int a = aa\n" 4194 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4195 " * cccccccccccccccccccccccccccccccccccc;\n", 4196 Style); 4197 4198 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 4199 verifyFormat("return (a > b\n" 4200 " // comment1\n" 4201 " // comment2\n" 4202 " || c);", 4203 Style); 4204 } 4205 4206 TEST_F(FormatTest, BreakingBeforeNonAssigmentOperators) { 4207 FormatStyle Style = getLLVMStyle(); 4208 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment; 4209 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 4210 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4211 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;", 4212 Style); 4213 } 4214 4215 TEST_F(FormatTest, AllowBinPackingInsideArguments) { 4216 FormatStyle Style = getLLVMStyle(); 4217 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment; 4218 Style.BinPackArguments = false; 4219 Style.ColumnLimit = 40; 4220 verifyFormat("void test() {\n" 4221 " someFunction(\n" 4222 " this + argument + is + quite\n" 4223 " + long + so + it + gets + wrapped\n" 4224 " + but + remains + bin - packed);\n" 4225 "}", 4226 Style); 4227 verifyFormat("void test() {\n" 4228 " someFunction(arg1,\n" 4229 " this + argument + is\n" 4230 " + quite + long + so\n" 4231 " + it + gets + wrapped\n" 4232 " + but + remains + bin\n" 4233 " - packed,\n" 4234 " arg3);\n" 4235 "}", 4236 Style); 4237 verifyFormat("void test() {\n" 4238 " someFunction(\n" 4239 " arg1,\n" 4240 " this + argument + has\n" 4241 " + anotherFunc(nested,\n" 4242 " calls + whose\n" 4243 " + arguments\n" 4244 " + are + also\n" 4245 " + wrapped,\n" 4246 " in + addition)\n" 4247 " + to + being + bin - packed,\n" 4248 " arg3);\n" 4249 "}", 4250 Style); 4251 4252 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 4253 verifyFormat("void test() {\n" 4254 " someFunction(\n" 4255 " arg1,\n" 4256 " this + argument + has +\n" 4257 " anotherFunc(nested,\n" 4258 " calls + whose +\n" 4259 " arguments +\n" 4260 " are + also +\n" 4261 " wrapped,\n" 4262 " in + addition) +\n" 4263 " to + being + bin - packed,\n" 4264 " arg3);\n" 4265 "}", 4266 Style); 4267 } 4268 4269 TEST_F(FormatTest, ConstructorInitializers) { 4270 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}"); 4271 verifyFormat("Constructor() : Inttializer(FitsOnTheLine) {}", 4272 getLLVMStyleWithColumns(45)); 4273 verifyFormat("Constructor()\n" 4274 " : Inttializer(FitsOnTheLine) {}", 4275 getLLVMStyleWithColumns(44)); 4276 verifyFormat("Constructor()\n" 4277 " : Inttializer(FitsOnTheLine) {}", 4278 getLLVMStyleWithColumns(43)); 4279 4280 verifyFormat("template <typename T>\n" 4281 "Constructor() : Initializer(FitsOnTheLine) {}", 4282 getLLVMStyleWithColumns(45)); 4283 4284 verifyFormat( 4285 "SomeClass::Constructor()\n" 4286 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}"); 4287 4288 verifyFormat( 4289 "SomeClass::Constructor()\n" 4290 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4291 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}"); 4292 verifyFormat( 4293 "SomeClass::Constructor()\n" 4294 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4295 " aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}"); 4296 verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4297 " aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 4298 " : aaaaaaaaaa(aaaaaa) {}"); 4299 4300 verifyFormat("Constructor()\n" 4301 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4302 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4303 " aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4304 " aaaaaaaaaaaaaaaaaaaaaaa() {}"); 4305 4306 verifyFormat("Constructor()\n" 4307 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4308 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); 4309 4310 verifyFormat("Constructor(int Parameter = 0)\n" 4311 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n" 4312 " aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}"); 4313 verifyFormat("Constructor()\n" 4314 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n" 4315 "}", 4316 getLLVMStyleWithColumns(60)); 4317 verifyFormat("Constructor()\n" 4318 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4319 " aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}"); 4320 4321 // Here a line could be saved by splitting the second initializer onto two 4322 // lines, but that is not desirable. 4323 verifyFormat("Constructor()\n" 4324 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n" 4325 " aaaaaaaaaaa(aaaaaaaaaaa),\n" 4326 " aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); 4327 4328 FormatStyle OnePerLine = getLLVMStyle(); 4329 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4330 OnePerLine.AllowAllParametersOfDeclarationOnNextLine = false; 4331 verifyFormat("SomeClass::Constructor()\n" 4332 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4333 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4334 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4335 OnePerLine); 4336 verifyFormat("SomeClass::Constructor()\n" 4337 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n" 4338 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4339 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4340 OnePerLine); 4341 verifyFormat("MyClass::MyClass(int var)\n" 4342 " : some_var_(var), // 4 space indent\n" 4343 " some_other_var_(var + 1) { // lined up\n" 4344 "}", 4345 OnePerLine); 4346 verifyFormat("Constructor()\n" 4347 " : aaaaa(aaaaaa),\n" 4348 " aaaaa(aaaaaa),\n" 4349 " aaaaa(aaaaaa),\n" 4350 " aaaaa(aaaaaa),\n" 4351 " aaaaa(aaaaaa) {}", 4352 OnePerLine); 4353 verifyFormat("Constructor()\n" 4354 " : aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n" 4355 " aaaaaaaaaaaaaaaaaaaaaa) {}", 4356 OnePerLine); 4357 OnePerLine.BinPackParameters = false; 4358 verifyFormat( 4359 "Constructor()\n" 4360 " : aaaaaaaaaaaaaaaaaaaaaaaa(\n" 4361 " aaaaaaaaaaa().aaa(),\n" 4362 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4363 OnePerLine); 4364 OnePerLine.ColumnLimit = 60; 4365 verifyFormat("Constructor()\n" 4366 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4367 " bbbbbbbbbbbbbbbbbbbbbbbb(b) {}", 4368 OnePerLine); 4369 4370 EXPECT_EQ("Constructor()\n" 4371 " : // Comment forcing unwanted break.\n" 4372 " aaaa(aaaa) {}", 4373 format("Constructor() :\n" 4374 " // Comment forcing unwanted break.\n" 4375 " aaaa(aaaa) {}")); 4376 } 4377 4378 TEST_F(FormatTest, AllowAllConstructorInitializersOnNextLine) { 4379 FormatStyle Style = getLLVMStyle(); 4380 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 4381 Style.ColumnLimit = 60; 4382 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4383 Style.AllowAllConstructorInitializersOnNextLine = true; 4384 Style.BinPackParameters = false; 4385 4386 for (int i = 0; i < 4; ++i) { 4387 // Test all combinations of parameters that should not have an effect. 4388 Style.AllowAllParametersOfDeclarationOnNextLine = i & 1; 4389 Style.AllowAllArgumentsOnNextLine = i & 2; 4390 4391 Style.AllowAllConstructorInitializersOnNextLine = true; 4392 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 4393 verifyFormat("Constructor()\n" 4394 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4395 Style); 4396 verifyFormat("Constructor() : a(a), b(b) {}", Style); 4397 4398 Style.AllowAllConstructorInitializersOnNextLine = false; 4399 verifyFormat("Constructor()\n" 4400 " : aaaaaaaaaaaaaaaaaaaa(a)\n" 4401 " , bbbbbbbbbbbbbbbbbbbbb(b) {}", 4402 Style); 4403 verifyFormat("Constructor() : a(a), b(b) {}", Style); 4404 4405 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon; 4406 Style.AllowAllConstructorInitializersOnNextLine = true; 4407 verifyFormat("Constructor()\n" 4408 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4409 Style); 4410 4411 Style.AllowAllConstructorInitializersOnNextLine = false; 4412 verifyFormat("Constructor()\n" 4413 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4414 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4415 Style); 4416 4417 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 4418 Style.AllowAllConstructorInitializersOnNextLine = true; 4419 verifyFormat("Constructor() :\n" 4420 " aaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4421 Style); 4422 4423 Style.AllowAllConstructorInitializersOnNextLine = false; 4424 verifyFormat("Constructor() :\n" 4425 " aaaaaaaaaaaaaaaaaa(a),\n" 4426 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4427 Style); 4428 } 4429 4430 // Test interactions between AllowAllParametersOfDeclarationOnNextLine and 4431 // AllowAllConstructorInitializersOnNextLine in all 4432 // BreakConstructorInitializers modes 4433 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 4434 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4435 Style.AllowAllConstructorInitializersOnNextLine = false; 4436 verifyFormat("SomeClassWithALongName::Constructor(\n" 4437 " int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb)\n" 4438 " : aaaaaaaaaaaaaaaaaaaa(a)\n" 4439 " , bbbbbbbbbbbbbbbbbbbbb(b) {}", 4440 Style); 4441 4442 Style.AllowAllConstructorInitializersOnNextLine = true; 4443 verifyFormat("SomeClassWithALongName::Constructor(\n" 4444 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4445 " int bbbbbbbbbbbbb,\n" 4446 " int cccccccccccccccc)\n" 4447 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4448 Style); 4449 4450 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4451 Style.AllowAllConstructorInitializersOnNextLine = false; 4452 verifyFormat("SomeClassWithALongName::Constructor(\n" 4453 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4454 " int bbbbbbbbbbbbb)\n" 4455 " : aaaaaaaaaaaaaaaaaaaa(a)\n" 4456 " , bbbbbbbbbbbbbbbbbbbbb(b) {}", 4457 Style); 4458 4459 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon; 4460 4461 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4462 verifyFormat("SomeClassWithALongName::Constructor(\n" 4463 " int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb)\n" 4464 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4465 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4466 Style); 4467 4468 Style.AllowAllConstructorInitializersOnNextLine = true; 4469 verifyFormat("SomeClassWithALongName::Constructor(\n" 4470 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4471 " int bbbbbbbbbbbbb,\n" 4472 " int cccccccccccccccc)\n" 4473 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4474 Style); 4475 4476 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4477 Style.AllowAllConstructorInitializersOnNextLine = false; 4478 verifyFormat("SomeClassWithALongName::Constructor(\n" 4479 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4480 " int bbbbbbbbbbbbb)\n" 4481 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4482 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4483 Style); 4484 4485 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 4486 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4487 verifyFormat("SomeClassWithALongName::Constructor(\n" 4488 " int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb) :\n" 4489 " aaaaaaaaaaaaaaaaaaaa(a),\n" 4490 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4491 Style); 4492 4493 Style.AllowAllConstructorInitializersOnNextLine = true; 4494 verifyFormat("SomeClassWithALongName::Constructor(\n" 4495 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4496 " int bbbbbbbbbbbbb,\n" 4497 " int cccccccccccccccc) :\n" 4498 " aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4499 Style); 4500 4501 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4502 Style.AllowAllConstructorInitializersOnNextLine = false; 4503 verifyFormat("SomeClassWithALongName::Constructor(\n" 4504 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4505 " int bbbbbbbbbbbbb) :\n" 4506 " aaaaaaaaaaaaaaaaaaaa(a),\n" 4507 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4508 Style); 4509 } 4510 4511 TEST_F(FormatTest, AllowAllArgumentsOnNextLine) { 4512 FormatStyle Style = getLLVMStyle(); 4513 Style.ColumnLimit = 60; 4514 Style.BinPackArguments = false; 4515 for (int i = 0; i < 4; ++i) { 4516 // Test all combinations of parameters that should not have an effect. 4517 Style.AllowAllParametersOfDeclarationOnNextLine = i & 1; 4518 Style.AllowAllConstructorInitializersOnNextLine = i & 2; 4519 4520 Style.AllowAllArgumentsOnNextLine = true; 4521 verifyFormat("void foo() {\n" 4522 " FunctionCallWithReallyLongName(\n" 4523 " aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbb);\n" 4524 "}", 4525 Style); 4526 Style.AllowAllArgumentsOnNextLine = false; 4527 verifyFormat("void foo() {\n" 4528 " FunctionCallWithReallyLongName(\n" 4529 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4530 " bbbbbbbbbbbb);\n" 4531 "}", 4532 Style); 4533 4534 Style.AllowAllArgumentsOnNextLine = true; 4535 verifyFormat("void foo() {\n" 4536 " auto VariableWithReallyLongName = {\n" 4537 " aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbb};\n" 4538 "}", 4539 Style); 4540 Style.AllowAllArgumentsOnNextLine = false; 4541 verifyFormat("void foo() {\n" 4542 " auto VariableWithReallyLongName = {\n" 4543 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4544 " bbbbbbbbbbbb};\n" 4545 "}", 4546 Style); 4547 } 4548 4549 // This parameter should not affect declarations. 4550 Style.BinPackParameters = false; 4551 Style.AllowAllArgumentsOnNextLine = false; 4552 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4553 verifyFormat("void FunctionCallWithReallyLongName(\n" 4554 " int aaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbb);", 4555 Style); 4556 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4557 verifyFormat("void FunctionCallWithReallyLongName(\n" 4558 " int aaaaaaaaaaaaaaaaaaaaaaa,\n" 4559 " int bbbbbbbbbbbb);", 4560 Style); 4561 } 4562 4563 TEST_F(FormatTest, BreakConstructorInitializersAfterColon) { 4564 FormatStyle Style = getLLVMStyle(); 4565 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 4566 4567 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}"); 4568 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}", 4569 getStyleWithColumns(Style, 45)); 4570 verifyFormat("Constructor() :\n" 4571 " Initializer(FitsOnTheLine) {}", 4572 getStyleWithColumns(Style, 44)); 4573 verifyFormat("Constructor() :\n" 4574 " Initializer(FitsOnTheLine) {}", 4575 getStyleWithColumns(Style, 43)); 4576 4577 verifyFormat("template <typename T>\n" 4578 "Constructor() : Initializer(FitsOnTheLine) {}", 4579 getStyleWithColumns(Style, 50)); 4580 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4581 verifyFormat( 4582 "SomeClass::Constructor() :\n" 4583 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}", 4584 Style); 4585 4586 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = false; 4587 verifyFormat( 4588 "SomeClass::Constructor() :\n" 4589 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}", 4590 Style); 4591 4592 verifyFormat( 4593 "SomeClass::Constructor() :\n" 4594 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4595 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4596 Style); 4597 verifyFormat( 4598 "SomeClass::Constructor() :\n" 4599 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4600 " aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}", 4601 Style); 4602 verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4603 " aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n" 4604 " aaaaaaaaaa(aaaaaa) {}", 4605 Style); 4606 4607 verifyFormat("Constructor() :\n" 4608 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4609 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4610 " aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4611 " aaaaaaaaaaaaaaaaaaaaaaa() {}", 4612 Style); 4613 4614 verifyFormat("Constructor() :\n" 4615 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4616 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4617 Style); 4618 4619 verifyFormat("Constructor(int Parameter = 0) :\n" 4620 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n" 4621 " aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}", 4622 Style); 4623 verifyFormat("Constructor() :\n" 4624 " aaaaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n" 4625 "}", 4626 getStyleWithColumns(Style, 60)); 4627 verifyFormat("Constructor() :\n" 4628 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4629 " aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}", 4630 Style); 4631 4632 // Here a line could be saved by splitting the second initializer onto two 4633 // lines, but that is not desirable. 4634 verifyFormat("Constructor() :\n" 4635 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n" 4636 " aaaaaaaaaaa(aaaaaaaaaaa),\n" 4637 " aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4638 Style); 4639 4640 FormatStyle OnePerLine = Style; 4641 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4642 OnePerLine.AllowAllConstructorInitializersOnNextLine = false; 4643 verifyFormat("SomeClass::Constructor() :\n" 4644 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4645 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4646 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4647 OnePerLine); 4648 verifyFormat("SomeClass::Constructor() :\n" 4649 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n" 4650 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4651 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4652 OnePerLine); 4653 verifyFormat("MyClass::MyClass(int var) :\n" 4654 " some_var_(var), // 4 space indent\n" 4655 " some_other_var_(var + 1) { // lined up\n" 4656 "}", 4657 OnePerLine); 4658 verifyFormat("Constructor() :\n" 4659 " aaaaa(aaaaaa),\n" 4660 " aaaaa(aaaaaa),\n" 4661 " aaaaa(aaaaaa),\n" 4662 " aaaaa(aaaaaa),\n" 4663 " aaaaa(aaaaaa) {}", 4664 OnePerLine); 4665 verifyFormat("Constructor() :\n" 4666 " aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n" 4667 " aaaaaaaaaaaaaaaaaaaaaa) {}", 4668 OnePerLine); 4669 OnePerLine.BinPackParameters = false; 4670 verifyFormat("Constructor() :\n" 4671 " aaaaaaaaaaaaaaaaaaaaaaaa(\n" 4672 " aaaaaaaaaaa().aaa(),\n" 4673 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4674 OnePerLine); 4675 OnePerLine.ColumnLimit = 60; 4676 verifyFormat("Constructor() :\n" 4677 " aaaaaaaaaaaaaaaaaaaa(a),\n" 4678 " bbbbbbbbbbbbbbbbbbbbbbbb(b) {}", 4679 OnePerLine); 4680 4681 EXPECT_EQ("Constructor() :\n" 4682 " // Comment forcing unwanted break.\n" 4683 " aaaa(aaaa) {}", 4684 format("Constructor() :\n" 4685 " // Comment forcing unwanted break.\n" 4686 " aaaa(aaaa) {}", 4687 Style)); 4688 4689 Style.ColumnLimit = 0; 4690 verifyFormat("SomeClass::Constructor() :\n" 4691 " a(a) {}", 4692 Style); 4693 verifyFormat("SomeClass::Constructor() noexcept :\n" 4694 " a(a) {}", 4695 Style); 4696 verifyFormat("SomeClass::Constructor() :\n" 4697 " a(a), b(b), c(c) {}", 4698 Style); 4699 verifyFormat("SomeClass::Constructor() :\n" 4700 " a(a) {\n" 4701 " foo();\n" 4702 " bar();\n" 4703 "}", 4704 Style); 4705 4706 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 4707 verifyFormat("SomeClass::Constructor() :\n" 4708 " a(a), b(b), c(c) {\n" 4709 "}", 4710 Style); 4711 verifyFormat("SomeClass::Constructor() :\n" 4712 " a(a) {\n" 4713 "}", 4714 Style); 4715 4716 Style.ColumnLimit = 80; 4717 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 4718 Style.ConstructorInitializerIndentWidth = 2; 4719 verifyFormat("SomeClass::Constructor() : a(a), b(b), c(c) {}", Style); 4720 verifyFormat("SomeClass::Constructor() :\n" 4721 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4722 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {}", 4723 Style); 4724 4725 // `ConstructorInitializerIndentWidth` actually applies to InheritanceList as 4726 // well 4727 Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon; 4728 verifyFormat( 4729 "class SomeClass\n" 4730 " : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4731 " public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};", 4732 Style); 4733 Style.BreakInheritanceList = FormatStyle::BILS_BeforeComma; 4734 verifyFormat( 4735 "class SomeClass\n" 4736 " : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4737 " , public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};", 4738 Style); 4739 Style.BreakInheritanceList = FormatStyle::BILS_AfterColon; 4740 verifyFormat( 4741 "class SomeClass :\n" 4742 " public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4743 " public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};", 4744 Style); 4745 } 4746 4747 #ifndef EXPENSIVE_CHECKS 4748 // Expensive checks enables libstdc++ checking which includes validating the 4749 // state of ranges used in std::priority_queue - this blows out the 4750 // runtime/scalability of the function and makes this test unacceptably slow. 4751 TEST_F(FormatTest, MemoizationTests) { 4752 // This breaks if the memoization lookup does not take \c Indent and 4753 // \c LastSpace into account. 4754 verifyFormat( 4755 "extern CFRunLoopTimerRef\n" 4756 "CFRunLoopTimerCreate(CFAllocatorRef allocato, CFAbsoluteTime fireDate,\n" 4757 " CFTimeInterval interval, CFOptionFlags flags,\n" 4758 " CFIndex order, CFRunLoopTimerCallBack callout,\n" 4759 " CFRunLoopTimerContext *context) {}"); 4760 4761 // Deep nesting somewhat works around our memoization. 4762 verifyFormat( 4763 "aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 4764 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 4765 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 4766 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 4767 " aaaaa())))))))))))))))))))))))))))))))))))))));", 4768 getLLVMStyleWithColumns(65)); 4769 verifyFormat( 4770 "aaaaa(\n" 4771 " aaaaa,\n" 4772 " aaaaa(\n" 4773 " aaaaa,\n" 4774 " aaaaa(\n" 4775 " aaaaa,\n" 4776 " aaaaa(\n" 4777 " aaaaa,\n" 4778 " aaaaa(\n" 4779 " aaaaa,\n" 4780 " aaaaa(\n" 4781 " aaaaa,\n" 4782 " aaaaa(\n" 4783 " aaaaa,\n" 4784 " aaaaa(\n" 4785 " aaaaa,\n" 4786 " aaaaa(\n" 4787 " aaaaa,\n" 4788 " aaaaa(\n" 4789 " aaaaa,\n" 4790 " aaaaa(\n" 4791 " aaaaa,\n" 4792 " aaaaa(\n" 4793 " aaaaa,\n" 4794 " aaaaa))))))))))));", 4795 getLLVMStyleWithColumns(65)); 4796 verifyFormat( 4797 "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" 4798 " a),\n" 4799 " a),\n" 4800 " a),\n" 4801 " a),\n" 4802 " a),\n" 4803 " a),\n" 4804 " a),\n" 4805 " a),\n" 4806 " a),\n" 4807 " a),\n" 4808 " a),\n" 4809 " a),\n" 4810 " a),\n" 4811 " a),\n" 4812 " a),\n" 4813 " a),\n" 4814 " a)", 4815 getLLVMStyleWithColumns(65)); 4816 4817 // This test takes VERY long when memoization is broken. 4818 FormatStyle OnePerLine = getLLVMStyle(); 4819 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4820 OnePerLine.BinPackParameters = false; 4821 std::string input = "Constructor()\n" 4822 " : aaaa(a,\n"; 4823 for (unsigned i = 0, e = 80; i != e; ++i) { 4824 input += " a,\n"; 4825 } 4826 input += " a) {}"; 4827 verifyFormat(input, OnePerLine); 4828 } 4829 #endif 4830 4831 TEST_F(FormatTest, BreaksAsHighAsPossible) { 4832 verifyFormat( 4833 "void f() {\n" 4834 " if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaaaaaaaa) ||\n" 4835 " (bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb && bbbbbbbbbbbbbbbbbbbbbbbbbb))\n" 4836 " f();\n" 4837 "}"); 4838 verifyFormat("if (Intervals[i].getRange().getFirst() <\n" 4839 " Intervals[i - 1].getRange().getLast()) {\n}"); 4840 } 4841 4842 TEST_F(FormatTest, BreaksFunctionDeclarations) { 4843 // Principially, we break function declarations in a certain order: 4844 // 1) break amongst arguments. 4845 verifyFormat("Aaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccc,\n" 4846 " Cccccccccccccc cccccccccccccc);"); 4847 verifyFormat("template <class TemplateIt>\n" 4848 "SomeReturnType SomeFunction(TemplateIt begin, TemplateIt end,\n" 4849 " TemplateIt *stop) {}"); 4850 4851 // 2) break after return type. 4852 verifyFormat( 4853 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4854 "bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccccccccccccccc);", 4855 getGoogleStyle()); 4856 4857 // 3) break after (. 4858 verifyFormat( 4859 "Aaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbb(\n" 4860 " Cccccccccccccccccccccccccccccc cccccccccccccccccccccccccccccccc);", 4861 getGoogleStyle()); 4862 4863 // 4) break before after nested name specifiers. 4864 verifyFormat( 4865 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4866 "SomeClasssssssssssssssssssssssssssssssssssssss::\n" 4867 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc);", 4868 getGoogleStyle()); 4869 4870 // However, there are exceptions, if a sufficient amount of lines can be 4871 // saved. 4872 // FIXME: The precise cut-offs wrt. the number of saved lines might need some 4873 // more adjusting. 4874 verifyFormat("Aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n" 4875 " Cccccccccccccc cccccccccc,\n" 4876 " Cccccccccccccc cccccccccc,\n" 4877 " Cccccccccccccc cccccccccc,\n" 4878 " Cccccccccccccc cccccccccc);"); 4879 verifyFormat( 4880 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4881 "bbbbbbbbbbb(Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 4882 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 4883 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);", 4884 getGoogleStyle()); 4885 verifyFormat( 4886 "Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n" 4887 " Cccccccccccccc cccccccccc,\n" 4888 " Cccccccccccccc cccccccccc,\n" 4889 " Cccccccccccccc cccccccccc,\n" 4890 " Cccccccccccccc cccccccccc,\n" 4891 " Cccccccccccccc cccccccccc,\n" 4892 " Cccccccccccccc cccccccccc);"); 4893 verifyFormat("Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 4894 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 4895 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 4896 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 4897 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);"); 4898 4899 // Break after multi-line parameters. 4900 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4901 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4902 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4903 " bbbb bbbb);"); 4904 verifyFormat("void SomeLoooooooooooongFunction(\n" 4905 " std::unique_ptr<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n" 4906 " aaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4907 " int bbbbbbbbbbbbb);"); 4908 4909 // Treat overloaded operators like other functions. 4910 verifyFormat("SomeLoooooooooooooooooooooooooogType\n" 4911 "operator>(const SomeLoooooooooooooooooooooooooogType &other);"); 4912 verifyFormat("SomeLoooooooooooooooooooooooooogType\n" 4913 "operator>>(const SomeLooooooooooooooooooooooooogType &other);"); 4914 verifyFormat("SomeLoooooooooooooooooooooooooogType\n" 4915 "operator<<(const SomeLooooooooooooooooooooooooogType &other);"); 4916 verifyGoogleFormat( 4917 "SomeLoooooooooooooooooooooooooooooogType operator>>(\n" 4918 " const SomeLooooooooogType &a, const SomeLooooooooogType &b);"); 4919 verifyGoogleFormat( 4920 "SomeLoooooooooooooooooooooooooooooogType operator<<(\n" 4921 " const SomeLooooooooogType &a, const SomeLooooooooogType &b);"); 4922 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4923 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = 1);"); 4924 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa\n" 4925 "aaaaaaaaaaaaaaaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaa = 1);"); 4926 verifyGoogleFormat( 4927 "typename aaaaaaaaaa<aaaaaa>::aaaaaaaaaaa\n" 4928 "aaaaaaaaaa<aaaaaa>::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4929 " bool *aaaaaaaaaaaaaaaaaa, bool *aa) {}"); 4930 verifyGoogleFormat("template <typename T>\n" 4931 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4932 "aaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaaaaa(\n" 4933 " aaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaa);"); 4934 4935 FormatStyle Style = getLLVMStyle(); 4936 Style.PointerAlignment = FormatStyle::PAS_Left; 4937 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4938 " aaaaaaaaaaaaaaaaaaaaaaaaa* const aaaaaaaaaaaa) {}", 4939 Style); 4940 verifyFormat("void aaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*\n" 4941 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4942 Style); 4943 } 4944 4945 TEST_F(FormatTest, DontBreakBeforeQualifiedOperator) { 4946 // Regression test for https://bugs.llvm.org/show_bug.cgi?id=40516: 4947 // Prefer keeping `::` followed by `operator` together. 4948 EXPECT_EQ("const aaaa::bbbbbbb &\n" 4949 "ccccccccc::operator++() {\n" 4950 " stuff();\n" 4951 "}", 4952 format("const aaaa::bbbbbbb\n" 4953 "&ccccccccc::operator++() { stuff(); }", 4954 getLLVMStyleWithColumns(40))); 4955 } 4956 4957 TEST_F(FormatTest, TrailingReturnType) { 4958 verifyFormat("auto foo() -> int;\n"); 4959 // correct trailing return type spacing 4960 verifyFormat("auto operator->() -> int;\n"); 4961 verifyFormat("auto operator++(int) -> int;\n"); 4962 4963 verifyFormat("struct S {\n" 4964 " auto bar() const -> int;\n" 4965 "};"); 4966 verifyFormat("template <size_t Order, typename T>\n" 4967 "auto load_img(const std::string &filename)\n" 4968 " -> alias::tensor<Order, T, mem::tag::cpu> {}"); 4969 verifyFormat("auto SomeFunction(A aaaaaaaaaaaaaaaaaaaaa) const\n" 4970 " -> decltype(f(aaaaaaaaaaaaaaaaaaaaa)) {}"); 4971 verifyFormat("auto doSomething(Aaaaaa *aaaaaa) -> decltype(aaaaaa->f()) {}"); 4972 verifyFormat("template <typename T>\n" 4973 "auto aaaaaaaaaaaaaaaaaaaaaa(T t)\n" 4974 " -> decltype(eaaaaaaaaaaaaaaa<T>(t.a).aaaaaaaa());"); 4975 4976 // Not trailing return types. 4977 verifyFormat("void f() { auto a = b->c(); }"); 4978 } 4979 4980 TEST_F(FormatTest, BreaksFunctionDeclarationsWithTrailingTokens) { 4981 // Avoid breaking before trailing 'const' or other trailing annotations, if 4982 // they are not function-like. 4983 FormatStyle Style = getGoogleStyle(); 4984 Style.ColumnLimit = 47; 4985 verifyFormat("void someLongFunction(\n" 4986 " int someLoooooooooooooongParameter) const {\n}", 4987 getLLVMStyleWithColumns(47)); 4988 verifyFormat("LoooooongReturnType\n" 4989 "someLoooooooongFunction() const {}", 4990 getLLVMStyleWithColumns(47)); 4991 verifyFormat("LoooooongReturnType someLoooooooongFunction()\n" 4992 " const {}", 4993 Style); 4994 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n" 4995 " aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE;"); 4996 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n" 4997 " aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE FINAL;"); 4998 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n" 4999 " aaaaa aaaaaaaaaaaaaaaaaaaa) override final;"); 5000 verifyFormat("virtual void aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa,\n" 5001 " aaaaaaaaaaa aaaaa) const override;"); 5002 verifyGoogleFormat( 5003 "virtual void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5004 " const override;"); 5005 5006 // Even if the first parameter has to be wrapped. 5007 verifyFormat("void someLongFunction(\n" 5008 " int someLongParameter) const {}", 5009 getLLVMStyleWithColumns(46)); 5010 verifyFormat("void someLongFunction(\n" 5011 " int someLongParameter) const {}", 5012 Style); 5013 verifyFormat("void someLongFunction(\n" 5014 " int someLongParameter) override {}", 5015 Style); 5016 verifyFormat("void someLongFunction(\n" 5017 " int someLongParameter) OVERRIDE {}", 5018 Style); 5019 verifyFormat("void someLongFunction(\n" 5020 " int someLongParameter) final {}", 5021 Style); 5022 verifyFormat("void someLongFunction(\n" 5023 " int someLongParameter) FINAL {}", 5024 Style); 5025 verifyFormat("void someLongFunction(\n" 5026 " int parameter) const override {}", 5027 Style); 5028 5029 Style.BreakBeforeBraces = FormatStyle::BS_Allman; 5030 verifyFormat("void someLongFunction(\n" 5031 " int someLongParameter) const\n" 5032 "{\n" 5033 "}", 5034 Style); 5035 5036 Style.BreakBeforeBraces = FormatStyle::BS_Whitesmiths; 5037 verifyFormat("void someLongFunction(\n" 5038 " int someLongParameter) const\n" 5039 " {\n" 5040 " }", 5041 Style); 5042 5043 // Unless these are unknown annotations. 5044 verifyFormat("void SomeFunction(aaaaaaaaaa aaaaaaaaaaaaaaa,\n" 5045 " aaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5046 " LONG_AND_UGLY_ANNOTATION;"); 5047 5048 // Breaking before function-like trailing annotations is fine to keep them 5049 // close to their arguments. 5050 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5051 " LOCKS_EXCLUDED(aaaaaaaaaaaaa);"); 5052 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n" 5053 " LOCKS_EXCLUDED(aaaaaaaaaaaaa);"); 5054 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n" 5055 " LOCKS_EXCLUDED(aaaaaaaaaaaaa) {}"); 5056 verifyGoogleFormat("void aaaaaaaaaaaaaa(aaaaaaaa aaa) override\n" 5057 " AAAAAAAAAAAAAAAAAAAAAAAA(aaaaaaaaaaaaaaa);"); 5058 verifyFormat("SomeFunction([](int i) LOCKS_EXCLUDED(a) {});"); 5059 5060 verifyFormat( 5061 "void aaaaaaaaaaaaaaaaaa()\n" 5062 " __attribute__((aaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaa,\n" 5063 " aaaaaaaaaaaaaaaaaaaaaaaaa));"); 5064 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5065 " __attribute__((unused));"); 5066 verifyGoogleFormat( 5067 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5068 " GUARDED_BY(aaaaaaaaaaaa);"); 5069 verifyGoogleFormat( 5070 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5071 " GUARDED_BY(aaaaaaaaaaaa);"); 5072 verifyGoogleFormat( 5073 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n" 5074 " aaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5075 verifyGoogleFormat( 5076 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n" 5077 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5078 } 5079 5080 TEST_F(FormatTest, FunctionAnnotations) { 5081 verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n" 5082 "int OldFunction(const string ¶meter) {}"); 5083 verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n" 5084 "string OldFunction(const string ¶meter) {}"); 5085 verifyFormat("template <typename T>\n" 5086 "DEPRECATED(\"Use NewClass::NewFunction instead.\")\n" 5087 "string OldFunction(const string ¶meter) {}"); 5088 5089 // Not function annotations. 5090 verifyFormat("ASSERT(\"aaaaa\") << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5091 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"); 5092 verifyFormat("TEST_F(ThisIsATestFixtureeeeeeeeeeeee,\n" 5093 " ThisIsATestWithAReallyReallyReallyReallyLongName) {}"); 5094 verifyFormat("MACRO(abc).function() // wrap\n" 5095 " << abc;"); 5096 verifyFormat("MACRO(abc)->function() // wrap\n" 5097 " << abc;"); 5098 verifyFormat("MACRO(abc)::function() // wrap\n" 5099 " << abc;"); 5100 } 5101 5102 TEST_F(FormatTest, BreaksDesireably) { 5103 verifyFormat("if (aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n" 5104 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n" 5105 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa)) {\n}"); 5106 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5107 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n" 5108 "}"); 5109 5110 verifyFormat( 5111 "aaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5112 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); 5113 5114 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5115 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5116 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 5117 5118 verifyFormat( 5119 "aaaaaaaa(aaaaaaaaaaaaa,\n" 5120 " aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5121 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n" 5122 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5123 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));"); 5124 5125 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 5126 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5127 5128 verifyFormat( 5129 "void f() {\n" 5130 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&\n" 5131 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 5132 "}"); 5133 verifyFormat( 5134 "aaaaaa(new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5135 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 5136 verifyFormat( 5137 "aaaaaa(aaa, new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5138 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 5139 verifyFormat( 5140 "aaaaaa(aaa,\n" 5141 " new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5142 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5143 " aaaa);"); 5144 verifyFormat("aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5145 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5146 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5147 5148 // Indent consistently independent of call expression and unary operator. 5149 verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 5150 " dddddddddddddddddddddddddddddd));"); 5151 verifyFormat("aaaaaaaaaaa(!bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 5152 " dddddddddddddddddddddddddddddd));"); 5153 verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbb.ccccccccccccccccc(\n" 5154 " dddddddddddddddddddddddddddddd));"); 5155 5156 // This test case breaks on an incorrect memoization, i.e. an optimization not 5157 // taking into account the StopAt value. 5158 verifyFormat( 5159 "return aaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 5160 " aaaaaaaaaaa(aaaaaaaaa) || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 5161 " aaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 5162 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5163 5164 verifyFormat("{\n {\n {\n" 5165 " Annotation.SpaceRequiredBefore =\n" 5166 " Line.Tokens[i - 1].Tok.isNot(tok::l_paren) &&\n" 5167 " Line.Tokens[i - 1].Tok.isNot(tok::l_square);\n" 5168 " }\n }\n}"); 5169 5170 // Break on an outer level if there was a break on an inner level. 5171 EXPECT_EQ("f(g(h(a, // comment\n" 5172 " b, c),\n" 5173 " d, e),\n" 5174 " x, y);", 5175 format("f(g(h(a, // comment\n" 5176 " b, c), d, e), x, y);")); 5177 5178 // Prefer breaking similar line breaks. 5179 verifyFormat( 5180 "const int kTrackingOptions = NSTrackingMouseMoved |\n" 5181 " NSTrackingMouseEnteredAndExited |\n" 5182 " NSTrackingActiveAlways;"); 5183 } 5184 5185 TEST_F(FormatTest, FormatsDeclarationsOnePerLine) { 5186 FormatStyle NoBinPacking = getGoogleStyle(); 5187 NoBinPacking.BinPackParameters = false; 5188 NoBinPacking.BinPackArguments = true; 5189 verifyFormat("void f() {\n" 5190 " f(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa,\n" 5191 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 5192 "}", 5193 NoBinPacking); 5194 verifyFormat("void f(int aaaaaaaaaaaaaaaaaaaa,\n" 5195 " int aaaaaaaaaaaaaaaaaaaa,\n" 5196 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 5197 NoBinPacking); 5198 5199 NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false; 5200 verifyFormat("void aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5201 " vector<int> bbbbbbbbbbbbbbb);", 5202 NoBinPacking); 5203 // FIXME: This behavior difference is probably not wanted. However, currently 5204 // we cannot distinguish BreakBeforeParameter being set because of the wrapped 5205 // template arguments from BreakBeforeParameter being set because of the 5206 // one-per-line formatting. 5207 verifyFormat( 5208 "void fffffffffff(aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa,\n" 5209 " aaaaaaaaaa> aaaaaaaaaa);", 5210 NoBinPacking); 5211 verifyFormat( 5212 "void fffffffffff(\n" 5213 " aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaa>\n" 5214 " aaaaaaaaaa);"); 5215 } 5216 5217 TEST_F(FormatTest, FormatsOneParameterPerLineIfNecessary) { 5218 FormatStyle NoBinPacking = getGoogleStyle(); 5219 NoBinPacking.BinPackParameters = false; 5220 NoBinPacking.BinPackArguments = false; 5221 verifyFormat("f(aaaaaaaaaaaaaaaaaaaa,\n" 5222 " aaaaaaaaaaaaaaaaaaaa,\n" 5223 " aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaa);", 5224 NoBinPacking); 5225 verifyFormat("aaaaaaa(aaaaaaaaaaaaa,\n" 5226 " aaaaaaaaaaaaa,\n" 5227 " aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));", 5228 NoBinPacking); 5229 verifyFormat( 5230 "aaaaaaaa(aaaaaaaaaaaaa,\n" 5231 " aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5232 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n" 5233 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5234 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));", 5235 NoBinPacking); 5236 verifyFormat("aaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n" 5237 " .aaaaaaaaaaaaaaaaaa();", 5238 NoBinPacking); 5239 verifyFormat("void f() {\n" 5240 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5241 " aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaa);\n" 5242 "}", 5243 NoBinPacking); 5244 5245 verifyFormat( 5246 "aaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5247 " aaaaaaaaaaaa,\n" 5248 " aaaaaaaaaaaa);", 5249 NoBinPacking); 5250 verifyFormat( 5251 "somefunction(someotherFunction(ddddddddddddddddddddddddddddddddddd,\n" 5252 " ddddddddddddddddddddddddddddd),\n" 5253 " test);", 5254 NoBinPacking); 5255 5256 verifyFormat("std::vector<aaaaaaaaaaaaaaaaaaaaaaa,\n" 5257 " aaaaaaaaaaaaaaaaaaaaaaa,\n" 5258 " aaaaaaaaaaaaaaaaaaaaaaa>\n" 5259 " aaaaaaaaaaaaaaaaaa;", 5260 NoBinPacking); 5261 verifyFormat("a(\"a\"\n" 5262 " \"a\",\n" 5263 " a);"); 5264 5265 NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false; 5266 verifyFormat("void aaaaaaaaaa(aaaaaaaaa,\n" 5267 " aaaaaaaaa,\n" 5268 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5269 NoBinPacking); 5270 verifyFormat( 5271 "void f() {\n" 5272 " aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n" 5273 " .aaaaaaa();\n" 5274 "}", 5275 NoBinPacking); 5276 verifyFormat( 5277 "template <class SomeType, class SomeOtherType>\n" 5278 "SomeType SomeFunction(SomeType Type, SomeOtherType OtherType) {}", 5279 NoBinPacking); 5280 } 5281 5282 TEST_F(FormatTest, AdaptiveOnePerLineFormatting) { 5283 FormatStyle Style = getLLVMStyleWithColumns(15); 5284 Style.ExperimentalAutoDetectBinPacking = true; 5285 EXPECT_EQ("aaa(aaaa,\n" 5286 " aaaa,\n" 5287 " aaaa);\n" 5288 "aaa(aaaa,\n" 5289 " aaaa,\n" 5290 " aaaa);", 5291 format("aaa(aaaa,\n" // one-per-line 5292 " aaaa,\n" 5293 " aaaa );\n" 5294 "aaa(aaaa, aaaa, aaaa);", // inconclusive 5295 Style)); 5296 EXPECT_EQ("aaa(aaaa, aaaa,\n" 5297 " aaaa);\n" 5298 "aaa(aaaa, aaaa,\n" 5299 " aaaa);", 5300 format("aaa(aaaa, aaaa,\n" // bin-packed 5301 " aaaa );\n" 5302 "aaa(aaaa, aaaa, aaaa);", // inconclusive 5303 Style)); 5304 } 5305 5306 TEST_F(FormatTest, FormatsBuilderPattern) { 5307 verifyFormat("return llvm::StringSwitch<Reference::Kind>(name)\n" 5308 " .StartsWith(\".eh_frame_hdr\", ORDER_EH_FRAMEHDR)\n" 5309 " .StartsWith(\".eh_frame\", ORDER_EH_FRAME)\n" 5310 " .StartsWith(\".init\", ORDER_INIT)\n" 5311 " .StartsWith(\".fini\", ORDER_FINI)\n" 5312 " .StartsWith(\".hash\", ORDER_HASH)\n" 5313 " .Default(ORDER_TEXT);\n"); 5314 5315 verifyFormat("return aaaaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa() <\n" 5316 " aaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa();"); 5317 verifyFormat("aaaaaaa->aaaaaaa\n" 5318 " ->aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5319 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5320 " ->aaaaaaaa(aaaaaaaaaaaaaaa);"); 5321 verifyFormat( 5322 "aaaaaaa->aaaaaaa\n" 5323 " ->aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5324 " ->aaaaaaaa(aaaaaaaaaaaaaaa);"); 5325 verifyFormat( 5326 "aaaaaaaaaaaaaaaaaaa()->aaaaaa(bbbbb)->aaaaaaaaaaaaaaaaaaa( // break\n" 5327 " aaaaaaaaaaaaaa);"); 5328 verifyFormat( 5329 "aaaaaaaaaaaaaaaaaaaaaaa *aaaaaaaaa =\n" 5330 " aaaaaa->aaaaaaaaaaaa()\n" 5331 " ->aaaaaaaaaaaaaaaa(\n" 5332 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5333 " ->aaaaaaaaaaaaaaaaa();"); 5334 verifyGoogleFormat( 5335 "void f() {\n" 5336 " someo->Add((new util::filetools::Handler(dir))\n" 5337 " ->OnEvent1(NewPermanentCallback(\n" 5338 " this, &HandlerHolderClass::EventHandlerCBA))\n" 5339 " ->OnEvent2(NewPermanentCallback(\n" 5340 " this, &HandlerHolderClass::EventHandlerCBB))\n" 5341 " ->OnEvent3(NewPermanentCallback(\n" 5342 " this, &HandlerHolderClass::EventHandlerCBC))\n" 5343 " ->OnEvent5(NewPermanentCallback(\n" 5344 " this, &HandlerHolderClass::EventHandlerCBD))\n" 5345 " ->OnEvent6(NewPermanentCallback(\n" 5346 " this, &HandlerHolderClass::EventHandlerCBE)));\n" 5347 "}"); 5348 5349 verifyFormat( 5350 "aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa();"); 5351 verifyFormat("aaaaaaaaaaaaaaa()\n" 5352 " .aaaaaaaaaaaaaaa()\n" 5353 " .aaaaaaaaaaaaaaa()\n" 5354 " .aaaaaaaaaaaaaaa()\n" 5355 " .aaaaaaaaaaaaaaa();"); 5356 verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n" 5357 " .aaaaaaaaaaaaaaa()\n" 5358 " .aaaaaaaaaaaaaaa()\n" 5359 " .aaaaaaaaaaaaaaa();"); 5360 verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n" 5361 " .aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n" 5362 " .aaaaaaaaaaaaaaa();"); 5363 verifyFormat("aaaaaaaaaaaaa->aaaaaaaaaaaaaaaaaaaaaaaa()\n" 5364 " ->aaaaaaaaaaaaaae(0)\n" 5365 " ->aaaaaaaaaaaaaaa();"); 5366 5367 // Don't linewrap after very short segments. 5368 verifyFormat("a().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5369 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5370 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 5371 verifyFormat("aa().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5372 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5373 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 5374 verifyFormat("aaa()\n" 5375 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5376 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5377 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 5378 5379 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n" 5380 " .aaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5381 " .has<bbbbbbbbbbbbbbbbbbbbb>();"); 5382 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n" 5383 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n" 5384 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>();"); 5385 5386 // Prefer not to break after empty parentheses. 5387 verifyFormat("FirstToken->WhitespaceRange.getBegin().getLocWithOffset(\n" 5388 " First->LastNewlineOffset);"); 5389 5390 // Prefer not to create "hanging" indents. 5391 verifyFormat( 5392 "return !soooooooooooooome_map\n" 5393 " .insert(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5394 " .second;"); 5395 verifyFormat( 5396 "return aaaaaaaaaaaaaaaa\n" 5397 " .aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa)\n" 5398 " .aaaa(aaaaaaaaaaaaaa);"); 5399 // No hanging indent here. 5400 verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa.aaaaaaaaaaaaaaa(\n" 5401 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5402 verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa().aaaaaaaaaaaaaaa(\n" 5403 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5404 verifyFormat("aaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n" 5405 " .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5406 getLLVMStyleWithColumns(60)); 5407 verifyFormat("aaaaaaaaaaaaaaaaaa\n" 5408 " .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n" 5409 " .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5410 getLLVMStyleWithColumns(59)); 5411 verifyFormat("aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5412 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5413 " .aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5414 5415 // Dont break if only closing statements before member call 5416 verifyFormat("test() {\n" 5417 " ([]() -> {\n" 5418 " int b = 32;\n" 5419 " return 3;\n" 5420 " }).foo();\n" 5421 "}"); 5422 verifyFormat("test() {\n" 5423 " (\n" 5424 " []() -> {\n" 5425 " int b = 32;\n" 5426 " return 3;\n" 5427 " },\n" 5428 " foo, bar)\n" 5429 " .foo();\n" 5430 "}"); 5431 verifyFormat("test() {\n" 5432 " ([]() -> {\n" 5433 " int b = 32;\n" 5434 " return 3;\n" 5435 " })\n" 5436 " .foo()\n" 5437 " .bar();\n" 5438 "}"); 5439 verifyFormat("test() {\n" 5440 " ([]() -> {\n" 5441 " int b = 32;\n" 5442 " return 3;\n" 5443 " })\n" 5444 " .foo(\"aaaaaaaaaaaaaaaaa\"\n" 5445 " \"bbbb\");\n" 5446 "}", 5447 getLLVMStyleWithColumns(30)); 5448 } 5449 5450 TEST_F(FormatTest, BreaksAccordingToOperatorPrecedence) { 5451 verifyFormat( 5452 "if (aaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 5453 " bbbbbbbbbbbbbbbbbbbbbbbbb && ccccccccccccccccccccccccc) {\n}"); 5454 verifyFormat( 5455 "if (aaaaaaaaaaaaaaaaaaaaaaaaa or\n" 5456 " bbbbbbbbbbbbbbbbbbbbbbbbb and cccccccccccccccccccccccc) {\n}"); 5457 5458 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa && bbbbbbbbbbbbbbbbbbbbbbbbb ||\n" 5459 " ccccccccccccccccccccccccc) {\n}"); 5460 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa and bbbbbbbbbbbbbbbbbbbbbbbb or\n" 5461 " ccccccccccccccccccccccccc) {\n}"); 5462 5463 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb ||\n" 5464 " ccccccccccccccccccccccccc) {\n}"); 5465 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb or\n" 5466 " ccccccccccccccccccccccccc) {\n}"); 5467 5468 verifyFormat( 5469 "if ((aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb) &&\n" 5470 " ccccccccccccccccccccccccc) {\n}"); 5471 verifyFormat( 5472 "if ((aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb) and\n" 5473 " ccccccccccccccccccccccccc) {\n}"); 5474 5475 verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA ||\n" 5476 " bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB ||\n" 5477 " cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC ||\n" 5478 " dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;"); 5479 verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA or\n" 5480 " bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB or\n" 5481 " cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC or\n" 5482 " dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;"); 5483 5484 verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa ||\n" 5485 " aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) &&\n" 5486 " aaaaaaaaaaaaaaa != aa) {\n}"); 5487 verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa or\n" 5488 " aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) and\n" 5489 " aaaaaaaaaaaaaaa != aa) {\n}"); 5490 } 5491 5492 TEST_F(FormatTest, BreaksAfterAssignments) { 5493 verifyFormat( 5494 "unsigned Cost =\n" 5495 " TTI.getMemoryOpCost(I->getOpcode(), VectorTy, SI->getAlignment(),\n" 5496 " SI->getPointerAddressSpaceee());\n"); 5497 verifyFormat( 5498 "CharSourceRange LineRange = CharSourceRange::getTokenRange(\n" 5499 " Line.Tokens.front().Tok.getLo(), Line.Tokens.back().Tok.getLoc());"); 5500 5501 verifyFormat( 5502 "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa = aaaaaaaaaaaaaa(0).aaaa().aaaaaaaaa(\n" 5503 " aaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaa);"); 5504 verifyFormat("unsigned OriginalStartColumn =\n" 5505 " SourceMgr.getSpellingColumnNumber(\n" 5506 " Current.FormatTok.getStartOfNonWhitespace()) -\n" 5507 " 1;"); 5508 } 5509 5510 TEST_F(FormatTest, ConfigurableBreakAssignmentPenalty) { 5511 FormatStyle Style = getLLVMStyle(); 5512 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 5513 " bbbbbbbbbbbbbbbbbbbbbbbbbb + cccccccccccccccccccccccccc;", 5514 Style); 5515 5516 Style.PenaltyBreakAssignment = 20; 5517 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa = bbbbbbbbbbbbbbbbbbbbbbbbbb +\n" 5518 " cccccccccccccccccccccccccc;", 5519 Style); 5520 } 5521 5522 TEST_F(FormatTest, AlignsAfterAssignments) { 5523 verifyFormat( 5524 "int Result = aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5525 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5526 verifyFormat( 5527 "Result += aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5528 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5529 verifyFormat( 5530 "Result >>= aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5531 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5532 verifyFormat( 5533 "int Result = (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5534 " aaaaaaaaaaaaaaaaaaaaaaaaa);"); 5535 verifyFormat( 5536 "double LooooooooooooooooooooooooongResult = aaaaaaaaaaaaaaaaaaaaaaaa +\n" 5537 " aaaaaaaaaaaaaaaaaaaaaaaa +\n" 5538 " aaaaaaaaaaaaaaaaaaaaaaaa;"); 5539 } 5540 5541 TEST_F(FormatTest, AlignsAfterReturn) { 5542 verifyFormat( 5543 "return aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5544 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5545 verifyFormat( 5546 "return (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5547 " aaaaaaaaaaaaaaaaaaaaaaaaa);"); 5548 verifyFormat( 5549 "return aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n" 5550 " aaaaaaaaaaaaaaaaaaaaaa();"); 5551 verifyFormat( 5552 "return (aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n" 5553 " aaaaaaaaaaaaaaaaaaaaaa());"); 5554 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5555 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5556 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5557 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) &&\n" 5558 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5559 verifyFormat("return\n" 5560 " // true if code is one of a or b.\n" 5561 " code == a || code == b;"); 5562 } 5563 5564 TEST_F(FormatTest, AlignsAfterOpenBracket) { 5565 verifyFormat( 5566 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n" 5567 " aaaaaaaaa aaaaaaa) {}"); 5568 verifyFormat( 5569 "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n" 5570 " aaaaaaaaaaa aaaaaaaaa);"); 5571 verifyFormat( 5572 "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n" 5573 " aaaaaaaaaaaaaaaaaaaaa));"); 5574 FormatStyle Style = getLLVMStyle(); 5575 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 5576 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5577 " aaaaaaaaaaa aaaaaaaa, aaaaaaaaa aaaaaaa) {}", 5578 Style); 5579 verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n" 5580 " aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaa aaaaaaaaa);", 5581 Style); 5582 verifyFormat("SomeLongVariableName->someFunction(\n" 5583 " foooooooo(aaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa));", 5584 Style); 5585 verifyFormat( 5586 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n" 5587 " aaaaaaaaa aaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 5588 Style); 5589 verifyFormat( 5590 "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n" 5591 " aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5592 Style); 5593 verifyFormat( 5594 "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n" 5595 " aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));", 5596 Style); 5597 5598 verifyFormat("bbbbbbbbbbbb(aaaaaaaaaaaaaaaaaaaaaaaa, //\n" 5599 " ccccccc(aaaaaaaaaaaaaaaaa, //\n" 5600 " b));", 5601 Style); 5602 5603 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 5604 Style.BinPackArguments = false; 5605 Style.BinPackParameters = false; 5606 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5607 " aaaaaaaaaaa aaaaaaaa,\n" 5608 " aaaaaaaaa aaaaaaa,\n" 5609 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 5610 Style); 5611 verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n" 5612 " aaaaaaaaaaa aaaaaaaaa,\n" 5613 " aaaaaaaaaaa aaaaaaaaa,\n" 5614 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5615 Style); 5616 verifyFormat("SomeLongVariableName->someFunction(foooooooo(\n" 5617 " aaaaaaaaaaaaaaa,\n" 5618 " aaaaaaaaaaaaaaaaaaaaa,\n" 5619 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));", 5620 Style); 5621 verifyFormat( 5622 "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa(\n" 5623 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));", 5624 Style); 5625 verifyFormat( 5626 "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaa.aaaaaaaaaa(\n" 5627 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));", 5628 Style); 5629 verifyFormat( 5630 "aaaaaaaaaaaaaaaaaaaaaaaa(\n" 5631 " aaaaaaaaaaaaaaaaaaaaa(\n" 5632 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)),\n" 5633 " aaaaaaaaaaaaaaaa);", 5634 Style); 5635 verifyFormat( 5636 "aaaaaaaaaaaaaaaaaaaaaaaa(\n" 5637 " aaaaaaaaaaaaaaaaaaaaa(\n" 5638 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)) &&\n" 5639 " aaaaaaaaaaaaaaaa);", 5640 Style); 5641 } 5642 5643 TEST_F(FormatTest, ParenthesesAndOperandAlignment) { 5644 FormatStyle Style = getLLVMStyleWithColumns(40); 5645 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5646 " bbbbbbbbbbbbbbbbbbbbbb);", 5647 Style); 5648 Style.AlignAfterOpenBracket = FormatStyle::BAS_Align; 5649 Style.AlignOperands = false; 5650 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5651 " bbbbbbbbbbbbbbbbbbbbbb);", 5652 Style); 5653 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 5654 Style.AlignOperands = true; 5655 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5656 " bbbbbbbbbbbbbbbbbbbbbb);", 5657 Style); 5658 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 5659 Style.AlignOperands = false; 5660 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5661 " bbbbbbbbbbbbbbbbbbbbbb);", 5662 Style); 5663 } 5664 5665 TEST_F(FormatTest, BreaksConditionalExpressions) { 5666 verifyFormat( 5667 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5668 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5669 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5670 verifyFormat( 5671 "aaaa(aaaaaaaaaa, aaaaaaaa,\n" 5672 " aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5673 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5674 verifyFormat( 5675 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5676 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5677 verifyFormat("aaaa(aaaaaaaaa, aaaaaaaaa,\n" 5678 " aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5679 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5680 verifyFormat( 5681 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa)\n" 5682 " : aaaaaaaaaaaaa);"); 5683 verifyFormat( 5684 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5685 " aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5686 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5687 " aaaaaaaaaaaaa);"); 5688 verifyFormat( 5689 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5690 " aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5691 " aaaaaaaaaaaaa);"); 5692 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5693 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5694 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5695 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5696 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5697 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5698 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5699 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5700 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5701 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5702 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5703 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5704 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5705 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5706 " ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5707 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5708 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5709 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5710 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5711 " : aaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5712 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n" 5713 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5714 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5715 " : aaaaaaaaaaaaaaaa;"); 5716 verifyFormat( 5717 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5718 " ? aaaaaaaaaaaaaaa\n" 5719 " : aaaaaaaaaaaaaaa;"); 5720 verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n" 5721 " aaaaaaaaa\n" 5722 " ? b\n" 5723 " : c);"); 5724 verifyFormat("return aaaa == bbbb\n" 5725 " // comment\n" 5726 " ? aaaa\n" 5727 " : bbbb;"); 5728 verifyFormat("unsigned Indent =\n" 5729 " format(TheLine.First,\n" 5730 " IndentForLevel[TheLine.Level] >= 0\n" 5731 " ? IndentForLevel[TheLine.Level]\n" 5732 " : TheLine * 2,\n" 5733 " TheLine.InPPDirective, PreviousEndOfLineColumn);", 5734 getLLVMStyleWithColumns(60)); 5735 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n" 5736 " ? aaaaaaaaaaaaaaa\n" 5737 " : bbbbbbbbbbbbbbb //\n" 5738 " ? ccccccccccccccc\n" 5739 " : ddddddddddddddd;"); 5740 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n" 5741 " ? aaaaaaaaaaaaaaa\n" 5742 " : (bbbbbbbbbbbbbbb //\n" 5743 " ? ccccccccccccccc\n" 5744 " : ddddddddddddddd);"); 5745 verifyFormat( 5746 "int aaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5747 " ? aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5748 " aaaaaaaaaaaaaaaaaaaaa +\n" 5749 " aaaaaaaaaaaaaaaaaaaaa\n" 5750 " : aaaaaaaaaa;"); 5751 verifyFormat( 5752 "aaaaaa = aaaaaaaaaaaa ? aaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5753 " : aaaaaaaaaaaaaaaaaaaaaa\n" 5754 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5755 5756 FormatStyle NoBinPacking = getLLVMStyle(); 5757 NoBinPacking.BinPackArguments = false; 5758 verifyFormat( 5759 "void f() {\n" 5760 " g(aaa,\n" 5761 " aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n" 5762 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5763 " ? aaaaaaaaaaaaaaa\n" 5764 " : aaaaaaaaaaaaaaa);\n" 5765 "}", 5766 NoBinPacking); 5767 verifyFormat( 5768 "void f() {\n" 5769 " g(aaa,\n" 5770 " aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n" 5771 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5772 " ?: aaaaaaaaaaaaaaa);\n" 5773 "}", 5774 NoBinPacking); 5775 5776 verifyFormat("SomeFunction(aaaaaaaaaaaaaaaaa,\n" 5777 " // comment.\n" 5778 " ccccccccccccccccccccccccccccccccccccccc\n" 5779 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5780 " : bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);"); 5781 5782 // Assignments in conditional expressions. Apparently not uncommon :-(. 5783 verifyFormat("return a != b\n" 5784 " // comment\n" 5785 " ? a = b\n" 5786 " : a = b;"); 5787 verifyFormat("return a != b\n" 5788 " // comment\n" 5789 " ? a = a != b\n" 5790 " // comment\n" 5791 " ? a = b\n" 5792 " : a\n" 5793 " : a;\n"); 5794 verifyFormat("return a != b\n" 5795 " // comment\n" 5796 " ? a\n" 5797 " : a = a != b\n" 5798 " // comment\n" 5799 " ? a = b\n" 5800 " : a;"); 5801 } 5802 5803 TEST_F(FormatTest, BreaksConditionalExpressionsAfterOperator) { 5804 FormatStyle Style = getLLVMStyle(); 5805 Style.BreakBeforeTernaryOperators = false; 5806 Style.ColumnLimit = 70; 5807 verifyFormat( 5808 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5809 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5810 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5811 Style); 5812 verifyFormat( 5813 "aaaa(aaaaaaaaaa, aaaaaaaa,\n" 5814 " aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5815 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5816 Style); 5817 verifyFormat( 5818 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5819 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5820 Style); 5821 verifyFormat("aaaa(aaaaaaaa, aaaaaaaaaa,\n" 5822 " aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5823 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5824 Style); 5825 verifyFormat( 5826 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa) :\n" 5827 " aaaaaaaaaaaaa);", 5828 Style); 5829 verifyFormat( 5830 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5831 " aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5832 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5833 " aaaaaaaaaaaaa);", 5834 Style); 5835 verifyFormat( 5836 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5837 " aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5838 " aaaaaaaaaaaaa);", 5839 Style); 5840 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5841 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5842 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n" 5843 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5844 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5845 Style); 5846 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5847 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5848 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5849 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n" 5850 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5851 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5852 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5853 Style); 5854 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5855 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?:\n" 5856 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5857 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5858 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5859 Style); 5860 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5861 " aaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5862 " aaaaaaaaaaaaaaaaaaaaaaaaaaa;", 5863 Style); 5864 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n" 5865 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5866 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5867 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 5868 Style); 5869 verifyFormat( 5870 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5871 " aaaaaaaaaaaaaaa :\n" 5872 " aaaaaaaaaaaaaaa;", 5873 Style); 5874 verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n" 5875 " aaaaaaaaa ?\n" 5876 " b :\n" 5877 " c);", 5878 Style); 5879 verifyFormat("unsigned Indent =\n" 5880 " format(TheLine.First,\n" 5881 " IndentForLevel[TheLine.Level] >= 0 ?\n" 5882 " IndentForLevel[TheLine.Level] :\n" 5883 " TheLine * 2,\n" 5884 " TheLine.InPPDirective, PreviousEndOfLineColumn);", 5885 Style); 5886 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n" 5887 " aaaaaaaaaaaaaaa :\n" 5888 " bbbbbbbbbbbbbbb ? //\n" 5889 " ccccccccccccccc :\n" 5890 " ddddddddddddddd;", 5891 Style); 5892 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n" 5893 " aaaaaaaaaaaaaaa :\n" 5894 " (bbbbbbbbbbbbbbb ? //\n" 5895 " ccccccccccccccc :\n" 5896 " ddddddddddddddd);", 5897 Style); 5898 verifyFormat("int i = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5899 " /*bbbbbbbbbbbbbbb=*/bbbbbbbbbbbbbbbbbbbbbbbbb :\n" 5900 " ccccccccccccccccccccccccccc;", 5901 Style); 5902 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5903 " aaaaa :\n" 5904 " bbbbbbbbbbbbbbb + cccccccccccccccc;", 5905 Style); 5906 } 5907 5908 TEST_F(FormatTest, DeclarationsOfMultipleVariables) { 5909 verifyFormat("bool aaaaaaaaaaaaaaaaa = aaaaaa->aaaaaaaaaaaaaaaaa(),\n" 5910 " aaaaaaaaaaa = aaaaaa->aaaaaaaaaaa();"); 5911 verifyFormat("bool a = true, b = false;"); 5912 5913 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaa =\n" 5914 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa),\n" 5915 " bbbbbbbbbbbbbbbbbbbbbbbbb =\n" 5916 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(bbbbbbbbbbbbbbbb);"); 5917 verifyFormat( 5918 "bool aaaaaaaaaaaaaaaaaaaaa =\n" 5919 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb && cccccccccccccccccccccccccccc,\n" 5920 " d = e && f;"); 5921 verifyFormat("aaaaaaaaa a = aaaaaaaaaaaaaaaaaaaa, b = bbbbbbbbbbbbbbbbbbbb,\n" 5922 " c = cccccccccccccccccccc, d = dddddddddddddddddddd;"); 5923 verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n" 5924 " *c = ccccccccccccccccccc, *d = ddddddddddddddddddd;"); 5925 verifyFormat("aaaaaaaaa ***a = aaaaaaaaaaaaaaaaaaa, ***b = bbbbbbbbbbbbbbb,\n" 5926 " ***c = ccccccccccccccccccc, ***d = ddddddddddddddd;"); 5927 5928 FormatStyle Style = getGoogleStyle(); 5929 Style.PointerAlignment = FormatStyle::PAS_Left; 5930 Style.DerivePointerAlignment = false; 5931 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5932 " *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaa,\n" 5933 " *b = bbbbbbbbbbbbbbbbbbb;", 5934 Style); 5935 verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n" 5936 " *b = bbbbbbbbbbbbbbbbbbb, *d = ddddddddddddddddddd;", 5937 Style); 5938 verifyFormat("vector<int*> a, b;", Style); 5939 verifyFormat("for (int *p, *q; p != q; p = p->next) {\n}", Style); 5940 } 5941 5942 TEST_F(FormatTest, ConditionalExpressionsInBrackets) { 5943 verifyFormat("arr[foo ? bar : baz];"); 5944 verifyFormat("f()[foo ? bar : baz];"); 5945 verifyFormat("(a + b)[foo ? bar : baz];"); 5946 verifyFormat("arr[foo ? (4 > 5 ? 4 : 5) : 5 < 5 ? 5 : 7];"); 5947 } 5948 5949 TEST_F(FormatTest, AlignsStringLiterals) { 5950 verifyFormat("loooooooooooooooooooooooooongFunction(\"short literal \"\n" 5951 " \"short literal\");"); 5952 verifyFormat( 5953 "looooooooooooooooooooooooongFunction(\n" 5954 " \"short literal\"\n" 5955 " \"looooooooooooooooooooooooooooooooooooooooooooooooong literal\");"); 5956 verifyFormat("someFunction(\"Always break between multi-line\"\n" 5957 " \" string literals\",\n" 5958 " and, other, parameters);"); 5959 EXPECT_EQ("fun + \"1243\" /* comment */\n" 5960 " \"5678\";", 5961 format("fun + \"1243\" /* comment */\n" 5962 " \"5678\";", 5963 getLLVMStyleWithColumns(28))); 5964 EXPECT_EQ( 5965 "aaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 5966 " \"aaaaaaaaaaaaaaaaaaaaa\"\n" 5967 " \"aaaaaaaaaaaaaaaa\";", 5968 format("aaaaaa =" 5969 "\"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa " 5970 "aaaaaaaaaaaaaaaaaaaaa\" " 5971 "\"aaaaaaaaaaaaaaaa\";")); 5972 verifyFormat("a = a + \"a\"\n" 5973 " \"a\"\n" 5974 " \"a\";"); 5975 verifyFormat("f(\"a\", \"b\"\n" 5976 " \"c\");"); 5977 5978 verifyFormat( 5979 "#define LL_FORMAT \"ll\"\n" 5980 "printf(\"aaaaa: %d, bbbbbb: %\" LL_FORMAT \"d, cccccccc: %\" LL_FORMAT\n" 5981 " \"d, ddddddddd: %\" LL_FORMAT \"d\");"); 5982 5983 verifyFormat("#define A(X) \\\n" 5984 " \"aaaaa\" #X \"bbbbbb\" \\\n" 5985 " \"ccccc\"", 5986 getLLVMStyleWithColumns(23)); 5987 verifyFormat("#define A \"def\"\n" 5988 "f(\"abc\" A \"ghi\"\n" 5989 " \"jkl\");"); 5990 5991 verifyFormat("f(L\"a\"\n" 5992 " L\"b\");"); 5993 verifyFormat("#define A(X) \\\n" 5994 " L\"aaaaa\" #X L\"bbbbbb\" \\\n" 5995 " L\"ccccc\"", 5996 getLLVMStyleWithColumns(25)); 5997 5998 verifyFormat("f(@\"a\"\n" 5999 " @\"b\");"); 6000 verifyFormat("NSString s = @\"a\"\n" 6001 " @\"b\"\n" 6002 " @\"c\";"); 6003 verifyFormat("NSString s = @\"a\"\n" 6004 " \"b\"\n" 6005 " \"c\";"); 6006 } 6007 6008 TEST_F(FormatTest, ReturnTypeBreakingStyle) { 6009 FormatStyle Style = getLLVMStyle(); 6010 // No declarations or definitions should be moved to own line. 6011 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_None; 6012 verifyFormat("class A {\n" 6013 " int f() { return 1; }\n" 6014 " int g();\n" 6015 "};\n" 6016 "int f() { return 1; }\n" 6017 "int g();\n", 6018 Style); 6019 6020 // All declarations and definitions should have the return type moved to its 6021 // own 6022 // line. 6023 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All; 6024 verifyFormat("class E {\n" 6025 " int\n" 6026 " f() {\n" 6027 " return 1;\n" 6028 " }\n" 6029 " int\n" 6030 " g();\n" 6031 "};\n" 6032 "int\n" 6033 "f() {\n" 6034 " return 1;\n" 6035 "}\n" 6036 "int\n" 6037 "g();\n", 6038 Style); 6039 6040 // Top-level definitions, and no kinds of declarations should have the 6041 // return type moved to its own line. 6042 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevelDefinitions; 6043 verifyFormat("class B {\n" 6044 " int f() { return 1; }\n" 6045 " int g();\n" 6046 "};\n" 6047 "int\n" 6048 "f() {\n" 6049 " return 1;\n" 6050 "}\n" 6051 "int g();\n", 6052 Style); 6053 6054 // Top-level definitions and declarations should have the return type moved 6055 // to its own line. 6056 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevel; 6057 verifyFormat("class C {\n" 6058 " int f() { return 1; }\n" 6059 " int g();\n" 6060 "};\n" 6061 "int\n" 6062 "f() {\n" 6063 " return 1;\n" 6064 "}\n" 6065 "int\n" 6066 "g();\n", 6067 Style); 6068 6069 // All definitions should have the return type moved to its own line, but no 6070 // kinds of declarations. 6071 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions; 6072 verifyFormat("class D {\n" 6073 " int\n" 6074 " f() {\n" 6075 " return 1;\n" 6076 " }\n" 6077 " int g();\n" 6078 "};\n" 6079 "int\n" 6080 "f() {\n" 6081 " return 1;\n" 6082 "}\n" 6083 "int g();\n", 6084 Style); 6085 verifyFormat("const char *\n" 6086 "f(void) {\n" // Break here. 6087 " return \"\";\n" 6088 "}\n" 6089 "const char *bar(void);\n", // No break here. 6090 Style); 6091 verifyFormat("template <class T>\n" 6092 "T *\n" 6093 "f(T &c) {\n" // Break here. 6094 " return NULL;\n" 6095 "}\n" 6096 "template <class T> T *f(T &c);\n", // No break here. 6097 Style); 6098 verifyFormat("class C {\n" 6099 " int\n" 6100 " operator+() {\n" 6101 " return 1;\n" 6102 " }\n" 6103 " int\n" 6104 " operator()() {\n" 6105 " return 1;\n" 6106 " }\n" 6107 "};\n", 6108 Style); 6109 verifyFormat("void\n" 6110 "A::operator()() {}\n" 6111 "void\n" 6112 "A::operator>>() {}\n" 6113 "void\n" 6114 "A::operator+() {}\n", 6115 Style); 6116 verifyFormat("void *operator new(std::size_t s);", // No break here. 6117 Style); 6118 verifyFormat("void *\n" 6119 "operator new(std::size_t s) {}", 6120 Style); 6121 verifyFormat("void *\n" 6122 "operator delete[](void *ptr) {}", 6123 Style); 6124 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 6125 verifyFormat("const char *\n" 6126 "f(void)\n" // Break here. 6127 "{\n" 6128 " return \"\";\n" 6129 "}\n" 6130 "const char *bar(void);\n", // No break here. 6131 Style); 6132 verifyFormat("template <class T>\n" 6133 "T *\n" // Problem here: no line break 6134 "f(T &c)\n" // Break here. 6135 "{\n" 6136 " return NULL;\n" 6137 "}\n" 6138 "template <class T> T *f(T &c);\n", // No break here. 6139 Style); 6140 verifyFormat("int\n" 6141 "foo(A<bool> a)\n" 6142 "{\n" 6143 " return a;\n" 6144 "}\n", 6145 Style); 6146 verifyFormat("int\n" 6147 "foo(A<8> a)\n" 6148 "{\n" 6149 " return a;\n" 6150 "}\n", 6151 Style); 6152 verifyFormat("int\n" 6153 "foo(A<B<bool>, 8> a)\n" 6154 "{\n" 6155 " return a;\n" 6156 "}\n", 6157 Style); 6158 verifyFormat("int\n" 6159 "foo(A<B<8>, bool> a)\n" 6160 "{\n" 6161 " return a;\n" 6162 "}\n", 6163 Style); 6164 verifyFormat("int\n" 6165 "foo(A<B<bool>, bool> a)\n" 6166 "{\n" 6167 " return a;\n" 6168 "}\n", 6169 Style); 6170 verifyFormat("int\n" 6171 "foo(A<B<8>, 8> a)\n" 6172 "{\n" 6173 " return a;\n" 6174 "}\n", 6175 Style); 6176 6177 Style = getGNUStyle(); 6178 6179 // Test for comments at the end of function declarations. 6180 verifyFormat("void\n" 6181 "foo (int a, /*abc*/ int b) // def\n" 6182 "{\n" 6183 "}\n", 6184 Style); 6185 6186 verifyFormat("void\n" 6187 "foo (int a, /* abc */ int b) /* def */\n" 6188 "{\n" 6189 "}\n", 6190 Style); 6191 6192 // Definitions that should not break after return type 6193 verifyFormat("void foo (int a, int b); // def\n", Style); 6194 verifyFormat("void foo (int a, int b); /* def */\n", Style); 6195 verifyFormat("void foo (int a, int b);\n", Style); 6196 } 6197 6198 TEST_F(FormatTest, AlwaysBreakBeforeMultilineStrings) { 6199 FormatStyle NoBreak = getLLVMStyle(); 6200 NoBreak.AlwaysBreakBeforeMultilineStrings = false; 6201 FormatStyle Break = getLLVMStyle(); 6202 Break.AlwaysBreakBeforeMultilineStrings = true; 6203 verifyFormat("aaaa = \"bbbb\"\n" 6204 " \"cccc\";", 6205 NoBreak); 6206 verifyFormat("aaaa =\n" 6207 " \"bbbb\"\n" 6208 " \"cccc\";", 6209 Break); 6210 verifyFormat("aaaa(\"bbbb\"\n" 6211 " \"cccc\");", 6212 NoBreak); 6213 verifyFormat("aaaa(\n" 6214 " \"bbbb\"\n" 6215 " \"cccc\");", 6216 Break); 6217 verifyFormat("aaaa(qqq, \"bbbb\"\n" 6218 " \"cccc\");", 6219 NoBreak); 6220 verifyFormat("aaaa(qqq,\n" 6221 " \"bbbb\"\n" 6222 " \"cccc\");", 6223 Break); 6224 verifyFormat("aaaa(qqq,\n" 6225 " L\"bbbb\"\n" 6226 " L\"cccc\");", 6227 Break); 6228 verifyFormat("aaaaa(aaaaaa, aaaaaaa(\"aaaa\"\n" 6229 " \"bbbb\"));", 6230 Break); 6231 verifyFormat("string s = someFunction(\n" 6232 " \"abc\"\n" 6233 " \"abc\");", 6234 Break); 6235 6236 // As we break before unary operators, breaking right after them is bad. 6237 verifyFormat("string foo = abc ? \"x\"\n" 6238 " \"blah blah blah blah blah blah\"\n" 6239 " : \"y\";", 6240 Break); 6241 6242 // Don't break if there is no column gain. 6243 verifyFormat("f(\"aaaa\"\n" 6244 " \"bbbb\");", 6245 Break); 6246 6247 // Treat literals with escaped newlines like multi-line string literals. 6248 EXPECT_EQ("x = \"a\\\n" 6249 "b\\\n" 6250 "c\";", 6251 format("x = \"a\\\n" 6252 "b\\\n" 6253 "c\";", 6254 NoBreak)); 6255 EXPECT_EQ("xxxx =\n" 6256 " \"a\\\n" 6257 "b\\\n" 6258 "c\";", 6259 format("xxxx = \"a\\\n" 6260 "b\\\n" 6261 "c\";", 6262 Break)); 6263 6264 EXPECT_EQ("NSString *const kString =\n" 6265 " @\"aaaa\"\n" 6266 " @\"bbbb\";", 6267 format("NSString *const kString = @\"aaaa\"\n" 6268 "@\"bbbb\";", 6269 Break)); 6270 6271 Break.ColumnLimit = 0; 6272 verifyFormat("const char *hello = \"hello llvm\";", Break); 6273 } 6274 6275 TEST_F(FormatTest, AlignsPipes) { 6276 verifyFormat( 6277 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6278 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6279 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6280 verifyFormat( 6281 "aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa\n" 6282 " << aaaaaaaaaaaaaaaaaaaa;"); 6283 verifyFormat( 6284 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6285 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6286 verifyFormat( 6287 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 6288 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6289 verifyFormat( 6290 "llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"\n" 6291 " \"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\"\n" 6292 " << \"ccccccccccccccccccccccccccccccccccccccccccccccccc\";"); 6293 verifyFormat( 6294 "aaaaaaaa << (aaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6295 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6296 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6297 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6298 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6299 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6300 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 6301 verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaaaaaa: \"\n" 6302 " << aaaaaaaaaaaaaaaaa(aaaaaaaa, aaaaaaaaaaa);"); 6303 verifyFormat( 6304 "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6305 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6306 verifyFormat( 6307 "auto Diag = diag() << aaaaaaaaaaaaaaaa(aaaaaaaaaaaa, aaaaaaaaaaaaa,\n" 6308 " aaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6309 6310 verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \"\n" 6311 " << aaaaaaaa.aaaaaaaaaaaa(aaa)->aaaaaaaaaaaaaa();"); 6312 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6313 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6314 " aaaaaaaaaaaaaaaaaaaaa)\n" 6315 " << aaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6316 verifyFormat("LOG_IF(aaa == //\n" 6317 " bbb)\n" 6318 " << a << b;"); 6319 6320 // But sometimes, breaking before the first "<<" is desirable. 6321 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n" 6322 " << aaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaa);"); 6323 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbb)\n" 6324 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6325 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6326 verifyFormat("SemaRef.Diag(Loc, diag::note_for_range_begin_end)\n" 6327 " << BEF << IsTemplate << Description << E->getType();"); 6328 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n" 6329 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6330 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6331 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n" 6332 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6333 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6334 " << aaa;"); 6335 6336 verifyFormat( 6337 "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6338 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6339 6340 // Incomplete string literal. 6341 EXPECT_EQ("llvm::errs() << \"\n" 6342 " << a;", 6343 format("llvm::errs() << \"\n<<a;")); 6344 6345 verifyFormat("void f() {\n" 6346 " CHECK_EQ(aaaa, (*bbbbbbbbb)->cccccc)\n" 6347 " << \"qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\";\n" 6348 "}"); 6349 6350 // Handle 'endl'. 6351 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << endl\n" 6352 " << bbbbbbbbbbbbbbbbbbbbbb << endl;"); 6353 verifyFormat("llvm::errs() << endl << bbbbbbbbbbbbbbbbbbbbbb << endl;"); 6354 6355 // Handle '\n'. 6356 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \"\\n\"\n" 6357 " << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";"); 6358 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \'\\n\'\n" 6359 " << bbbbbbbbbbbbbbbbbbbbbb << \'\\n\';"); 6360 verifyFormat("llvm::errs() << aaaa << \"aaaaaaaaaaaaaaaaaa\\n\"\n" 6361 " << bbbb << \"bbbbbbbbbbbbbbbbbb\\n\";"); 6362 verifyFormat("llvm::errs() << \"\\n\" << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";"); 6363 } 6364 6365 TEST_F(FormatTest, KeepStringLabelValuePairsOnALine) { 6366 verifyFormat("return out << \"somepacket = {\\n\"\n" 6367 " << \" aaaaaa = \" << pkt.aaaaaa << \"\\n\"\n" 6368 " << \" bbbb = \" << pkt.bbbb << \"\\n\"\n" 6369 " << \" cccccc = \" << pkt.cccccc << \"\\n\"\n" 6370 " << \" ddd = [\" << pkt.ddd << \"]\\n\"\n" 6371 " << \"}\";"); 6372 6373 verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n" 6374 " << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n" 6375 " << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa;"); 6376 verifyFormat( 6377 "llvm::outs() << \"aaaaaaaaaaaaaaaaa = \" << aaaaaaaaaaaaaaaaa\n" 6378 " << \"bbbbbbbbbbbbbbbbb = \" << bbbbbbbbbbbbbbbbb\n" 6379 " << \"ccccccccccccccccc = \" << ccccccccccccccccc\n" 6380 " << \"ddddddddddddddddd = \" << ddddddddddddddddd\n" 6381 " << \"eeeeeeeeeeeeeeeee = \" << eeeeeeeeeeeeeeeee;"); 6382 verifyFormat("llvm::outs() << aaaaaaaaaaaaaaaaaaaaaaaa << \"=\"\n" 6383 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 6384 verifyFormat( 6385 "void f() {\n" 6386 " llvm::outs() << \"aaaaaaaaaaaaaaaaaaaa: \"\n" 6387 " << aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 6388 "}"); 6389 6390 // Breaking before the first "<<" is generally not desirable. 6391 verifyFormat( 6392 "llvm::errs()\n" 6393 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6394 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6395 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6396 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 6397 getLLVMStyleWithColumns(70)); 6398 verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaa: \"\n" 6399 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6400 " << \"aaaaaaaaaaaaaaaaaaa: \"\n" 6401 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6402 " << \"aaaaaaaaaaaaaaaaaaa: \"\n" 6403 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 6404 getLLVMStyleWithColumns(70)); 6405 6406 verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n" 6407 " \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n" 6408 " \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa;"); 6409 verifyFormat("string v = StrCat(\"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n" 6410 " \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n" 6411 " \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa);"); 6412 verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" +\n" 6413 " (aaaa + aaaa);", 6414 getLLVMStyleWithColumns(40)); 6415 verifyFormat("string v = StrCat(\"aaaaaaaaaaaa: \" +\n" 6416 " (aaaaaaa + aaaaa));", 6417 getLLVMStyleWithColumns(40)); 6418 verifyFormat( 6419 "string v = StrCat(\"aaaaaaaaaaaaaaaaaaaaaaaaaaa: \",\n" 6420 " SomeFunction(aaaaaaaaaaaa, aaaaaaaa.aaaaaaa),\n" 6421 " bbbbbbbbbbbbbbbbbbbbbbb);"); 6422 } 6423 6424 TEST_F(FormatTest, UnderstandsEquals) { 6425 verifyFormat( 6426 "aaaaaaaaaaaaaaaaa =\n" 6427 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6428 verifyFormat( 6429 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 6430 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 6431 verifyFormat( 6432 "if (a) {\n" 6433 " f();\n" 6434 "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 6435 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 6436 "}"); 6437 6438 verifyFormat("if (int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 6439 " 100000000 + 10000000) {\n}"); 6440 } 6441 6442 TEST_F(FormatTest, WrapsAtFunctionCallsIfNecessary) { 6443 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n" 6444 " .looooooooooooooooooooooooooooooooooooooongFunction();"); 6445 6446 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n" 6447 " ->looooooooooooooooooooooooooooooooooooooongFunction();"); 6448 6449 verifyFormat( 6450 "LooooooooooooooooooooooooooooooooongObject->shortFunction(Parameter1,\n" 6451 " Parameter2);"); 6452 6453 verifyFormat( 6454 "ShortObject->shortFunction(\n" 6455 " LooooooooooooooooooooooooooooooooooooooooooooooongParameter1,\n" 6456 " LooooooooooooooooooooooooooooooooooooooooooooooongParameter2);"); 6457 6458 verifyFormat("loooooooooooooongFunction(\n" 6459 " LoooooooooooooongObject->looooooooooooooooongFunction());"); 6460 6461 verifyFormat( 6462 "function(LoooooooooooooooooooooooooooooooooooongObject\n" 6463 " ->loooooooooooooooooooooooooooooooooooooooongFunction());"); 6464 6465 verifyFormat("EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n" 6466 " .WillRepeatedly(Return(SomeValue));"); 6467 verifyFormat("void f() {\n" 6468 " EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n" 6469 " .Times(2)\n" 6470 " .WillRepeatedly(Return(SomeValue));\n" 6471 "}"); 6472 verifyFormat("SomeMap[std::pair(aaaaaaaaaaaa, bbbbbbbbbbbbbbb)].insert(\n" 6473 " ccccccccccccccccccccccc);"); 6474 verifyFormat("aaaaa(aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6475 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6476 " .aaaaa(aaaaa),\n" 6477 " aaaaaaaaaaaaaaaaaaaaa);"); 6478 verifyFormat("void f() {\n" 6479 " aaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6480 " aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa)->aaaaaaaaa());\n" 6481 "}"); 6482 verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6483 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6484 " .aaaaaaaaaaaaaaa(aa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6485 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6486 " aaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 6487 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6488 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6489 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6490 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()) {\n" 6491 "}"); 6492 6493 // Here, it is not necessary to wrap at "." or "->". 6494 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaa) ||\n" 6495 " aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 6496 verifyFormat( 6497 "aaaaaaaaaaa->aaaaaaaaa(\n" 6498 " aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6499 " aaaaaaaaaaaaaaaaaa->aaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa));\n"); 6500 6501 verifyFormat( 6502 "aaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6503 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa().aaaaaaaaaaaaaaaaa());"); 6504 verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() *\n" 6505 " aaaaaaaaa()->aaaaaa()->aaaaa());"); 6506 verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() ||\n" 6507 " aaaaaaaaa()->aaaaaa()->aaaaa());"); 6508 6509 verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6510 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6511 " .a();"); 6512 6513 FormatStyle NoBinPacking = getLLVMStyle(); 6514 NoBinPacking.BinPackParameters = false; 6515 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n" 6516 " .aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n" 6517 " .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa,\n" 6518 " aaaaaaaaaaaaaaaaaaa,\n" 6519 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 6520 NoBinPacking); 6521 6522 // If there is a subsequent call, change to hanging indentation. 6523 verifyFormat( 6524 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6525 " aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa))\n" 6526 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6527 verifyFormat( 6528 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6529 " aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa));"); 6530 verifyFormat("aaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6531 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6532 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6533 verifyFormat("aaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6534 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6535 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());"); 6536 } 6537 6538 TEST_F(FormatTest, WrapsTemplateDeclarations) { 6539 verifyFormat("template <typename T>\n" 6540 "virtual void loooooooooooongFunction(int Param1, int Param2);"); 6541 verifyFormat("template <typename T>\n" 6542 "// T should be one of {A, B}.\n" 6543 "virtual void loooooooooooongFunction(int Param1, int Param2);"); 6544 verifyFormat( 6545 "template <typename T>\n" 6546 "using comment_to_xml_conversion = comment_to_xml_conversion<T, int>;"); 6547 verifyFormat("template <typename T>\n" 6548 "void f(int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram1,\n" 6549 " int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram2);"); 6550 verifyFormat( 6551 "template <typename T>\n" 6552 "void looooooooooooooooooooongFunction(int Paaaaaaaaaaaaaaaaaaaaram1,\n" 6553 " int Paaaaaaaaaaaaaaaaaaaaram2);"); 6554 verifyFormat( 6555 "template <typename T>\n" 6556 "aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaa,\n" 6557 " aaaaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaa,\n" 6558 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6559 verifyFormat("template <typename T>\n" 6560 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6561 " int aaaaaaaaaaaaaaaaaaaaaa);"); 6562 verifyFormat( 6563 "template <typename T1, typename T2 = char, typename T3 = char,\n" 6564 " typename T4 = char>\n" 6565 "void f();"); 6566 verifyFormat("template <typename aaaaaaaaaaa, typename bbbbbbbbbbbbb,\n" 6567 " template <typename> class cccccccccccccccccccccc,\n" 6568 " typename ddddddddddddd>\n" 6569 "class C {};"); 6570 verifyFormat( 6571 "aaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>(\n" 6572 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6573 6574 verifyFormat("void f() {\n" 6575 " a<aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaa>(\n" 6576 " a(aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));\n" 6577 "}"); 6578 6579 verifyFormat("template <typename T> class C {};"); 6580 verifyFormat("template <typename T> void f();"); 6581 verifyFormat("template <typename T> void f() {}"); 6582 verifyFormat( 6583 "aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n" 6584 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6585 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> *aaaa =\n" 6586 " new aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n" 6587 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6588 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>(\n" 6589 " bbbbbbbbbbbbbbbbbbbbbbbb);", 6590 getLLVMStyleWithColumns(72)); 6591 EXPECT_EQ("static_cast<A< //\n" 6592 " B> *>(\n" 6593 "\n" 6594 ");", 6595 format("static_cast<A<//\n" 6596 " B>*>(\n" 6597 "\n" 6598 " );")); 6599 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6600 " const typename aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaa);"); 6601 6602 FormatStyle AlwaysBreak = getLLVMStyle(); 6603 AlwaysBreak.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes; 6604 verifyFormat("template <typename T>\nclass C {};", AlwaysBreak); 6605 verifyFormat("template <typename T>\nvoid f();", AlwaysBreak); 6606 verifyFormat("template <typename T>\nvoid f() {}", AlwaysBreak); 6607 verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6608 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n" 6609 " ccccccccccccccccccccccccccccccccccccccccccccccc);"); 6610 verifyFormat("template <template <typename> class Fooooooo,\n" 6611 " template <typename> class Baaaaaaar>\n" 6612 "struct C {};", 6613 AlwaysBreak); 6614 verifyFormat("template <typename T> // T can be A, B or C.\n" 6615 "struct C {};", 6616 AlwaysBreak); 6617 verifyFormat("template <enum E> class A {\n" 6618 "public:\n" 6619 " E *f();\n" 6620 "};"); 6621 6622 FormatStyle NeverBreak = getLLVMStyle(); 6623 NeverBreak.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_No; 6624 verifyFormat("template <typename T> class C {};", NeverBreak); 6625 verifyFormat("template <typename T> void f();", NeverBreak); 6626 verifyFormat("template <typename T> void f() {}", NeverBreak); 6627 verifyFormat("template <typename T>\nvoid foo(aaaaaaaaaaaaaaaaaaaaaaaaaa " 6628 "bbbbbbbbbbbbbbbbbbbb) {}", 6629 NeverBreak); 6630 verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6631 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n" 6632 " ccccccccccccccccccccccccccccccccccccccccccccccc);", 6633 NeverBreak); 6634 verifyFormat("template <template <typename> class Fooooooo,\n" 6635 " template <typename> class Baaaaaaar>\n" 6636 "struct C {};", 6637 NeverBreak); 6638 verifyFormat("template <typename T> // T can be A, B or C.\n" 6639 "struct C {};", 6640 NeverBreak); 6641 verifyFormat("template <enum E> class A {\n" 6642 "public:\n" 6643 " E *f();\n" 6644 "};", 6645 NeverBreak); 6646 NeverBreak.PenaltyBreakTemplateDeclaration = 100; 6647 verifyFormat("template <typename T> void\nfoo(aaaaaaaaaaaaaaaaaaaaaaaaaa " 6648 "bbbbbbbbbbbbbbbbbbbb) {}", 6649 NeverBreak); 6650 } 6651 6652 TEST_F(FormatTest, WrapsTemplateDeclarationsWithComments) { 6653 FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp); 6654 Style.ColumnLimit = 60; 6655 EXPECT_EQ("// Baseline - no comments.\n" 6656 "template <\n" 6657 " typename aaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbbb>::value>\n" 6658 "void f() {}", 6659 format("// Baseline - no comments.\n" 6660 "template <\n" 6661 " typename aaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbbb>::value>\n" 6662 "void f() {}", 6663 Style)); 6664 6665 EXPECT_EQ("template <\n" 6666 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 6667 "void f() {}", 6668 format("template <\n" 6669 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 6670 "void f() {}", 6671 Style)); 6672 6673 EXPECT_EQ( 6674 "template <\n" 6675 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> /* line */\n" 6676 "void f() {}", 6677 format("template <typename aaaaaaaaaa<bbbbbbbbbbbb>::value> /* line */\n" 6678 "void f() {}", 6679 Style)); 6680 6681 EXPECT_EQ( 6682 "template <\n" 6683 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 6684 " // multiline\n" 6685 "void f() {}", 6686 format("template <\n" 6687 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 6688 " // multiline\n" 6689 "void f() {}", 6690 Style)); 6691 6692 EXPECT_EQ( 6693 "template <typename aaaaaaaaaa<\n" 6694 " bbbbbbbbbbbb>::value> // trailing loooong\n" 6695 "void f() {}", 6696 format( 6697 "template <\n" 6698 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing loooong\n" 6699 "void f() {}", 6700 Style)); 6701 } 6702 6703 TEST_F(FormatTest, WrapsTemplateParameters) { 6704 FormatStyle Style = getLLVMStyle(); 6705 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 6706 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 6707 verifyFormat( 6708 "template <typename... a> struct q {};\n" 6709 "extern q<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n" 6710 " aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n" 6711 " y;", 6712 Style); 6713 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 6714 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 6715 verifyFormat( 6716 "template <typename... a> struct r {};\n" 6717 "extern r<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n" 6718 " aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n" 6719 " y;", 6720 Style); 6721 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 6722 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 6723 verifyFormat("template <typename... a> struct s {};\n" 6724 "extern s<\n" 6725 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, " 6726 "aaaaaaaaaaaaaaaaaaaaaa,\n" 6727 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, " 6728 "aaaaaaaaaaaaaaaaaaaaaa>\n" 6729 " y;", 6730 Style); 6731 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 6732 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 6733 verifyFormat("template <typename... a> struct t {};\n" 6734 "extern t<\n" 6735 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, " 6736 "aaaaaaaaaaaaaaaaaaaaaa,\n" 6737 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, " 6738 "aaaaaaaaaaaaaaaaaaaaaa>\n" 6739 " y;", 6740 Style); 6741 } 6742 6743 TEST_F(FormatTest, WrapsAtNestedNameSpecifiers) { 6744 verifyFormat( 6745 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6746 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6747 verifyFormat( 6748 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6749 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6750 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());"); 6751 6752 // FIXME: Should we have the extra indent after the second break? 6753 verifyFormat( 6754 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6755 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6756 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6757 6758 verifyFormat( 6759 "aaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb::\n" 6760 " cccccccccccccccccccccccccccccccccccccccccccccc());"); 6761 6762 // Breaking at nested name specifiers is generally not desirable. 6763 verifyFormat( 6764 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6765 " aaaaaaaaaaaaaaaaaaaaaaa);"); 6766 6767 verifyFormat("aaaaaaaaaaaaaaaaaa(aaaaaaaa,\n" 6768 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6769 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6770 " aaaaaaaaaaaaaaaaaaaaa);", 6771 getLLVMStyleWithColumns(74)); 6772 6773 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6774 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6775 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6776 } 6777 6778 TEST_F(FormatTest, UnderstandsTemplateParameters) { 6779 verifyFormat("A<int> a;"); 6780 verifyFormat("A<A<A<int>>> a;"); 6781 verifyFormat("A<A<A<int, 2>, 3>, 4> a;"); 6782 verifyFormat("bool x = a < 1 || 2 > a;"); 6783 verifyFormat("bool x = 5 < f<int>();"); 6784 verifyFormat("bool x = f<int>() > 5;"); 6785 verifyFormat("bool x = 5 < a<int>::x;"); 6786 verifyFormat("bool x = a < 4 ? a > 2 : false;"); 6787 verifyFormat("bool x = f() ? a < 2 : a > 2;"); 6788 6789 verifyGoogleFormat("A<A<int>> a;"); 6790 verifyGoogleFormat("A<A<A<int>>> a;"); 6791 verifyGoogleFormat("A<A<A<A<int>>>> a;"); 6792 verifyGoogleFormat("A<A<int> > a;"); 6793 verifyGoogleFormat("A<A<A<int> > > a;"); 6794 verifyGoogleFormat("A<A<A<A<int> > > > a;"); 6795 verifyGoogleFormat("A<::A<int>> a;"); 6796 verifyGoogleFormat("A<::A> a;"); 6797 verifyGoogleFormat("A< ::A> a;"); 6798 verifyGoogleFormat("A< ::A<int> > a;"); 6799 EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A> >> a;", getGoogleStyle())); 6800 EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A>> > a;", getGoogleStyle())); 6801 EXPECT_EQ("A<::A<int>> a;", format("A< ::A<int>> a;", getGoogleStyle())); 6802 EXPECT_EQ("A<::A<int>> a;", format("A<::A<int> > a;", getGoogleStyle())); 6803 EXPECT_EQ("auto x = [] { A<A<A<A>>> a; };", 6804 format("auto x=[]{A<A<A<A> >> a;};", getGoogleStyle())); 6805 6806 verifyFormat("A<A<int>> a;", getChromiumStyle(FormatStyle::LK_Cpp)); 6807 6808 // template closer followed by a token that starts with > or = 6809 verifyFormat("bool b = a<1> > 1;"); 6810 verifyFormat("bool b = a<1> >= 1;"); 6811 verifyFormat("int i = a<1> >> 1;"); 6812 FormatStyle Style = getLLVMStyle(); 6813 Style.SpaceBeforeAssignmentOperators = false; 6814 verifyFormat("bool b= a<1> == 1;", Style); 6815 verifyFormat("a<int> = 1;", Style); 6816 verifyFormat("a<int> >>= 1;", Style); 6817 6818 verifyFormat("test >> a >> b;"); 6819 verifyFormat("test << a >> b;"); 6820 6821 verifyFormat("f<int>();"); 6822 verifyFormat("template <typename T> void f() {}"); 6823 verifyFormat("struct A<std::enable_if<sizeof(T2) < sizeof(int32)>::type>;"); 6824 verifyFormat("struct A<std::enable_if<sizeof(T2) ? sizeof(int32) : " 6825 "sizeof(char)>::type>;"); 6826 verifyFormat("template <class T> struct S<std::is_arithmetic<T>{}> {};"); 6827 verifyFormat("f(a.operator()<A>());"); 6828 verifyFormat("f(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6829 " .template operator()<A>());", 6830 getLLVMStyleWithColumns(35)); 6831 6832 // Not template parameters. 6833 verifyFormat("return a < b && c > d;"); 6834 verifyFormat("void f() {\n" 6835 " while (a < b && c > d) {\n" 6836 " }\n" 6837 "}"); 6838 verifyFormat("template <typename... Types>\n" 6839 "typename enable_if<0 < sizeof...(Types)>::type Foo() {}"); 6840 6841 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6842 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa >> aaaaa);", 6843 getLLVMStyleWithColumns(60)); 6844 verifyFormat("static_assert(is_convertible<A &&, B>::value, \"AAA\");"); 6845 verifyFormat("Constructor(A... a) : a_(X<A>{std::forward<A>(a)}...) {}"); 6846 verifyFormat("< < < < < < < < < < < < < < < < < < < < < < < < < < < < < <"); 6847 } 6848 6849 TEST_F(FormatTest, BitshiftOperatorWidth) { 6850 EXPECT_EQ("int a = 1 << 2; /* foo\n" 6851 " bar */", 6852 format("int a=1<<2; /* foo\n" 6853 " bar */")); 6854 6855 EXPECT_EQ("int b = 256 >> 1; /* foo\n" 6856 " bar */", 6857 format("int b =256>>1 ; /* foo\n" 6858 " bar */")); 6859 } 6860 6861 TEST_F(FormatTest, UnderstandsBinaryOperators) { 6862 verifyFormat("COMPARE(a, ==, b);"); 6863 verifyFormat("auto s = sizeof...(Ts) - 1;"); 6864 } 6865 6866 TEST_F(FormatTest, UnderstandsPointersToMembers) { 6867 verifyFormat("int A::*x;"); 6868 verifyFormat("int (S::*func)(void *);"); 6869 verifyFormat("void f() { int (S::*func)(void *); }"); 6870 verifyFormat("typedef bool *(Class::*Member)() const;"); 6871 verifyFormat("void f() {\n" 6872 " (a->*f)();\n" 6873 " a->*x;\n" 6874 " (a.*f)();\n" 6875 " ((*a).*f)();\n" 6876 " a.*x;\n" 6877 "}"); 6878 verifyFormat("void f() {\n" 6879 " (a->*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n" 6880 " aaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);\n" 6881 "}"); 6882 verifyFormat( 6883 "(aaaaaaaaaa->*bbbbbbb)(\n" 6884 " aaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 6885 FormatStyle Style = getLLVMStyle(); 6886 Style.PointerAlignment = FormatStyle::PAS_Left; 6887 verifyFormat("typedef bool* (Class::*Member)() const;", Style); 6888 } 6889 6890 TEST_F(FormatTest, UnderstandsUnaryOperators) { 6891 verifyFormat("int a = -2;"); 6892 verifyFormat("f(-1, -2, -3);"); 6893 verifyFormat("a[-1] = 5;"); 6894 verifyFormat("int a = 5 + -2;"); 6895 verifyFormat("if (i == -1) {\n}"); 6896 verifyFormat("if (i != -1) {\n}"); 6897 verifyFormat("if (i > -1) {\n}"); 6898 verifyFormat("if (i < -1) {\n}"); 6899 verifyFormat("++(a->f());"); 6900 verifyFormat("--(a->f());"); 6901 verifyFormat("(a->f())++;"); 6902 verifyFormat("a[42]++;"); 6903 verifyFormat("if (!(a->f())) {\n}"); 6904 verifyFormat("if (!+i) {\n}"); 6905 verifyFormat("~&a;"); 6906 6907 verifyFormat("a-- > b;"); 6908 verifyFormat("b ? -a : c;"); 6909 verifyFormat("n * sizeof char16;"); 6910 verifyFormat("n * alignof char16;", getGoogleStyle()); 6911 verifyFormat("sizeof(char);"); 6912 verifyFormat("alignof(char);", getGoogleStyle()); 6913 6914 verifyFormat("return -1;"); 6915 verifyFormat("throw -1;"); 6916 verifyFormat("switch (a) {\n" 6917 "case -1:\n" 6918 " break;\n" 6919 "}"); 6920 verifyFormat("#define X -1"); 6921 verifyFormat("#define X -kConstant"); 6922 6923 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {-5, +3};"); 6924 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {+5, -3};"); 6925 6926 verifyFormat("int a = /* confusing comment */ -1;"); 6927 // FIXME: The space after 'i' is wrong, but hopefully, this is a rare case. 6928 verifyFormat("int a = i /* confusing comment */++;"); 6929 } 6930 6931 TEST_F(FormatTest, DoesNotIndentRelativeToUnaryOperators) { 6932 verifyFormat("if (!aaaaaaaaaa( // break\n" 6933 " aaaaa)) {\n" 6934 "}"); 6935 verifyFormat("aaaaaaaaaa(!aaaaaaaaaa( // break\n" 6936 " aaaaa));"); 6937 verifyFormat("*aaa = aaaaaaa( // break\n" 6938 " bbbbbb);"); 6939 } 6940 6941 TEST_F(FormatTest, UnderstandsOverloadedOperators) { 6942 verifyFormat("bool operator<();"); 6943 verifyFormat("bool operator>();"); 6944 verifyFormat("bool operator=();"); 6945 verifyFormat("bool operator==();"); 6946 verifyFormat("bool operator!=();"); 6947 verifyFormat("int operator+();"); 6948 verifyFormat("int operator++();"); 6949 verifyFormat("int operator++(int) volatile noexcept;"); 6950 verifyFormat("bool operator,();"); 6951 verifyFormat("bool operator();"); 6952 verifyFormat("bool operator()();"); 6953 verifyFormat("bool operator[]();"); 6954 verifyFormat("operator bool();"); 6955 verifyFormat("operator int();"); 6956 verifyFormat("operator void *();"); 6957 verifyFormat("operator SomeType<int>();"); 6958 verifyFormat("operator SomeType<int, int>();"); 6959 verifyFormat("operator SomeType<SomeType<int>>();"); 6960 verifyFormat("void *operator new(std::size_t size);"); 6961 verifyFormat("void *operator new[](std::size_t size);"); 6962 verifyFormat("void operator delete(void *ptr);"); 6963 verifyFormat("void operator delete[](void *ptr);"); 6964 verifyFormat("template <typename AAAAAAA, typename BBBBBBB>\n" 6965 "AAAAAAA operator/(const AAAAAAA &a, BBBBBBB &b);"); 6966 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa operator,(\n" 6967 " aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaaaaaaaaaaaaaaaaaaa) const;"); 6968 6969 verifyFormat( 6970 "ostream &operator<<(ostream &OutputStream,\n" 6971 " SomeReallyLongType WithSomeReallyLongValue);"); 6972 verifyFormat("bool operator<(const aaaaaaaaaaaaaaaaaaaaa &left,\n" 6973 " const aaaaaaaaaaaaaaaaaaaaa &right) {\n" 6974 " return left.group < right.group;\n" 6975 "}"); 6976 verifyFormat("SomeType &operator=(const SomeType &S);"); 6977 verifyFormat("f.template operator()<int>();"); 6978 6979 verifyGoogleFormat("operator void*();"); 6980 verifyGoogleFormat("operator SomeType<SomeType<int>>();"); 6981 verifyGoogleFormat("operator ::A();"); 6982 6983 verifyFormat("using A::operator+;"); 6984 verifyFormat("inline A operator^(const A &lhs, const A &rhs) {}\n" 6985 "int i;"); 6986 } 6987 6988 TEST_F(FormatTest, UnderstandsFunctionRefQualification) { 6989 verifyFormat("Deleted &operator=(const Deleted &) & = default;"); 6990 verifyFormat("Deleted &operator=(const Deleted &) && = delete;"); 6991 verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;"); 6992 verifyFormat("SomeType MemberFunction(const Deleted &) && = delete;"); 6993 verifyFormat("Deleted &operator=(const Deleted &) &;"); 6994 verifyFormat("Deleted &operator=(const Deleted &) &&;"); 6995 verifyFormat("SomeType MemberFunction(const Deleted &) &;"); 6996 verifyFormat("SomeType MemberFunction(const Deleted &) &&;"); 6997 verifyFormat("SomeType MemberFunction(const Deleted &) && {}"); 6998 verifyFormat("SomeType MemberFunction(const Deleted &) && final {}"); 6999 verifyFormat("SomeType MemberFunction(const Deleted &) && override {}"); 7000 verifyFormat("void Fn(T const &) const &;"); 7001 verifyFormat("void Fn(T const volatile &&) const volatile &&;"); 7002 verifyFormat("template <typename T>\n" 7003 "void F(T) && = delete;", 7004 getGoogleStyle()); 7005 7006 FormatStyle AlignLeft = getLLVMStyle(); 7007 AlignLeft.PointerAlignment = FormatStyle::PAS_Left; 7008 verifyFormat("void A::b() && {}", AlignLeft); 7009 verifyFormat("Deleted& operator=(const Deleted&) & = default;", AlignLeft); 7010 verifyFormat("SomeType MemberFunction(const Deleted&) & = delete;", 7011 AlignLeft); 7012 verifyFormat("Deleted& operator=(const Deleted&) &;", AlignLeft); 7013 verifyFormat("SomeType MemberFunction(const Deleted&) &;", AlignLeft); 7014 verifyFormat("auto Function(T t) & -> void {}", AlignLeft); 7015 verifyFormat("auto Function(T... t) & -> void {}", AlignLeft); 7016 verifyFormat("auto Function(T) & -> void {}", AlignLeft); 7017 verifyFormat("auto Function(T) & -> void;", AlignLeft); 7018 verifyFormat("void Fn(T const&) const&;", AlignLeft); 7019 verifyFormat("void Fn(T const volatile&&) const volatile&&;", AlignLeft); 7020 7021 FormatStyle Spaces = getLLVMStyle(); 7022 Spaces.SpacesInCStyleCastParentheses = true; 7023 verifyFormat("Deleted &operator=(const Deleted &) & = default;", Spaces); 7024 verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;", Spaces); 7025 verifyFormat("Deleted &operator=(const Deleted &) &;", Spaces); 7026 verifyFormat("SomeType MemberFunction(const Deleted &) &;", Spaces); 7027 7028 Spaces.SpacesInCStyleCastParentheses = false; 7029 Spaces.SpacesInParentheses = true; 7030 verifyFormat("Deleted &operator=( const Deleted & ) & = default;", Spaces); 7031 verifyFormat("SomeType MemberFunction( const Deleted & ) & = delete;", 7032 Spaces); 7033 verifyFormat("Deleted &operator=( const Deleted & ) &;", Spaces); 7034 verifyFormat("SomeType MemberFunction( const Deleted & ) &;", Spaces); 7035 7036 FormatStyle BreakTemplate = getLLVMStyle(); 7037 BreakTemplate.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes; 7038 7039 verifyFormat("struct f {\n" 7040 " template <class T>\n" 7041 " int &foo(const std::string &str) &noexcept {}\n" 7042 "};", 7043 BreakTemplate); 7044 7045 verifyFormat("struct f {\n" 7046 " template <class T>\n" 7047 " int &foo(const std::string &str) &&noexcept {}\n" 7048 "};", 7049 BreakTemplate); 7050 7051 verifyFormat("struct f {\n" 7052 " template <class T>\n" 7053 " int &foo(const std::string &str) const &noexcept {}\n" 7054 "};", 7055 BreakTemplate); 7056 7057 verifyFormat("struct f {\n" 7058 " template <class T>\n" 7059 " int &foo(const std::string &str) const &noexcept {}\n" 7060 "};", 7061 BreakTemplate); 7062 7063 verifyFormat("struct f {\n" 7064 " template <class T>\n" 7065 " auto foo(const std::string &str) &&noexcept -> int & {}\n" 7066 "};", 7067 BreakTemplate); 7068 7069 FormatStyle AlignLeftBreakTemplate = getLLVMStyle(); 7070 AlignLeftBreakTemplate.AlwaysBreakTemplateDeclarations = 7071 FormatStyle::BTDS_Yes; 7072 AlignLeftBreakTemplate.PointerAlignment = FormatStyle::PAS_Left; 7073 7074 verifyFormat("struct f {\n" 7075 " template <class T>\n" 7076 " int& foo(const std::string& str) & noexcept {}\n" 7077 "};", 7078 AlignLeftBreakTemplate); 7079 7080 verifyFormat("struct f {\n" 7081 " template <class T>\n" 7082 " int& foo(const std::string& str) && noexcept {}\n" 7083 "};", 7084 AlignLeftBreakTemplate); 7085 7086 verifyFormat("struct f {\n" 7087 " template <class T>\n" 7088 " int& foo(const std::string& str) const& noexcept {}\n" 7089 "};", 7090 AlignLeftBreakTemplate); 7091 7092 verifyFormat("struct f {\n" 7093 " template <class T>\n" 7094 " int& foo(const std::string& str) const&& noexcept {}\n" 7095 "};", 7096 AlignLeftBreakTemplate); 7097 7098 verifyFormat("struct f {\n" 7099 " template <class T>\n" 7100 " auto foo(const std::string& str) && noexcept -> int& {}\n" 7101 "};", 7102 AlignLeftBreakTemplate); 7103 7104 // The `&` in `Type&` should not be confused with a trailing `&` of 7105 // DEPRECATED(reason) member function. 7106 verifyFormat("struct f {\n" 7107 " template <class T>\n" 7108 " DEPRECATED(reason)\n" 7109 " Type &foo(arguments) {}\n" 7110 "};", 7111 BreakTemplate); 7112 7113 verifyFormat("struct f {\n" 7114 " template <class T>\n" 7115 " DEPRECATED(reason)\n" 7116 " Type& foo(arguments) {}\n" 7117 "};", 7118 AlignLeftBreakTemplate); 7119 7120 verifyFormat("void (*foopt)(int) = &func;"); 7121 } 7122 7123 TEST_F(FormatTest, UnderstandsNewAndDelete) { 7124 verifyFormat("void f() {\n" 7125 " A *a = new A;\n" 7126 " A *a = new (placement) A;\n" 7127 " delete a;\n" 7128 " delete (A *)a;\n" 7129 "}"); 7130 verifyFormat("new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n" 7131 " typename aaaaaaaaaaaaaaaaaaaaaaaa();"); 7132 verifyFormat("auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 7133 " new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n" 7134 " typename aaaaaaaaaaaaaaaaaaaaaaaa();"); 7135 verifyFormat("delete[] h->p;"); 7136 } 7137 7138 TEST_F(FormatTest, UnderstandsUsesOfStarAndAmp) { 7139 verifyFormat("int *f(int *a) {}"); 7140 verifyFormat("int main(int argc, char **argv) {}"); 7141 verifyFormat("Test::Test(int b) : a(b * b) {}"); 7142 verifyIndependentOfContext("f(a, *a);"); 7143 verifyFormat("void g() { f(*a); }"); 7144 verifyIndependentOfContext("int a = b * 10;"); 7145 verifyIndependentOfContext("int a = 10 * b;"); 7146 verifyIndependentOfContext("int a = b * c;"); 7147 verifyIndependentOfContext("int a += b * c;"); 7148 verifyIndependentOfContext("int a -= b * c;"); 7149 verifyIndependentOfContext("int a *= b * c;"); 7150 verifyIndependentOfContext("int a /= b * c;"); 7151 verifyIndependentOfContext("int a = *b;"); 7152 verifyIndependentOfContext("int a = *b * c;"); 7153 verifyIndependentOfContext("int a = b * *c;"); 7154 verifyIndependentOfContext("int a = b * (10);"); 7155 verifyIndependentOfContext("S << b * (10);"); 7156 verifyIndependentOfContext("return 10 * b;"); 7157 verifyIndependentOfContext("return *b * *c;"); 7158 verifyIndependentOfContext("return a & ~b;"); 7159 verifyIndependentOfContext("f(b ? *c : *d);"); 7160 verifyIndependentOfContext("int a = b ? *c : *d;"); 7161 verifyIndependentOfContext("*b = a;"); 7162 verifyIndependentOfContext("a * ~b;"); 7163 verifyIndependentOfContext("a * !b;"); 7164 verifyIndependentOfContext("a * +b;"); 7165 verifyIndependentOfContext("a * -b;"); 7166 verifyIndependentOfContext("a * ++b;"); 7167 verifyIndependentOfContext("a * --b;"); 7168 verifyIndependentOfContext("a[4] * b;"); 7169 verifyIndependentOfContext("a[a * a] = 1;"); 7170 verifyIndependentOfContext("f() * b;"); 7171 verifyIndependentOfContext("a * [self dostuff];"); 7172 verifyIndependentOfContext("int x = a * (a + b);"); 7173 verifyIndependentOfContext("(a *)(a + b);"); 7174 verifyIndependentOfContext("*(int *)(p & ~3UL) = 0;"); 7175 verifyIndependentOfContext("int *pa = (int *)&a;"); 7176 verifyIndependentOfContext("return sizeof(int **);"); 7177 verifyIndependentOfContext("return sizeof(int ******);"); 7178 verifyIndependentOfContext("return (int **&)a;"); 7179 verifyIndependentOfContext("f((*PointerToArray)[10]);"); 7180 verifyFormat("void f(Type (*parameter)[10]) {}"); 7181 verifyFormat("void f(Type (¶meter)[10]) {}"); 7182 verifyGoogleFormat("return sizeof(int**);"); 7183 verifyIndependentOfContext("Type **A = static_cast<Type **>(P);"); 7184 verifyGoogleFormat("Type** A = static_cast<Type**>(P);"); 7185 verifyFormat("auto a = [](int **&, int ***) {};"); 7186 verifyFormat("auto PointerBinding = [](const char *S) {};"); 7187 verifyFormat("typedef typeof(int(int, int)) *MyFunc;"); 7188 verifyFormat("[](const decltype(*a) &value) {}"); 7189 verifyFormat("decltype(a * b) F();"); 7190 verifyFormat("#define MACRO() [](A *a) { return 1; }"); 7191 verifyFormat("Constructor() : member([](A *a, B *b) {}) {}"); 7192 verifyIndependentOfContext("typedef void (*f)(int *a);"); 7193 verifyIndependentOfContext("int i{a * b};"); 7194 verifyIndependentOfContext("aaa && aaa->f();"); 7195 verifyIndependentOfContext("int x = ~*p;"); 7196 verifyFormat("Constructor() : a(a), area(width * height) {}"); 7197 verifyFormat("Constructor() : a(a), area(a, width * height) {}"); 7198 verifyGoogleFormat("MACRO Constructor(const int& i) : a(a), b(b) {}"); 7199 verifyFormat("void f() { f(a, c * d); }"); 7200 verifyFormat("void f() { f(new a(), c * d); }"); 7201 verifyFormat("void f(const MyOverride &override);"); 7202 verifyFormat("void f(const MyFinal &final);"); 7203 verifyIndependentOfContext("bool a = f() && override.f();"); 7204 verifyIndependentOfContext("bool a = f() && final.f();"); 7205 7206 verifyIndependentOfContext("InvalidRegions[*R] = 0;"); 7207 7208 verifyIndependentOfContext("A<int *> a;"); 7209 verifyIndependentOfContext("A<int **> a;"); 7210 verifyIndependentOfContext("A<int *, int *> a;"); 7211 verifyIndependentOfContext("A<int *[]> a;"); 7212 verifyIndependentOfContext( 7213 "const char *const p = reinterpret_cast<const char *const>(q);"); 7214 verifyIndependentOfContext("A<int **, int **> a;"); 7215 verifyIndependentOfContext("void f(int *a = d * e, int *b = c * d);"); 7216 verifyFormat("for (char **a = b; *a; ++a) {\n}"); 7217 verifyFormat("for (; a && b;) {\n}"); 7218 verifyFormat("bool foo = true && [] { return false; }();"); 7219 7220 verifyFormat( 7221 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7222 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa, *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 7223 7224 verifyGoogleFormat("int const* a = &b;"); 7225 verifyGoogleFormat("**outparam = 1;"); 7226 verifyGoogleFormat("*outparam = a * b;"); 7227 verifyGoogleFormat("int main(int argc, char** argv) {}"); 7228 verifyGoogleFormat("A<int*> a;"); 7229 verifyGoogleFormat("A<int**> a;"); 7230 verifyGoogleFormat("A<int*, int*> a;"); 7231 verifyGoogleFormat("A<int**, int**> a;"); 7232 verifyGoogleFormat("f(b ? *c : *d);"); 7233 verifyGoogleFormat("int a = b ? *c : *d;"); 7234 verifyGoogleFormat("Type* t = **x;"); 7235 verifyGoogleFormat("Type* t = *++*x;"); 7236 verifyGoogleFormat("*++*x;"); 7237 verifyGoogleFormat("Type* t = const_cast<T*>(&*x);"); 7238 verifyGoogleFormat("Type* t = x++ * y;"); 7239 verifyGoogleFormat( 7240 "const char* const p = reinterpret_cast<const char* const>(q);"); 7241 verifyGoogleFormat("void f(int i = 0, SomeType** temps = NULL);"); 7242 verifyGoogleFormat("void f(Bar* a = nullptr, Bar* b);"); 7243 verifyGoogleFormat("template <typename T>\n" 7244 "void f(int i = 0, SomeType** temps = NULL);"); 7245 7246 FormatStyle Left = getLLVMStyle(); 7247 Left.PointerAlignment = FormatStyle::PAS_Left; 7248 verifyFormat("x = *a(x) = *a(y);", Left); 7249 verifyFormat("for (;; *a = b) {\n}", Left); 7250 verifyFormat("return *this += 1;", Left); 7251 verifyFormat("throw *x;", Left); 7252 verifyFormat("delete *x;", Left); 7253 verifyFormat("typedef typeof(int(int, int))* MyFuncPtr;", Left); 7254 verifyFormat("[](const decltype(*a)* ptr) {}", Left); 7255 verifyFormat("typedef typeof /*comment*/ (int(int, int))* MyFuncPtr;", Left); 7256 7257 verifyIndependentOfContext("a = *(x + y);"); 7258 verifyIndependentOfContext("a = &(x + y);"); 7259 verifyIndependentOfContext("*(x + y).call();"); 7260 verifyIndependentOfContext("&(x + y)->call();"); 7261 verifyFormat("void f() { &(*I).first; }"); 7262 7263 verifyIndependentOfContext("f(b * /* confusing comment */ ++c);"); 7264 verifyFormat( 7265 "int *MyValues = {\n" 7266 " *A, // Operator detection might be confused by the '{'\n" 7267 " *BB // Operator detection might be confused by previous comment\n" 7268 "};"); 7269 7270 verifyIndependentOfContext("if (int *a = &b)"); 7271 verifyIndependentOfContext("if (int &a = *b)"); 7272 verifyIndependentOfContext("if (a & b[i])"); 7273 verifyIndependentOfContext("if constexpr (a & b[i])"); 7274 verifyIndependentOfContext("if CONSTEXPR (a & b[i])"); 7275 verifyIndependentOfContext("if (a * (b * c))"); 7276 verifyIndependentOfContext("if constexpr (a * (b * c))"); 7277 verifyIndependentOfContext("if CONSTEXPR (a * (b * c))"); 7278 verifyIndependentOfContext("if (a::b::c::d & b[i])"); 7279 verifyIndependentOfContext("if (*b[i])"); 7280 verifyIndependentOfContext("if (int *a = (&b))"); 7281 verifyIndependentOfContext("while (int *a = &b)"); 7282 verifyIndependentOfContext("while (a * (b * c))"); 7283 verifyIndependentOfContext("size = sizeof *a;"); 7284 verifyIndependentOfContext("if (a && (b = c))"); 7285 verifyFormat("void f() {\n" 7286 " for (const int &v : Values) {\n" 7287 " }\n" 7288 "}"); 7289 verifyFormat("for (int i = a * a; i < 10; ++i) {\n}"); 7290 verifyFormat("for (int i = 0; i < a * a; ++i) {\n}"); 7291 verifyGoogleFormat("for (int i = 0; i * 2 < z; i *= 2) {\n}"); 7292 7293 verifyFormat("#define A (!a * b)"); 7294 verifyFormat("#define MACRO \\\n" 7295 " int *i = a * b; \\\n" 7296 " void f(a *b);", 7297 getLLVMStyleWithColumns(19)); 7298 7299 verifyIndependentOfContext("A = new SomeType *[Length];"); 7300 verifyIndependentOfContext("A = new SomeType *[Length]();"); 7301 verifyIndependentOfContext("T **t = new T *;"); 7302 verifyIndependentOfContext("T **t = new T *();"); 7303 verifyGoogleFormat("A = new SomeType*[Length]();"); 7304 verifyGoogleFormat("A = new SomeType*[Length];"); 7305 verifyGoogleFormat("T** t = new T*;"); 7306 verifyGoogleFormat("T** t = new T*();"); 7307 7308 verifyFormat("STATIC_ASSERT((a & b) == 0);"); 7309 verifyFormat("STATIC_ASSERT(0 == (a & b));"); 7310 verifyFormat("template <bool a, bool b> " 7311 "typename t::if<x && y>::type f() {}"); 7312 verifyFormat("template <int *y> f() {}"); 7313 verifyFormat("vector<int *> v;"); 7314 verifyFormat("vector<int *const> v;"); 7315 verifyFormat("vector<int *const **const *> v;"); 7316 verifyFormat("vector<int *volatile> v;"); 7317 verifyFormat("vector<a * b> v;"); 7318 verifyFormat("foo<b && false>();"); 7319 verifyFormat("foo<b & 1>();"); 7320 verifyFormat("decltype(*::std::declval<const T &>()) void F();"); 7321 verifyFormat( 7322 "template <class T, class = typename std::enable_if<\n" 7323 " std::is_integral<T>::value &&\n" 7324 " (sizeof(T) > 1 || sizeof(T) < 8)>::type>\n" 7325 "void F();", 7326 getLLVMStyleWithColumns(70)); 7327 verifyFormat("template <class T,\n" 7328 " class = typename std::enable_if<\n" 7329 " std::is_integral<T>::value &&\n" 7330 " (sizeof(T) > 1 || sizeof(T) < 8)>::type,\n" 7331 " class U>\n" 7332 "void F();", 7333 getLLVMStyleWithColumns(70)); 7334 verifyFormat( 7335 "template <class T,\n" 7336 " class = typename ::std::enable_if<\n" 7337 " ::std::is_array<T>{} && ::std::is_array<T>{}>::type>\n" 7338 "void F();", 7339 getGoogleStyleWithColumns(68)); 7340 7341 verifyIndependentOfContext("MACRO(int *i);"); 7342 verifyIndependentOfContext("MACRO(auto *a);"); 7343 verifyIndependentOfContext("MACRO(const A *a);"); 7344 verifyIndependentOfContext("MACRO(A *const a);"); 7345 verifyIndependentOfContext("MACRO('0' <= c && c <= '9');"); 7346 verifyFormat("void f() { f(float{1}, a * a); }"); 7347 // FIXME: Is there a way to make this work? 7348 // verifyIndependentOfContext("MACRO(A *a);"); 7349 7350 verifyFormat("DatumHandle const *operator->() const { return input_; }"); 7351 verifyFormat("return options != nullptr && operator==(*options);"); 7352 7353 EXPECT_EQ("#define OP(x) \\\n" 7354 " ostream &operator<<(ostream &s, const A &a) { \\\n" 7355 " return s << a.DebugString(); \\\n" 7356 " }", 7357 format("#define OP(x) \\\n" 7358 " ostream &operator<<(ostream &s, const A &a) { \\\n" 7359 " return s << a.DebugString(); \\\n" 7360 " }", 7361 getLLVMStyleWithColumns(50))); 7362 7363 // FIXME: We cannot handle this case yet; we might be able to figure out that 7364 // foo<x> d > v; doesn't make sense. 7365 verifyFormat("foo<a<b && c> d> v;"); 7366 7367 FormatStyle PointerMiddle = getLLVMStyle(); 7368 PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle; 7369 verifyFormat("delete *x;", PointerMiddle); 7370 verifyFormat("int * x;", PointerMiddle); 7371 verifyFormat("int *[] x;", PointerMiddle); 7372 verifyFormat("template <int * y> f() {}", PointerMiddle); 7373 verifyFormat("int * f(int * a) {}", PointerMiddle); 7374 verifyFormat("int main(int argc, char ** argv) {}", PointerMiddle); 7375 verifyFormat("Test::Test(int b) : a(b * b) {}", PointerMiddle); 7376 verifyFormat("A<int *> a;", PointerMiddle); 7377 verifyFormat("A<int **> a;", PointerMiddle); 7378 verifyFormat("A<int *, int *> a;", PointerMiddle); 7379 verifyFormat("A<int *[]> a;", PointerMiddle); 7380 verifyFormat("A = new SomeType *[Length]();", PointerMiddle); 7381 verifyFormat("A = new SomeType *[Length];", PointerMiddle); 7382 verifyFormat("T ** t = new T *;", PointerMiddle); 7383 7384 // Member function reference qualifiers aren't binary operators. 7385 verifyFormat("string // break\n" 7386 "operator()() & {}"); 7387 verifyFormat("string // break\n" 7388 "operator()() && {}"); 7389 verifyGoogleFormat("template <typename T>\n" 7390 "auto x() & -> int {}"); 7391 } 7392 7393 TEST_F(FormatTest, UnderstandsAttributes) { 7394 verifyFormat("SomeType s __attribute__((unused)) (InitValue);"); 7395 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa __attribute__((unused))\n" 7396 "aaaaaaaaaaaaaaaaaaaaaaa(int i);"); 7397 FormatStyle AfterType = getLLVMStyle(); 7398 AfterType.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions; 7399 verifyFormat("__attribute__((nodebug)) void\n" 7400 "foo() {}\n", 7401 AfterType); 7402 } 7403 7404 TEST_F(FormatTest, UnderstandsSquareAttributes) { 7405 verifyFormat("SomeType s [[unused]] (InitValue);"); 7406 verifyFormat("SomeType s [[gnu::unused]] (InitValue);"); 7407 verifyFormat("SomeType s [[using gnu: unused]] (InitValue);"); 7408 verifyFormat("[[gsl::suppress(\"clang-tidy-check-name\")]] void f() {}"); 7409 verifyFormat("void f() [[deprecated(\"so sorry\")]];"); 7410 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7411 " [[unused]] aaaaaaaaaaaaaaaaaaaaaaa(int i);"); 7412 7413 // Make sure we do not mistake attributes for array subscripts. 7414 verifyFormat("int a() {}\n" 7415 "[[unused]] int b() {}\n"); 7416 verifyFormat("NSArray *arr;\n" 7417 "arr[[Foo() bar]];"); 7418 7419 // On the other hand, we still need to correctly find array subscripts. 7420 verifyFormat("int a = std::vector<int>{1, 2, 3}[0];"); 7421 7422 // Make sure that we do not mistake Objective-C method inside array literals 7423 // as attributes, even if those method names are also keywords. 7424 verifyFormat("@[ [foo bar] ];"); 7425 verifyFormat("@[ [NSArray class] ];"); 7426 verifyFormat("@[ [foo enum] ];"); 7427 7428 // Make sure we do not parse attributes as lambda introducers. 7429 FormatStyle MultiLineFunctions = getLLVMStyle(); 7430 MultiLineFunctions.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 7431 verifyFormat("[[unused]] int b() {\n" 7432 " return 42;\n" 7433 "}\n", 7434 MultiLineFunctions); 7435 } 7436 7437 TEST_F(FormatTest, UnderstandsEllipsis) { 7438 verifyFormat("int printf(const char *fmt, ...);"); 7439 verifyFormat("template <class... Ts> void Foo(Ts... ts) { Foo(ts...); }"); 7440 verifyFormat("template <class... Ts> void Foo(Ts *... ts) {}"); 7441 7442 FormatStyle PointersLeft = getLLVMStyle(); 7443 PointersLeft.PointerAlignment = FormatStyle::PAS_Left; 7444 verifyFormat("template <class... Ts> void Foo(Ts*... ts) {}", PointersLeft); 7445 } 7446 7447 TEST_F(FormatTest, AdaptivelyFormatsPointersAndReferences) { 7448 EXPECT_EQ("int *a;\n" 7449 "int *a;\n" 7450 "int *a;", 7451 format("int *a;\n" 7452 "int* a;\n" 7453 "int *a;", 7454 getGoogleStyle())); 7455 EXPECT_EQ("int* a;\n" 7456 "int* a;\n" 7457 "int* a;", 7458 format("int* a;\n" 7459 "int* a;\n" 7460 "int *a;", 7461 getGoogleStyle())); 7462 EXPECT_EQ("int *a;\n" 7463 "int *a;\n" 7464 "int *a;", 7465 format("int *a;\n" 7466 "int * a;\n" 7467 "int * a;", 7468 getGoogleStyle())); 7469 EXPECT_EQ("auto x = [] {\n" 7470 " int *a;\n" 7471 " int *a;\n" 7472 " int *a;\n" 7473 "};", 7474 format("auto x=[]{int *a;\n" 7475 "int * a;\n" 7476 "int * a;};", 7477 getGoogleStyle())); 7478 } 7479 7480 TEST_F(FormatTest, UnderstandsRvalueReferences) { 7481 verifyFormat("int f(int &&a) {}"); 7482 verifyFormat("int f(int a, char &&b) {}"); 7483 verifyFormat("void f() { int &&a = b; }"); 7484 verifyGoogleFormat("int f(int a, char&& b) {}"); 7485 verifyGoogleFormat("void f() { int&& a = b; }"); 7486 7487 verifyIndependentOfContext("A<int &&> a;"); 7488 verifyIndependentOfContext("A<int &&, int &&> a;"); 7489 verifyGoogleFormat("A<int&&> a;"); 7490 verifyGoogleFormat("A<int&&, int&&> a;"); 7491 7492 // Not rvalue references: 7493 verifyFormat("template <bool B, bool C> class A {\n" 7494 " static_assert(B && C, \"Something is wrong\");\n" 7495 "};"); 7496 verifyGoogleFormat("#define IF(a, b, c) if (a && (b == c))"); 7497 verifyGoogleFormat("#define WHILE(a, b, c) while (a && (b == c))"); 7498 verifyFormat("#define A(a, b) (a && b)"); 7499 } 7500 7501 TEST_F(FormatTest, FormatsBinaryOperatorsPrecedingEquals) { 7502 verifyFormat("void f() {\n" 7503 " x[aaaaaaaaa -\n" 7504 " b] = 23;\n" 7505 "}", 7506 getLLVMStyleWithColumns(15)); 7507 } 7508 7509 TEST_F(FormatTest, FormatsCasts) { 7510 verifyFormat("Type *A = static_cast<Type *>(P);"); 7511 verifyFormat("Type *A = (Type *)P;"); 7512 verifyFormat("Type *A = (vector<Type *, int *>)P;"); 7513 verifyFormat("int a = (int)(2.0f);"); 7514 verifyFormat("int a = (int)2.0f;"); 7515 verifyFormat("x[(int32)y];"); 7516 verifyFormat("x = (int32)y;"); 7517 verifyFormat("#define AA(X) sizeof(((X *)NULL)->a)"); 7518 verifyFormat("int a = (int)*b;"); 7519 verifyFormat("int a = (int)2.0f;"); 7520 verifyFormat("int a = (int)~0;"); 7521 verifyFormat("int a = (int)++a;"); 7522 verifyFormat("int a = (int)sizeof(int);"); 7523 verifyFormat("int a = (int)+2;"); 7524 verifyFormat("my_int a = (my_int)2.0f;"); 7525 verifyFormat("my_int a = (my_int)sizeof(int);"); 7526 verifyFormat("return (my_int)aaa;"); 7527 verifyFormat("#define x ((int)-1)"); 7528 verifyFormat("#define LENGTH(x, y) (x) - (y) + 1"); 7529 verifyFormat("#define p(q) ((int *)&q)"); 7530 verifyFormat("fn(a)(b) + 1;"); 7531 7532 verifyFormat("void f() { my_int a = (my_int)*b; }"); 7533 verifyFormat("void f() { return P ? (my_int)*P : (my_int)0; }"); 7534 verifyFormat("my_int a = (my_int)~0;"); 7535 verifyFormat("my_int a = (my_int)++a;"); 7536 verifyFormat("my_int a = (my_int)-2;"); 7537 verifyFormat("my_int a = (my_int)1;"); 7538 verifyFormat("my_int a = (my_int *)1;"); 7539 verifyFormat("my_int a = (const my_int)-1;"); 7540 verifyFormat("my_int a = (const my_int *)-1;"); 7541 verifyFormat("my_int a = (my_int)(my_int)-1;"); 7542 verifyFormat("my_int a = (ns::my_int)-2;"); 7543 verifyFormat("case (my_int)ONE:"); 7544 verifyFormat("auto x = (X)this;"); 7545 // Casts in Obj-C style calls used to not be recognized as such. 7546 verifyFormat("int a = [(type*)[((type*)val) arg] arg];", getGoogleStyle()); 7547 7548 // FIXME: single value wrapped with paren will be treated as cast. 7549 verifyFormat("void f(int i = (kValue)*kMask) {}"); 7550 7551 verifyFormat("{ (void)F; }"); 7552 7553 // Don't break after a cast's 7554 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 7555 " (aaaaaaaaaaaaaaaaaaaaaaaaaa *)(aaaaaaaaaaaaaaaaaaaaaa +\n" 7556 " bbbbbbbbbbbbbbbbbbbbbb);"); 7557 7558 // These are not casts. 7559 verifyFormat("void f(int *) {}"); 7560 verifyFormat("f(foo)->b;"); 7561 verifyFormat("f(foo).b;"); 7562 verifyFormat("f(foo)(b);"); 7563 verifyFormat("f(foo)[b];"); 7564 verifyFormat("[](foo) { return 4; }(bar);"); 7565 verifyFormat("(*funptr)(foo)[4];"); 7566 verifyFormat("funptrs[4](foo)[4];"); 7567 verifyFormat("void f(int *);"); 7568 verifyFormat("void f(int *) = 0;"); 7569 verifyFormat("void f(SmallVector<int>) {}"); 7570 verifyFormat("void f(SmallVector<int>);"); 7571 verifyFormat("void f(SmallVector<int>) = 0;"); 7572 verifyFormat("void f(int i = (kA * kB) & kMask) {}"); 7573 verifyFormat("int a = sizeof(int) * b;"); 7574 verifyFormat("int a = alignof(int) * b;", getGoogleStyle()); 7575 verifyFormat("template <> void f<int>(int i) SOME_ANNOTATION;"); 7576 verifyFormat("f(\"%\" SOME_MACRO(ll) \"d\");"); 7577 verifyFormat("aaaaa &operator=(const aaaaa &) LLVM_DELETED_FUNCTION;"); 7578 7579 // These are not casts, but at some point were confused with casts. 7580 verifyFormat("virtual void foo(int *) override;"); 7581 verifyFormat("virtual void foo(char &) const;"); 7582 verifyFormat("virtual void foo(int *a, char *) const;"); 7583 verifyFormat("int a = sizeof(int *) + b;"); 7584 verifyFormat("int a = alignof(int *) + b;", getGoogleStyle()); 7585 verifyFormat("bool b = f(g<int>) && c;"); 7586 verifyFormat("typedef void (*f)(int i) func;"); 7587 verifyFormat("void operator++(int) noexcept;"); 7588 verifyFormat("void operator++(int &) noexcept;"); 7589 verifyFormat("void operator delete(void *, std::size_t, const std::nothrow_t " 7590 "&) noexcept;"); 7591 verifyFormat( 7592 "void operator delete(std::size_t, const std::nothrow_t &) noexcept;"); 7593 verifyFormat("void operator delete(const std::nothrow_t &) noexcept;"); 7594 verifyFormat("void operator delete(std::nothrow_t &) noexcept;"); 7595 verifyFormat("void operator delete(nothrow_t &) noexcept;"); 7596 verifyFormat("void operator delete(foo &) noexcept;"); 7597 verifyFormat("void operator delete(foo) noexcept;"); 7598 verifyFormat("void operator delete(int) noexcept;"); 7599 verifyFormat("void operator delete(int &) noexcept;"); 7600 verifyFormat("void operator delete(int &) volatile noexcept;"); 7601 verifyFormat("void operator delete(int &) const"); 7602 verifyFormat("void operator delete(int &) = default"); 7603 verifyFormat("void operator delete(int &) = delete"); 7604 verifyFormat("void operator delete(int &) [[noreturn]]"); 7605 verifyFormat("void operator delete(int &) throw();"); 7606 verifyFormat("void operator delete(int &) throw(int);"); 7607 verifyFormat("auto operator delete(int &) -> int;"); 7608 verifyFormat("auto operator delete(int &) override"); 7609 verifyFormat("auto operator delete(int &) final"); 7610 7611 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *foo = (aaaaaaaaaaaaaaaaa *)\n" 7612 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 7613 // FIXME: The indentation here is not ideal. 7614 verifyFormat( 7615 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7616 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = (*cccccccccccccccc)\n" 7617 " [dddddddddddddddddddddddddddddddddddddddddddddddddddddddd];"); 7618 } 7619 7620 TEST_F(FormatTest, FormatsFunctionTypes) { 7621 verifyFormat("A<bool()> a;"); 7622 verifyFormat("A<SomeType()> a;"); 7623 verifyFormat("A<void (*)(int, std::string)> a;"); 7624 verifyFormat("A<void *(int)>;"); 7625 verifyFormat("void *(*a)(int *, SomeType *);"); 7626 verifyFormat("int (*func)(void *);"); 7627 verifyFormat("void f() { int (*func)(void *); }"); 7628 verifyFormat("template <class CallbackClass>\n" 7629 "using MyCallback = void (CallbackClass::*)(SomeObject *Data);"); 7630 7631 verifyGoogleFormat("A<void*(int*, SomeType*)>;"); 7632 verifyGoogleFormat("void* (*a)(int);"); 7633 verifyGoogleFormat( 7634 "template <class CallbackClass>\n" 7635 "using MyCallback = void (CallbackClass::*)(SomeObject* Data);"); 7636 7637 // Other constructs can look somewhat like function types: 7638 verifyFormat("A<sizeof(*x)> a;"); 7639 verifyFormat("#define DEREF_AND_CALL_F(x) f(*x)"); 7640 verifyFormat("some_var = function(*some_pointer_var)[0];"); 7641 verifyFormat("void f() { function(*some_pointer_var)[0] = 10; }"); 7642 verifyFormat("int x = f(&h)();"); 7643 verifyFormat("returnsFunction(¶m1, ¶m2)(param);"); 7644 verifyFormat("std::function<\n" 7645 " LooooooooooongTemplatedType<\n" 7646 " SomeType>*(\n" 7647 " LooooooooooooooooongType type)>\n" 7648 " function;", 7649 getGoogleStyleWithColumns(40)); 7650 } 7651 7652 TEST_F(FormatTest, FormatsPointersToArrayTypes) { 7653 verifyFormat("A (*foo_)[6];"); 7654 verifyFormat("vector<int> (*foo_)[6];"); 7655 } 7656 7657 TEST_F(FormatTest, BreaksLongVariableDeclarations) { 7658 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7659 " LoooooooooooooooooooooooooooooooooooooooongVariable;"); 7660 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType const\n" 7661 " LoooooooooooooooooooooooooooooooooooooooongVariable;"); 7662 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7663 " *LoooooooooooooooooooooooooooooooooooooooongVariable;"); 7664 7665 // Different ways of ()-initializiation. 7666 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7667 " LoooooooooooooooooooooooooooooooooooooooongVariable(1);"); 7668 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7669 " LoooooooooooooooooooooooooooooooooooooooongVariable(a);"); 7670 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7671 " LoooooooooooooooooooooooooooooooooooooooongVariable({});"); 7672 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7673 " LoooooooooooooooooooooooooooooooooooooongVariable([A a]);"); 7674 7675 // Lambdas should not confuse the variable declaration heuristic. 7676 verifyFormat("LooooooooooooooooongType\n" 7677 " variable(nullptr, [](A *a) {});", 7678 getLLVMStyleWithColumns(40)); 7679 } 7680 7681 TEST_F(FormatTest, BreaksLongDeclarations) { 7682 verifyFormat("typedef LoooooooooooooooooooooooooooooooooooooooongType\n" 7683 " AnotherNameForTheLongType;"); 7684 verifyFormat("typedef LongTemplateType<aaaaaaaaaaaaaaaaaaa()>\n" 7685 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 7686 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7687 "LoooooooooooooooooooooooooooooooongFunctionDeclaration();"); 7688 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType *\n" 7689 "LoooooooooooooooooooooooooooooooongFunctionDeclaration();"); 7690 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7691 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7692 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType MACRO\n" 7693 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7694 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType const\n" 7695 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7696 verifyFormat("decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n" 7697 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7698 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7699 "LooooooooooooooooooooooooooongFunctionDeclaration(T... t);"); 7700 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7701 "LooooooooooooooooooooooooooongFunctionDeclaration(T /*t*/) {}"); 7702 FormatStyle Indented = getLLVMStyle(); 7703 Indented.IndentWrappedFunctionNames = true; 7704 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7705 " LoooooooooooooooooooooooooooooooongFunctionDeclaration();", 7706 Indented); 7707 verifyFormat( 7708 "LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7709 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}", 7710 Indented); 7711 verifyFormat( 7712 "LoooooooooooooooooooooooooooooooooooooooongReturnType const\n" 7713 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}", 7714 Indented); 7715 verifyFormat( 7716 "decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n" 7717 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}", 7718 Indented); 7719 7720 // FIXME: Without the comment, this breaks after "(". 7721 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType // break\n" 7722 " (*LoooooooooooooooooooooooooooongFunctionTypeVarialbe)();", 7723 getGoogleStyle()); 7724 7725 verifyFormat("int *someFunction(int LoooooooooooooooooooongParam1,\n" 7726 " int LoooooooooooooooooooongParam2) {}"); 7727 verifyFormat( 7728 "TypeSpecDecl *TypeSpecDecl::Create(ASTContext &C, DeclContext *DC,\n" 7729 " SourceLocation L, IdentifierIn *II,\n" 7730 " Type *T) {}"); 7731 verifyFormat("ReallyLongReturnType<TemplateParam1, TemplateParam2>\n" 7732 "ReallyReaaallyLongFunctionName(\n" 7733 " const std::string &SomeParameter,\n" 7734 " const SomeType<string, SomeOtherTemplateParameter>\n" 7735 " &ReallyReallyLongParameterName,\n" 7736 " const SomeType<string, SomeOtherTemplateParameter>\n" 7737 " &AnotherLongParameterName) {}"); 7738 verifyFormat("template <typename A>\n" 7739 "SomeLoooooooooooooooooooooongType<\n" 7740 " typename some_namespace::SomeOtherType<A>::Type>\n" 7741 "Function() {}"); 7742 7743 verifyGoogleFormat( 7744 "aaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaa<aaaaaaaaaaaaa, aaaaaaaaaaaa>\n" 7745 " aaaaaaaaaaaaaaaaaaaaaaa;"); 7746 verifyGoogleFormat( 7747 "TypeSpecDecl* TypeSpecDecl::Create(ASTContext& C, DeclContext* DC,\n" 7748 " SourceLocation L) {}"); 7749 verifyGoogleFormat( 7750 "some_namespace::LongReturnType\n" 7751 "long_namespace::SomeVeryLongClass::SomeVeryLongFunction(\n" 7752 " int first_long_parameter, int second_parameter) {}"); 7753 7754 verifyGoogleFormat("template <typename T>\n" 7755 "aaaaaaaa::aaaaa::aaaaaa<T, aaaaaaaaaaaaaaaaaaaaaaaaa>\n" 7756 "aaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaa() {}"); 7757 verifyGoogleFormat("A<A<A>> aaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 7758 " int aaaaaaaaaaaaaaaaaaaaaaa);"); 7759 7760 verifyFormat("typedef size_t (*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n" 7761 " const aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7762 " *aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 7763 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7764 " vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n" 7765 " aaaaaaaaaaaaaaaaaaaaaaaa);"); 7766 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7767 " vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n" 7768 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>>\n" 7769 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 7770 7771 verifyFormat("template <typename T> // Templates on own line.\n" 7772 "static int // Some comment.\n" 7773 "MyFunction(int a);", 7774 getLLVMStyle()); 7775 } 7776 7777 TEST_F(FormatTest, FormatsArrays) { 7778 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaaaaaaaaaa]\n" 7779 " [bbbbbbbbbbbbbbbbbbbbbbbbb] = c;"); 7780 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaa(aaaaaaaaaaaa)]\n" 7781 " [bbbbbbbbbbb(bbbbbbbbbbbb)] = c;"); 7782 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaa &&\n" 7783 " aaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaa][aaaaaaaaaaaaa]) {\n}"); 7784 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7785 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;"); 7786 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7787 " [a][bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = cccccccc;"); 7788 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7789 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n" 7790 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;"); 7791 verifyFormat( 7792 "llvm::outs() << \"aaaaaaaaaaaa: \"\n" 7793 " << (*aaaaaaaiaaaaaaa)[aaaaaaaaaaaaaaaaaaaaaaaaa]\n" 7794 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa];"); 7795 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaa][a]\n" 7796 " .aaaaaaaaaaaaaaaaaaaaaa();"); 7797 7798 verifyGoogleFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<int>\n" 7799 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaa];"); 7800 verifyFormat( 7801 "aaaaaaaaaaa aaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaa->aaaaaaaaa[0]\n" 7802 " .aaaaaaa[0]\n" 7803 " .aaaaaaaaaaaaaaaaaaaaaa();"); 7804 verifyFormat("a[::b::c];"); 7805 7806 verifyNoCrash("a[,Y?)]", getLLVMStyleWithColumns(10)); 7807 7808 FormatStyle NoColumnLimit = getLLVMStyleWithColumns(0); 7809 verifyFormat("aaaaa[bbbbbb].cccccc()", NoColumnLimit); 7810 } 7811 7812 TEST_F(FormatTest, LineStartsWithSpecialCharacter) { 7813 verifyFormat("(a)->b();"); 7814 verifyFormat("--a;"); 7815 } 7816 7817 TEST_F(FormatTest, HandlesIncludeDirectives) { 7818 verifyFormat("#include <string>\n" 7819 "#include <a/b/c.h>\n" 7820 "#include \"a/b/string\"\n" 7821 "#include \"string.h\"\n" 7822 "#include \"string.h\"\n" 7823 "#include <a-a>\n" 7824 "#include < path with space >\n" 7825 "#include_next <test.h>" 7826 "#include \"abc.h\" // this is included for ABC\n" 7827 "#include \"some long include\" // with a comment\n" 7828 "#include \"some very long include path\"\n" 7829 "#include <some/very/long/include/path>\n", 7830 getLLVMStyleWithColumns(35)); 7831 EXPECT_EQ("#include \"a.h\"", format("#include \"a.h\"")); 7832 EXPECT_EQ("#include <a>", format("#include<a>")); 7833 7834 verifyFormat("#import <string>"); 7835 verifyFormat("#import <a/b/c.h>"); 7836 verifyFormat("#import \"a/b/string\""); 7837 verifyFormat("#import \"string.h\""); 7838 verifyFormat("#import \"string.h\""); 7839 verifyFormat("#if __has_include(<strstream>)\n" 7840 "#include <strstream>\n" 7841 "#endif"); 7842 7843 verifyFormat("#define MY_IMPORT <a/b>"); 7844 7845 verifyFormat("#if __has_include(<a/b>)"); 7846 verifyFormat("#if __has_include_next(<a/b>)"); 7847 verifyFormat("#define F __has_include(<a/b>)"); 7848 verifyFormat("#define F __has_include_next(<a/b>)"); 7849 7850 // Protocol buffer definition or missing "#". 7851 verifyFormat("import \"aaaaaaaaaaaaaaaaa/aaaaaaaaaaaaaaa\";", 7852 getLLVMStyleWithColumns(30)); 7853 7854 FormatStyle Style = getLLVMStyle(); 7855 Style.AlwaysBreakBeforeMultilineStrings = true; 7856 Style.ColumnLimit = 0; 7857 verifyFormat("#import \"abc.h\"", Style); 7858 7859 // But 'import' might also be a regular C++ namespace. 7860 verifyFormat("import::SomeFunction(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 7861 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 7862 } 7863 7864 //===----------------------------------------------------------------------===// 7865 // Error recovery tests. 7866 //===----------------------------------------------------------------------===// 7867 7868 TEST_F(FormatTest, IncompleteParameterLists) { 7869 FormatStyle NoBinPacking = getLLVMStyle(); 7870 NoBinPacking.BinPackParameters = false; 7871 verifyFormat("void aaaaaaaaaaaaaaaaaa(int level,\n" 7872 " double *min_x,\n" 7873 " double *max_x,\n" 7874 " double *min_y,\n" 7875 " double *max_y,\n" 7876 " double *min_z,\n" 7877 " double *max_z, ) {}", 7878 NoBinPacking); 7879 } 7880 7881 TEST_F(FormatTest, IncorrectCodeTrailingStuff) { 7882 verifyFormat("void f() { return; }\n42"); 7883 verifyFormat("void f() {\n" 7884 " if (0)\n" 7885 " return;\n" 7886 "}\n" 7887 "42"); 7888 verifyFormat("void f() { return }\n42"); 7889 verifyFormat("void f() {\n" 7890 " if (0)\n" 7891 " return\n" 7892 "}\n" 7893 "42"); 7894 } 7895 7896 TEST_F(FormatTest, IncorrectCodeMissingSemicolon) { 7897 EXPECT_EQ("void f() { return }", format("void f ( ) { return }")); 7898 EXPECT_EQ("void f() {\n" 7899 " if (a)\n" 7900 " return\n" 7901 "}", 7902 format("void f ( ) { if ( a ) return }")); 7903 EXPECT_EQ("namespace N {\n" 7904 "void f()\n" 7905 "}", 7906 format("namespace N { void f() }")); 7907 EXPECT_EQ("namespace N {\n" 7908 "void f() {}\n" 7909 "void g()\n" 7910 "} // namespace N", 7911 format("namespace N { void f( ) { } void g( ) }")); 7912 } 7913 7914 TEST_F(FormatTest, IndentationWithinColumnLimitNotPossible) { 7915 verifyFormat("int aaaaaaaa =\n" 7916 " // Overlylongcomment\n" 7917 " b;", 7918 getLLVMStyleWithColumns(20)); 7919 verifyFormat("function(\n" 7920 " ShortArgument,\n" 7921 " LoooooooooooongArgument);\n", 7922 getLLVMStyleWithColumns(20)); 7923 } 7924 7925 TEST_F(FormatTest, IncorrectAccessSpecifier) { 7926 verifyFormat("public:"); 7927 verifyFormat("class A {\n" 7928 "public\n" 7929 " void f() {}\n" 7930 "};"); 7931 verifyFormat("public\n" 7932 "int qwerty;"); 7933 verifyFormat("public\n" 7934 "B {}"); 7935 verifyFormat("public\n" 7936 "{}"); 7937 verifyFormat("public\n" 7938 "B { int x; }"); 7939 } 7940 7941 TEST_F(FormatTest, IncorrectCodeUnbalancedBraces) { 7942 verifyFormat("{"); 7943 verifyFormat("#})"); 7944 verifyNoCrash("(/**/[:!] ?[)."); 7945 } 7946 7947 TEST_F(FormatTest, IncorrectUnbalancedBracesInMacrosWithUnicode) { 7948 // Found by oss-fuzz: 7949 // https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=8212 7950 FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp); 7951 Style.ColumnLimit = 60; 7952 verifyNoCrash( 7953 "\x23\x47\xff\x20\x28\xff\x3c\xff\x3f\xff\x20\x2f\x7b\x7a\xff\x20" 7954 "\xff\xff\xff\xca\xb5\xff\xff\xff\xff\x3a\x7b\x7d\xff\x20\xff\x20" 7955 "\xff\x74\xff\x20\x7d\x7d\xff\x7b\x3a\xff\x20\x71\xff\x20\xff\x0a", 7956 Style); 7957 } 7958 7959 TEST_F(FormatTest, IncorrectCodeDoNoWhile) { 7960 verifyFormat("do {\n}"); 7961 verifyFormat("do {\n}\n" 7962 "f();"); 7963 verifyFormat("do {\n}\n" 7964 "wheeee(fun);"); 7965 verifyFormat("do {\n" 7966 " f();\n" 7967 "}"); 7968 } 7969 7970 TEST_F(FormatTest, IncorrectCodeMissingParens) { 7971 verifyFormat("if {\n foo;\n foo();\n}"); 7972 verifyFormat("switch {\n foo;\n foo();\n}"); 7973 verifyIncompleteFormat("for {\n foo;\n foo();\n}"); 7974 verifyFormat("while {\n foo;\n foo();\n}"); 7975 verifyFormat("do {\n foo;\n foo();\n} while;"); 7976 } 7977 7978 TEST_F(FormatTest, DoesNotTouchUnwrappedLinesWithErrors) { 7979 verifyIncompleteFormat("namespace {\n" 7980 "class Foo { Foo (\n" 7981 "};\n" 7982 "} // namespace"); 7983 } 7984 7985 TEST_F(FormatTest, IncorrectCodeErrorDetection) { 7986 EXPECT_EQ("{\n {}\n", format("{\n{\n}\n")); 7987 EXPECT_EQ("{\n {}\n", format("{\n {\n}\n")); 7988 EXPECT_EQ("{\n {}\n", format("{\n {\n }\n")); 7989 EXPECT_EQ("{\n {}\n}\n}\n", format("{\n {\n }\n }\n}\n")); 7990 7991 EXPECT_EQ("{\n" 7992 " {\n" 7993 " breakme(\n" 7994 " qwe);\n" 7995 " }\n", 7996 format("{\n" 7997 " {\n" 7998 " breakme(qwe);\n" 7999 "}\n", 8000 getLLVMStyleWithColumns(10))); 8001 } 8002 8003 TEST_F(FormatTest, LayoutCallsInsideBraceInitializers) { 8004 verifyFormat("int x = {\n" 8005 " avariable,\n" 8006 " b(alongervariable)};", 8007 getLLVMStyleWithColumns(25)); 8008 } 8009 8010 TEST_F(FormatTest, LayoutBraceInitializersInReturnStatement) { 8011 verifyFormat("return (a)(b){1, 2, 3};"); 8012 } 8013 8014 TEST_F(FormatTest, LayoutCxx11BraceInitializers) { 8015 verifyFormat("vector<int> x{1, 2, 3, 4};"); 8016 verifyFormat("vector<int> x{\n" 8017 " 1,\n" 8018 " 2,\n" 8019 " 3,\n" 8020 " 4,\n" 8021 "};"); 8022 verifyFormat("vector<T> x{{}, {}, {}, {}};"); 8023 verifyFormat("f({1, 2});"); 8024 verifyFormat("auto v = Foo{-1};"); 8025 verifyFormat("f({1, 2}, {{2, 3}, {4, 5}}, c, {d});"); 8026 verifyFormat("Class::Class : member{1, 2, 3} {}"); 8027 verifyFormat("new vector<int>{1, 2, 3};"); 8028 verifyFormat("new int[3]{1, 2, 3};"); 8029 verifyFormat("new int{1};"); 8030 verifyFormat("return {arg1, arg2};"); 8031 verifyFormat("return {arg1, SomeType{parameter}};"); 8032 verifyFormat("int count = set<int>{f(), g(), h()}.size();"); 8033 verifyFormat("new T{arg1, arg2};"); 8034 verifyFormat("f(MyMap[{composite, key}]);"); 8035 verifyFormat("class Class {\n" 8036 " T member = {arg1, arg2};\n" 8037 "};"); 8038 verifyFormat("vector<int> foo = {::SomeGlobalFunction()};"); 8039 verifyFormat("const struct A a = {.a = 1, .b = 2};"); 8040 verifyFormat("const struct A a = {[0] = 1, [1] = 2};"); 8041 verifyFormat("static_assert(std::is_integral<int>{} + 0, \"\");"); 8042 verifyFormat("int a = std::is_integral<int>{} + 0;"); 8043 8044 verifyFormat("int foo(int i) { return fo1{}(i); }"); 8045 verifyFormat("int foo(int i) { return fo1{}(i); }"); 8046 verifyFormat("auto i = decltype(x){};"); 8047 verifyFormat("std::vector<int> v = {1, 0 /* comment */};"); 8048 verifyFormat("Node n{1, Node{1000}, //\n" 8049 " 2};"); 8050 verifyFormat("Aaaa aaaaaaa{\n" 8051 " {\n" 8052 " aaaa,\n" 8053 " },\n" 8054 "};"); 8055 verifyFormat("class C : public D {\n" 8056 " SomeClass SC{2};\n" 8057 "};"); 8058 verifyFormat("class C : public A {\n" 8059 " class D : public B {\n" 8060 " void f() { int i{2}; }\n" 8061 " };\n" 8062 "};"); 8063 verifyFormat("#define A {a, a},"); 8064 8065 // Avoid breaking between equal sign and opening brace 8066 FormatStyle AvoidBreakingFirstArgument = getLLVMStyle(); 8067 AvoidBreakingFirstArgument.PenaltyBreakBeforeFirstCallParameter = 200; 8068 verifyFormat("const std::unordered_map<std::string, int> MyHashTable =\n" 8069 " {{\"aaaaaaaaaaaaaaaaaaaaa\", 0},\n" 8070 " {\"bbbbbbbbbbbbbbbbbbbbb\", 1},\n" 8071 " {\"ccccccccccccccccccccc\", 2}};", 8072 AvoidBreakingFirstArgument); 8073 8074 // Binpacking only if there is no trailing comma 8075 verifyFormat("const Aaaaaa aaaaa = {aaaaaaaaaa, bbbbbbbbbb,\n" 8076 " cccccccccc, dddddddddd};", 8077 getLLVMStyleWithColumns(50)); 8078 verifyFormat("const Aaaaaa aaaaa = {\n" 8079 " aaaaaaaaaaa,\n" 8080 " bbbbbbbbbbb,\n" 8081 " ccccccccccc,\n" 8082 " ddddddddddd,\n" 8083 "};", 8084 getLLVMStyleWithColumns(50)); 8085 8086 // Cases where distinguising braced lists and blocks is hard. 8087 verifyFormat("vector<int> v{12} GUARDED_BY(mutex);"); 8088 verifyFormat("void f() {\n" 8089 " return; // comment\n" 8090 "}\n" 8091 "SomeType t;"); 8092 verifyFormat("void f() {\n" 8093 " if (a) {\n" 8094 " f();\n" 8095 " }\n" 8096 "}\n" 8097 "SomeType t;"); 8098 8099 // In combination with BinPackArguments = false. 8100 FormatStyle NoBinPacking = getLLVMStyle(); 8101 NoBinPacking.BinPackArguments = false; 8102 verifyFormat("const Aaaaaa aaaaa = {aaaaa,\n" 8103 " bbbbb,\n" 8104 " ccccc,\n" 8105 " ddddd,\n" 8106 " eeeee,\n" 8107 " ffffff,\n" 8108 " ggggg,\n" 8109 " hhhhhh,\n" 8110 " iiiiii,\n" 8111 " jjjjjj,\n" 8112 " kkkkkk};", 8113 NoBinPacking); 8114 verifyFormat("const Aaaaaa aaaaa = {\n" 8115 " aaaaa,\n" 8116 " bbbbb,\n" 8117 " ccccc,\n" 8118 " ddddd,\n" 8119 " eeeee,\n" 8120 " ffffff,\n" 8121 " ggggg,\n" 8122 " hhhhhh,\n" 8123 " iiiiii,\n" 8124 " jjjjjj,\n" 8125 " kkkkkk,\n" 8126 "};", 8127 NoBinPacking); 8128 verifyFormat( 8129 "const Aaaaaa aaaaa = {\n" 8130 " aaaaa, bbbbb, ccccc, ddddd, eeeee, ffffff, ggggg, hhhhhh,\n" 8131 " iiiiii, jjjjjj, kkkkkk, aaaaa, bbbbb, ccccc, ddddd, eeeee,\n" 8132 " ffffff, ggggg, hhhhhh, iiiiii, jjjjjj, kkkkkk,\n" 8133 "};", 8134 NoBinPacking); 8135 8136 NoBinPacking.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 8137 EXPECT_EQ("static uint8 CddDp83848Reg[] = {\n" 8138 " CDDDP83848_BMCR_REGISTER,\n" 8139 " CDDDP83848_BMSR_REGISTER,\n" 8140 " CDDDP83848_RBR_REGISTER};", 8141 format("static uint8 CddDp83848Reg[] = {CDDDP83848_BMCR_REGISTER,\n" 8142 " CDDDP83848_BMSR_REGISTER,\n" 8143 " CDDDP83848_RBR_REGISTER};", 8144 NoBinPacking)); 8145 8146 // FIXME: The alignment of these trailing comments might be bad. Then again, 8147 // this might be utterly useless in real code. 8148 verifyFormat("Constructor::Constructor()\n" 8149 " : some_value{ //\n" 8150 " aaaaaaa, //\n" 8151 " bbbbbbb} {}"); 8152 8153 // In braced lists, the first comment is always assumed to belong to the 8154 // first element. Thus, it can be moved to the next or previous line as 8155 // appropriate. 8156 EXPECT_EQ("function({// First element:\n" 8157 " 1,\n" 8158 " // Second element:\n" 8159 " 2});", 8160 format("function({\n" 8161 " // First element:\n" 8162 " 1,\n" 8163 " // Second element:\n" 8164 " 2});")); 8165 EXPECT_EQ("std::vector<int> MyNumbers{\n" 8166 " // First element:\n" 8167 " 1,\n" 8168 " // Second element:\n" 8169 " 2};", 8170 format("std::vector<int> MyNumbers{// First element:\n" 8171 " 1,\n" 8172 " // Second element:\n" 8173 " 2};", 8174 getLLVMStyleWithColumns(30))); 8175 // A trailing comma should still lead to an enforced line break and no 8176 // binpacking. 8177 EXPECT_EQ("vector<int> SomeVector = {\n" 8178 " // aaa\n" 8179 " 1,\n" 8180 " 2,\n" 8181 "};", 8182 format("vector<int> SomeVector = { // aaa\n" 8183 " 1, 2, };")); 8184 8185 FormatStyle ExtraSpaces = getLLVMStyle(); 8186 ExtraSpaces.Cpp11BracedListStyle = false; 8187 ExtraSpaces.ColumnLimit = 75; 8188 verifyFormat("vector<int> x{ 1, 2, 3, 4 };", ExtraSpaces); 8189 verifyFormat("vector<T> x{ {}, {}, {}, {} };", ExtraSpaces); 8190 verifyFormat("f({ 1, 2 });", ExtraSpaces); 8191 verifyFormat("auto v = Foo{ 1 };", ExtraSpaces); 8192 verifyFormat("f({ 1, 2 }, { { 2, 3 }, { 4, 5 } }, c, { d });", ExtraSpaces); 8193 verifyFormat("Class::Class : member{ 1, 2, 3 } {}", ExtraSpaces); 8194 verifyFormat("new vector<int>{ 1, 2, 3 };", ExtraSpaces); 8195 verifyFormat("new int[3]{ 1, 2, 3 };", ExtraSpaces); 8196 verifyFormat("return { arg1, arg2 };", ExtraSpaces); 8197 verifyFormat("return { arg1, SomeType{ parameter } };", ExtraSpaces); 8198 verifyFormat("int count = set<int>{ f(), g(), h() }.size();", ExtraSpaces); 8199 verifyFormat("new T{ arg1, arg2 };", ExtraSpaces); 8200 verifyFormat("f(MyMap[{ composite, key }]);", ExtraSpaces); 8201 verifyFormat("class Class {\n" 8202 " T member = { arg1, arg2 };\n" 8203 "};", 8204 ExtraSpaces); 8205 verifyFormat( 8206 "foo = aaaaaaaaaaa ? vector<int>{ aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 8207 " aaaaaaaaaaaaaaaaaaaa, aaaaa }\n" 8208 " : vector<int>{ bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" 8209 " bbbbbbbbbbbbbbbbbbbb, bbbbb };", 8210 ExtraSpaces); 8211 verifyFormat("DoSomethingWithVector({} /* No data */);", ExtraSpaces); 8212 verifyFormat("DoSomethingWithVector({ {} /* No data */ }, { { 1, 2 } });", 8213 ExtraSpaces); 8214 verifyFormat( 8215 "someFunction(OtherParam,\n" 8216 " BracedList{ // comment 1 (Forcing interesting break)\n" 8217 " param1, param2,\n" 8218 " // comment 2\n" 8219 " param3, param4 });", 8220 ExtraSpaces); 8221 verifyFormat( 8222 "std::this_thread::sleep_for(\n" 8223 " std::chrono::nanoseconds{ std::chrono::seconds{ 1 } } / 5);", 8224 ExtraSpaces); 8225 verifyFormat("std::vector<MyValues> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa{\n" 8226 " aaaaaaa,\n" 8227 " aaaaaaaaaa,\n" 8228 " aaaaa,\n" 8229 " aaaaaaaaaaaaaaa,\n" 8230 " aaa,\n" 8231 " aaaaaaaaaa,\n" 8232 " a,\n" 8233 " aaaaaaaaaaaaaaaaaaaaa,\n" 8234 " aaaaaaaaaaaa,\n" 8235 " aaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaa,\n" 8236 " aaaaaaa,\n" 8237 " a};"); 8238 verifyFormat("vector<int> foo = { ::SomeGlobalFunction() };", ExtraSpaces); 8239 verifyFormat("const struct A a = { .a = 1, .b = 2 };", ExtraSpaces); 8240 verifyFormat("const struct A a = { [0] = 1, [1] = 2 };", ExtraSpaces); 8241 8242 // Avoid breaking between initializer/equal sign and opening brace 8243 ExtraSpaces.PenaltyBreakBeforeFirstCallParameter = 200; 8244 verifyFormat("const std::unordered_map<std::string, int> MyHashTable = {\n" 8245 " { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n" 8246 " { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n" 8247 " { \"ccccccccccccccccccccc\", 2 }\n" 8248 "};", 8249 ExtraSpaces); 8250 verifyFormat("const std::unordered_map<std::string, int> MyHashTable{\n" 8251 " { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n" 8252 " { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n" 8253 " { \"ccccccccccccccccccccc\", 2 }\n" 8254 "};", 8255 ExtraSpaces); 8256 8257 FormatStyle SpaceBeforeBrace = getLLVMStyle(); 8258 SpaceBeforeBrace.SpaceBeforeCpp11BracedList = true; 8259 verifyFormat("vector<int> x {1, 2, 3, 4};", SpaceBeforeBrace); 8260 verifyFormat("f({}, {{}, {}}, MyMap[{k, v}]);", SpaceBeforeBrace); 8261 8262 FormatStyle SpaceBetweenBraces = getLLVMStyle(); 8263 SpaceBetweenBraces.SpacesInAngles = true; 8264 SpaceBetweenBraces.SpacesInParentheses = true; 8265 SpaceBetweenBraces.SpacesInSquareBrackets = true; 8266 verifyFormat("vector< int > x{ 1, 2, 3, 4 };", SpaceBetweenBraces); 8267 verifyFormat("f( {}, { {}, {} }, MyMap[ { k, v } ] );", SpaceBetweenBraces); 8268 verifyFormat("vector< int > x{ // comment 1\n" 8269 " 1, 2, 3, 4 };", 8270 SpaceBetweenBraces); 8271 SpaceBetweenBraces.ColumnLimit = 20; 8272 EXPECT_EQ("vector< int > x{\n" 8273 " 1, 2, 3, 4 };", 8274 format("vector<int>x{1,2,3,4};", SpaceBetweenBraces)); 8275 SpaceBetweenBraces.ColumnLimit = 24; 8276 EXPECT_EQ("vector< int > x{ 1, 2,\n" 8277 " 3, 4 };", 8278 format("vector<int>x{1,2,3,4};", SpaceBetweenBraces)); 8279 EXPECT_EQ("vector< int > x{\n" 8280 " 1,\n" 8281 " 2,\n" 8282 " 3,\n" 8283 " 4,\n" 8284 "};", 8285 format("vector<int>x{1,2,3,4,};", SpaceBetweenBraces)); 8286 verifyFormat("vector< int > x{};", SpaceBetweenBraces); 8287 SpaceBetweenBraces.SpaceInEmptyParentheses = true; 8288 verifyFormat("vector< int > x{ };", SpaceBetweenBraces); 8289 } 8290 8291 TEST_F(FormatTest, FormatsBracedListsInColumnLayout) { 8292 verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8293 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8294 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8295 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8296 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8297 " 1, 22, 333, 4444, 55555, 666666, 7777777};"); 8298 verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777, //\n" 8299 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8300 " 1, 22, 333, 4444, 55555, //\n" 8301 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8302 " 1, 22, 333, 4444, 55555, 666666, 7777777};"); 8303 verifyFormat( 8304 "vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8305 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8306 " 1, 22, 333, 4444, 55555, 666666, // comment\n" 8307 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 8308 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 8309 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 8310 " 7777777};"); 8311 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n" 8312 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n" 8313 " X86::R8, X86::R9, X86::R10, X86::R11, 0};"); 8314 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n" 8315 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n" 8316 " // Separating comment.\n" 8317 " X86::R8, X86::R9, X86::R10, X86::R11, 0};"); 8318 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n" 8319 " // Leading comment\n" 8320 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n" 8321 " X86::R8, X86::R9, X86::R10, X86::R11, 0};"); 8322 verifyFormat("vector<int> x = {1, 1, 1, 1,\n" 8323 " 1, 1, 1, 1};", 8324 getLLVMStyleWithColumns(39)); 8325 verifyFormat("vector<int> x = {1, 1, 1, 1,\n" 8326 " 1, 1, 1, 1};", 8327 getLLVMStyleWithColumns(38)); 8328 verifyFormat("vector<int> aaaaaaaaaaaaaaaaaaaaaa = {\n" 8329 " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};", 8330 getLLVMStyleWithColumns(43)); 8331 verifyFormat( 8332 "static unsigned SomeValues[10][3] = {\n" 8333 " {1, 4, 0}, {4, 9, 0}, {4, 5, 9}, {8, 5, 4}, {1, 8, 4},\n" 8334 " {10, 1, 6}, {11, 0, 9}, {2, 11, 9}, {5, 2, 9}, {11, 2, 7}};"); 8335 verifyFormat("static auto fields = new vector<string>{\n" 8336 " \"aaaaaaaaaaaaa\",\n" 8337 " \"aaaaaaaaaaaaa\",\n" 8338 " \"aaaaaaaaaaaa\",\n" 8339 " \"aaaaaaaaaaaaaa\",\n" 8340 " \"aaaaaaaaaaaaaaaaaaaaaaaaa\",\n" 8341 " \"aaaaaaaaaaaa\",\n" 8342 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",\n" 8343 "};"); 8344 verifyFormat("vector<int> x = {1, 2, 3, 4, aaaaaaaaaaaaaaaaa, 6};"); 8345 verifyFormat("vector<int> x = {1, aaaaaaaaaaaaaaaaaaaaaa,\n" 8346 " 2, bbbbbbbbbbbbbbbbbbbbbb,\n" 8347 " 3, cccccccccccccccccccccc};", 8348 getLLVMStyleWithColumns(60)); 8349 8350 // Trailing commas. 8351 verifyFormat("vector<int> x = {\n" 8352 " 1, 1, 1, 1, 1, 1, 1, 1,\n" 8353 "};", 8354 getLLVMStyleWithColumns(39)); 8355 verifyFormat("vector<int> x = {\n" 8356 " 1, 1, 1, 1, 1, 1, 1, 1, //\n" 8357 "};", 8358 getLLVMStyleWithColumns(39)); 8359 verifyFormat("vector<int> x = {1, 1, 1, 1,\n" 8360 " 1, 1, 1, 1,\n" 8361 " /**/ /**/};", 8362 getLLVMStyleWithColumns(39)); 8363 8364 // Trailing comment in the first line. 8365 verifyFormat("vector<int> iiiiiiiiiiiiiii = { //\n" 8366 " 1111111111, 2222222222, 33333333333, 4444444444, //\n" 8367 " 111111111, 222222222, 3333333333, 444444444, //\n" 8368 " 11111111, 22222222, 333333333, 44444444};"); 8369 // Trailing comment in the last line. 8370 verifyFormat("int aaaaa[] = {\n" 8371 " 1, 2, 3, // comment\n" 8372 " 4, 5, 6 // comment\n" 8373 "};"); 8374 8375 // With nested lists, we should either format one item per line or all nested 8376 // lists one on line. 8377 // FIXME: For some nested lists, we can do better. 8378 verifyFormat("return {{aaaaaaaaaaaaaaaaaaaaa},\n" 8379 " {aaaaaaaaaaaaaaaaaaa},\n" 8380 " {aaaaaaaaaaaaaaaaaaaaa},\n" 8381 " {aaaaaaaaaaaaaaaaa}};", 8382 getLLVMStyleWithColumns(60)); 8383 verifyFormat( 8384 "SomeStruct my_struct_array = {\n" 8385 " {aaaaaa, aaaaaaaa, aaaaaaaaaa, aaaaaaaaa, aaaaaaaaa, aaaaaaaaaa,\n" 8386 " aaaaaaaaaaaaa, aaaaaaa, aaa},\n" 8387 " {aaa, aaa},\n" 8388 " {aaa, aaa},\n" 8389 " {aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaa},\n" 8390 " {aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaa,\n" 8391 " aaaaaaaaaaaa, a, aaaaaaaaaa, aaaaaaaaa, aaa}};"); 8392 8393 // No column layout should be used here. 8394 verifyFormat("aaaaaaaaaaaaaaa = {aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0, 0,\n" 8395 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb};"); 8396 8397 verifyNoCrash("a<,"); 8398 8399 // No braced initializer here. 8400 verifyFormat("void f() {\n" 8401 " struct Dummy {};\n" 8402 " f(v);\n" 8403 "}"); 8404 8405 // Long lists should be formatted in columns even if they are nested. 8406 verifyFormat( 8407 "vector<int> x = function({1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8408 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8409 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8410 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8411 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8412 " 1, 22, 333, 4444, 55555, 666666, 7777777});"); 8413 8414 // Allow "single-column" layout even if that violates the column limit. There 8415 // isn't going to be a better way. 8416 verifyFormat("std::vector<int> a = {\n" 8417 " aaaaaaaa,\n" 8418 " aaaaaaaa,\n" 8419 " aaaaaaaa,\n" 8420 " aaaaaaaa,\n" 8421 " aaaaaaaaaa,\n" 8422 " aaaaaaaa,\n" 8423 " aaaaaaaaaaaaaaaaaaaaaaaaaaa};", 8424 getLLVMStyleWithColumns(30)); 8425 verifyFormat("vector<int> aaaa = {\n" 8426 " aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 8427 " aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 8428 " aaaaaa.aaaaaaa,\n" 8429 " aaaaaa.aaaaaaa,\n" 8430 " aaaaaa.aaaaaaa,\n" 8431 " aaaaaa.aaaaaaa,\n" 8432 "};"); 8433 8434 // Don't create hanging lists. 8435 verifyFormat("someFunction(Param, {List1, List2,\n" 8436 " List3});", 8437 getLLVMStyleWithColumns(35)); 8438 verifyFormat("someFunction(Param, Param,\n" 8439 " {List1, List2,\n" 8440 " List3});", 8441 getLLVMStyleWithColumns(35)); 8442 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa, {},\n" 8443 " aaaaaaaaaaaaaaaaaaaaaaa);"); 8444 } 8445 8446 TEST_F(FormatTest, PullTrivialFunctionDefinitionsIntoSingleLine) { 8447 FormatStyle DoNotMerge = getLLVMStyle(); 8448 DoNotMerge.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 8449 8450 verifyFormat("void f() { return 42; }"); 8451 verifyFormat("void f() {\n" 8452 " return 42;\n" 8453 "}", 8454 DoNotMerge); 8455 verifyFormat("void f() {\n" 8456 " // Comment\n" 8457 "}"); 8458 verifyFormat("{\n" 8459 "#error {\n" 8460 " int a;\n" 8461 "}"); 8462 verifyFormat("{\n" 8463 " int a;\n" 8464 "#error {\n" 8465 "}"); 8466 verifyFormat("void f() {} // comment"); 8467 verifyFormat("void f() { int a; } // comment"); 8468 verifyFormat("void f() {\n" 8469 "} // comment", 8470 DoNotMerge); 8471 verifyFormat("void f() {\n" 8472 " int a;\n" 8473 "} // comment", 8474 DoNotMerge); 8475 verifyFormat("void f() {\n" 8476 "} // comment", 8477 getLLVMStyleWithColumns(15)); 8478 8479 verifyFormat("void f() { return 42; }", getLLVMStyleWithColumns(23)); 8480 verifyFormat("void f() {\n return 42;\n}", getLLVMStyleWithColumns(22)); 8481 8482 verifyFormat("void f() {}", getLLVMStyleWithColumns(11)); 8483 verifyFormat("void f() {\n}", getLLVMStyleWithColumns(10)); 8484 verifyFormat("class C {\n" 8485 " C()\n" 8486 " : iiiiiiii(nullptr),\n" 8487 " kkkkkkk(nullptr),\n" 8488 " mmmmmmm(nullptr),\n" 8489 " nnnnnnn(nullptr) {}\n" 8490 "};", 8491 getGoogleStyle()); 8492 8493 FormatStyle NoColumnLimit = getLLVMStyle(); 8494 NoColumnLimit.ColumnLimit = 0; 8495 EXPECT_EQ("A() : b(0) {}", format("A():b(0){}", NoColumnLimit)); 8496 EXPECT_EQ("class C {\n" 8497 " A() : b(0) {}\n" 8498 "};", 8499 format("class C{A():b(0){}};", NoColumnLimit)); 8500 EXPECT_EQ("A()\n" 8501 " : b(0) {\n" 8502 "}", 8503 format("A()\n:b(0)\n{\n}", NoColumnLimit)); 8504 8505 FormatStyle DoNotMergeNoColumnLimit = NoColumnLimit; 8506 DoNotMergeNoColumnLimit.AllowShortFunctionsOnASingleLine = 8507 FormatStyle::SFS_None; 8508 EXPECT_EQ("A()\n" 8509 " : b(0) {\n" 8510 "}", 8511 format("A():b(0){}", DoNotMergeNoColumnLimit)); 8512 EXPECT_EQ("A()\n" 8513 " : b(0) {\n" 8514 "}", 8515 format("A()\n:b(0)\n{\n}", DoNotMergeNoColumnLimit)); 8516 8517 verifyFormat("#define A \\\n" 8518 " void f() { \\\n" 8519 " int i; \\\n" 8520 " }", 8521 getLLVMStyleWithColumns(20)); 8522 verifyFormat("#define A \\\n" 8523 " void f() { int i; }", 8524 getLLVMStyleWithColumns(21)); 8525 verifyFormat("#define A \\\n" 8526 " void f() { \\\n" 8527 " int i; \\\n" 8528 " } \\\n" 8529 " int j;", 8530 getLLVMStyleWithColumns(22)); 8531 verifyFormat("#define A \\\n" 8532 " void f() { int i; } \\\n" 8533 " int j;", 8534 getLLVMStyleWithColumns(23)); 8535 } 8536 8537 TEST_F(FormatTest, PullEmptyFunctionDefinitionsIntoSingleLine) { 8538 FormatStyle MergeEmptyOnly = getLLVMStyle(); 8539 MergeEmptyOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty; 8540 verifyFormat("class C {\n" 8541 " int f() {}\n" 8542 "};", 8543 MergeEmptyOnly); 8544 verifyFormat("class C {\n" 8545 " int f() {\n" 8546 " return 42;\n" 8547 " }\n" 8548 "};", 8549 MergeEmptyOnly); 8550 verifyFormat("int f() {}", MergeEmptyOnly); 8551 verifyFormat("int f() {\n" 8552 " return 42;\n" 8553 "}", 8554 MergeEmptyOnly); 8555 8556 // Also verify behavior when BraceWrapping.AfterFunction = true 8557 MergeEmptyOnly.BreakBeforeBraces = FormatStyle::BS_Custom; 8558 MergeEmptyOnly.BraceWrapping.AfterFunction = true; 8559 verifyFormat("int f() {}", MergeEmptyOnly); 8560 verifyFormat("class C {\n" 8561 " int f() {}\n" 8562 "};", 8563 MergeEmptyOnly); 8564 } 8565 8566 TEST_F(FormatTest, PullInlineFunctionDefinitionsIntoSingleLine) { 8567 FormatStyle MergeInlineOnly = getLLVMStyle(); 8568 MergeInlineOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; 8569 verifyFormat("class C {\n" 8570 " int f() { return 42; }\n" 8571 "};", 8572 MergeInlineOnly); 8573 verifyFormat("int f() {\n" 8574 " return 42;\n" 8575 "}", 8576 MergeInlineOnly); 8577 8578 // SFS_Inline implies SFS_Empty 8579 verifyFormat("class C {\n" 8580 " int f() {}\n" 8581 "};", 8582 MergeInlineOnly); 8583 verifyFormat("int f() {}", MergeInlineOnly); 8584 8585 // Also verify behavior when BraceWrapping.AfterFunction = true 8586 MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom; 8587 MergeInlineOnly.BraceWrapping.AfterFunction = true; 8588 verifyFormat("class C {\n" 8589 " int f() { return 42; }\n" 8590 "};", 8591 MergeInlineOnly); 8592 verifyFormat("int f()\n" 8593 "{\n" 8594 " return 42;\n" 8595 "}", 8596 MergeInlineOnly); 8597 8598 // SFS_Inline implies SFS_Empty 8599 verifyFormat("int f() {}", MergeInlineOnly); 8600 verifyFormat("class C {\n" 8601 " int f() {}\n" 8602 "};", 8603 MergeInlineOnly); 8604 } 8605 8606 TEST_F(FormatTest, PullInlineOnlyFunctionDefinitionsIntoSingleLine) { 8607 FormatStyle MergeInlineOnly = getLLVMStyle(); 8608 MergeInlineOnly.AllowShortFunctionsOnASingleLine = 8609 FormatStyle::SFS_InlineOnly; 8610 verifyFormat("class C {\n" 8611 " int f() { return 42; }\n" 8612 "};", 8613 MergeInlineOnly); 8614 verifyFormat("int f() {\n" 8615 " return 42;\n" 8616 "}", 8617 MergeInlineOnly); 8618 8619 // SFS_InlineOnly does not imply SFS_Empty 8620 verifyFormat("class C {\n" 8621 " int f() {}\n" 8622 "};", 8623 MergeInlineOnly); 8624 verifyFormat("int f() {\n" 8625 "}", 8626 MergeInlineOnly); 8627 8628 // Also verify behavior when BraceWrapping.AfterFunction = true 8629 MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom; 8630 MergeInlineOnly.BraceWrapping.AfterFunction = true; 8631 verifyFormat("class C {\n" 8632 " int f() { return 42; }\n" 8633 "};", 8634 MergeInlineOnly); 8635 verifyFormat("int f()\n" 8636 "{\n" 8637 " return 42;\n" 8638 "}", 8639 MergeInlineOnly); 8640 8641 // SFS_InlineOnly does not imply SFS_Empty 8642 verifyFormat("int f()\n" 8643 "{\n" 8644 "}", 8645 MergeInlineOnly); 8646 verifyFormat("class C {\n" 8647 " int f() {}\n" 8648 "};", 8649 MergeInlineOnly); 8650 } 8651 8652 TEST_F(FormatTest, SplitEmptyFunction) { 8653 FormatStyle Style = getLLVMStyle(); 8654 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 8655 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8656 Style.BraceWrapping.AfterFunction = true; 8657 Style.BraceWrapping.SplitEmptyFunction = false; 8658 Style.ColumnLimit = 40; 8659 8660 verifyFormat("int f()\n" 8661 "{}", 8662 Style); 8663 verifyFormat("int f()\n" 8664 "{\n" 8665 " return 42;\n" 8666 "}", 8667 Style); 8668 verifyFormat("int f()\n" 8669 "{\n" 8670 " // some comment\n" 8671 "}", 8672 Style); 8673 8674 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty; 8675 verifyFormat("int f() {}", Style); 8676 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8677 "{}", 8678 Style); 8679 verifyFormat("int f()\n" 8680 "{\n" 8681 " return 0;\n" 8682 "}", 8683 Style); 8684 8685 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; 8686 verifyFormat("class Foo {\n" 8687 " int f() {}\n" 8688 "};\n", 8689 Style); 8690 verifyFormat("class Foo {\n" 8691 " int f() { return 0; }\n" 8692 "};\n", 8693 Style); 8694 verifyFormat("class Foo {\n" 8695 " int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8696 " {}\n" 8697 "};\n", 8698 Style); 8699 verifyFormat("class Foo {\n" 8700 " int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8701 " {\n" 8702 " return 0;\n" 8703 " }\n" 8704 "};\n", 8705 Style); 8706 8707 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 8708 verifyFormat("int f() {}", Style); 8709 verifyFormat("int f() { return 0; }", Style); 8710 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8711 "{}", 8712 Style); 8713 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8714 "{\n" 8715 " return 0;\n" 8716 "}", 8717 Style); 8718 } 8719 TEST_F(FormatTest, KeepShortFunctionAfterPPElse) { 8720 FormatStyle Style = getLLVMStyle(); 8721 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 8722 verifyFormat("#ifdef A\n" 8723 "int f() {}\n" 8724 "#else\n" 8725 "int g() {}\n" 8726 "#endif", 8727 Style); 8728 } 8729 8730 TEST_F(FormatTest, SplitEmptyClass) { 8731 FormatStyle Style = getLLVMStyle(); 8732 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8733 Style.BraceWrapping.AfterClass = true; 8734 Style.BraceWrapping.SplitEmptyRecord = false; 8735 8736 verifyFormat("class Foo\n" 8737 "{};", 8738 Style); 8739 verifyFormat("/* something */ class Foo\n" 8740 "{};", 8741 Style); 8742 verifyFormat("template <typename X> class Foo\n" 8743 "{};", 8744 Style); 8745 verifyFormat("class Foo\n" 8746 "{\n" 8747 " Foo();\n" 8748 "};", 8749 Style); 8750 verifyFormat("typedef class Foo\n" 8751 "{\n" 8752 "} Foo_t;", 8753 Style); 8754 } 8755 8756 TEST_F(FormatTest, SplitEmptyStruct) { 8757 FormatStyle Style = getLLVMStyle(); 8758 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8759 Style.BraceWrapping.AfterStruct = true; 8760 Style.BraceWrapping.SplitEmptyRecord = false; 8761 8762 verifyFormat("struct Foo\n" 8763 "{};", 8764 Style); 8765 verifyFormat("/* something */ struct Foo\n" 8766 "{};", 8767 Style); 8768 verifyFormat("template <typename X> struct Foo\n" 8769 "{};", 8770 Style); 8771 verifyFormat("struct Foo\n" 8772 "{\n" 8773 " Foo();\n" 8774 "};", 8775 Style); 8776 verifyFormat("typedef struct Foo\n" 8777 "{\n" 8778 "} Foo_t;", 8779 Style); 8780 // typedef struct Bar {} Bar_t; 8781 } 8782 8783 TEST_F(FormatTest, SplitEmptyUnion) { 8784 FormatStyle Style = getLLVMStyle(); 8785 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8786 Style.BraceWrapping.AfterUnion = true; 8787 Style.BraceWrapping.SplitEmptyRecord = false; 8788 8789 verifyFormat("union Foo\n" 8790 "{};", 8791 Style); 8792 verifyFormat("/* something */ union Foo\n" 8793 "{};", 8794 Style); 8795 verifyFormat("union Foo\n" 8796 "{\n" 8797 " A,\n" 8798 "};", 8799 Style); 8800 verifyFormat("typedef union Foo\n" 8801 "{\n" 8802 "} Foo_t;", 8803 Style); 8804 } 8805 8806 TEST_F(FormatTest, SplitEmptyNamespace) { 8807 FormatStyle Style = getLLVMStyle(); 8808 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8809 Style.BraceWrapping.AfterNamespace = true; 8810 Style.BraceWrapping.SplitEmptyNamespace = false; 8811 8812 verifyFormat("namespace Foo\n" 8813 "{};", 8814 Style); 8815 verifyFormat("/* something */ namespace Foo\n" 8816 "{};", 8817 Style); 8818 verifyFormat("inline namespace Foo\n" 8819 "{};", 8820 Style); 8821 verifyFormat("/* something */ inline namespace Foo\n" 8822 "{};", 8823 Style); 8824 verifyFormat("export namespace Foo\n" 8825 "{};", 8826 Style); 8827 verifyFormat("namespace Foo\n" 8828 "{\n" 8829 "void Bar();\n" 8830 "};", 8831 Style); 8832 } 8833 8834 TEST_F(FormatTest, NeverMergeShortRecords) { 8835 FormatStyle Style = getLLVMStyle(); 8836 8837 verifyFormat("class Foo {\n" 8838 " Foo();\n" 8839 "};", 8840 Style); 8841 verifyFormat("typedef class Foo {\n" 8842 " Foo();\n" 8843 "} Foo_t;", 8844 Style); 8845 verifyFormat("struct Foo {\n" 8846 " Foo();\n" 8847 "};", 8848 Style); 8849 verifyFormat("typedef struct Foo {\n" 8850 " Foo();\n" 8851 "} Foo_t;", 8852 Style); 8853 verifyFormat("union Foo {\n" 8854 " A,\n" 8855 "};", 8856 Style); 8857 verifyFormat("typedef union Foo {\n" 8858 " A,\n" 8859 "} Foo_t;", 8860 Style); 8861 verifyFormat("namespace Foo {\n" 8862 "void Bar();\n" 8863 "};", 8864 Style); 8865 8866 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8867 Style.BraceWrapping.AfterClass = true; 8868 Style.BraceWrapping.AfterStruct = true; 8869 Style.BraceWrapping.AfterUnion = true; 8870 Style.BraceWrapping.AfterNamespace = true; 8871 verifyFormat("class Foo\n" 8872 "{\n" 8873 " Foo();\n" 8874 "};", 8875 Style); 8876 verifyFormat("typedef class Foo\n" 8877 "{\n" 8878 " Foo();\n" 8879 "} Foo_t;", 8880 Style); 8881 verifyFormat("struct Foo\n" 8882 "{\n" 8883 " Foo();\n" 8884 "};", 8885 Style); 8886 verifyFormat("typedef struct Foo\n" 8887 "{\n" 8888 " Foo();\n" 8889 "} Foo_t;", 8890 Style); 8891 verifyFormat("union Foo\n" 8892 "{\n" 8893 " A,\n" 8894 "};", 8895 Style); 8896 verifyFormat("typedef union Foo\n" 8897 "{\n" 8898 " A,\n" 8899 "} Foo_t;", 8900 Style); 8901 verifyFormat("namespace Foo\n" 8902 "{\n" 8903 "void Bar();\n" 8904 "};", 8905 Style); 8906 } 8907 8908 TEST_F(FormatTest, UnderstandContextOfRecordTypeKeywords) { 8909 // Elaborate type variable declarations. 8910 verifyFormat("struct foo a = {bar};\nint n;"); 8911 verifyFormat("class foo a = {bar};\nint n;"); 8912 verifyFormat("union foo a = {bar};\nint n;"); 8913 8914 // Elaborate types inside function definitions. 8915 verifyFormat("struct foo f() {}\nint n;"); 8916 verifyFormat("class foo f() {}\nint n;"); 8917 verifyFormat("union foo f() {}\nint n;"); 8918 8919 // Templates. 8920 verifyFormat("template <class X> void f() {}\nint n;"); 8921 verifyFormat("template <struct X> void f() {}\nint n;"); 8922 verifyFormat("template <union X> void f() {}\nint n;"); 8923 8924 // Actual definitions... 8925 verifyFormat("struct {\n} n;"); 8926 verifyFormat( 8927 "template <template <class T, class Y>, class Z> class X {\n} n;"); 8928 verifyFormat("union Z {\n int n;\n} x;"); 8929 verifyFormat("class MACRO Z {\n} n;"); 8930 verifyFormat("class MACRO(X) Z {\n} n;"); 8931 verifyFormat("class __attribute__(X) Z {\n} n;"); 8932 verifyFormat("class __declspec(X) Z {\n} n;"); 8933 verifyFormat("class A##B##C {\n} n;"); 8934 verifyFormat("class alignas(16) Z {\n} n;"); 8935 verifyFormat("class MACRO(X) alignas(16) Z {\n} n;"); 8936 verifyFormat("class MACROA MACRO(X) Z {\n} n;"); 8937 8938 // Redefinition from nested context: 8939 verifyFormat("class A::B::C {\n} n;"); 8940 8941 // Template definitions. 8942 verifyFormat( 8943 "template <typename F>\n" 8944 "Matcher(const Matcher<F> &Other,\n" 8945 " typename enable_if_c<is_base_of<F, T>::value &&\n" 8946 " !is_same<F, T>::value>::type * = 0)\n" 8947 " : Implementation(new ImplicitCastMatcher<F>(Other)) {}"); 8948 8949 // FIXME: This is still incorrectly handled at the formatter side. 8950 verifyFormat("template <> struct X < 15, i<3 && 42 < 50 && 33 < 28> {};"); 8951 verifyFormat("int i = SomeFunction(a<b, a> b);"); 8952 8953 // FIXME: 8954 // This now gets parsed incorrectly as class definition. 8955 // verifyFormat("class A<int> f() {\n}\nint n;"); 8956 8957 // Elaborate types where incorrectly parsing the structural element would 8958 // break the indent. 8959 verifyFormat("if (true)\n" 8960 " class X x;\n" 8961 "else\n" 8962 " f();\n"); 8963 8964 // This is simply incomplete. Formatting is not important, but must not crash. 8965 verifyFormat("class A:"); 8966 } 8967 8968 TEST_F(FormatTest, DoNotInterfereWithErrorAndWarning) { 8969 EXPECT_EQ("#error Leave all white!!!!! space* alone!\n", 8970 format("#error Leave all white!!!!! space* alone!\n")); 8971 EXPECT_EQ( 8972 "#warning Leave all white!!!!! space* alone!\n", 8973 format("#warning Leave all white!!!!! space* alone!\n")); 8974 EXPECT_EQ("#error 1", format(" # error 1")); 8975 EXPECT_EQ("#warning 1", format(" # warning 1")); 8976 } 8977 8978 TEST_F(FormatTest, FormatHashIfExpressions) { 8979 verifyFormat("#if AAAA && BBBB"); 8980 verifyFormat("#if (AAAA && BBBB)"); 8981 verifyFormat("#elif (AAAA && BBBB)"); 8982 // FIXME: Come up with a better indentation for #elif. 8983 verifyFormat( 8984 "#if !defined(AAAAAAA) && (defined CCCCCC || defined DDDDDD) && \\\n" 8985 " defined(BBBBBBBB)\n" 8986 "#elif !defined(AAAAAA) && (defined CCCCC || defined DDDDDD) && \\\n" 8987 " defined(BBBBBBBB)\n" 8988 "#endif", 8989 getLLVMStyleWithColumns(65)); 8990 } 8991 8992 TEST_F(FormatTest, MergeHandlingInTheFaceOfPreprocessorDirectives) { 8993 FormatStyle AllowsMergedIf = getGoogleStyle(); 8994 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = 8995 FormatStyle::SIS_WithoutElse; 8996 verifyFormat("void f() { f(); }\n#error E", AllowsMergedIf); 8997 verifyFormat("if (true) return 42;\n#error E", AllowsMergedIf); 8998 verifyFormat("if (true)\n#error E\n return 42;", AllowsMergedIf); 8999 EXPECT_EQ("if (true) return 42;", 9000 format("if (true)\nreturn 42;", AllowsMergedIf)); 9001 FormatStyle ShortMergedIf = AllowsMergedIf; 9002 ShortMergedIf.ColumnLimit = 25; 9003 verifyFormat("#define A \\\n" 9004 " if (true) return 42;", 9005 ShortMergedIf); 9006 verifyFormat("#define A \\\n" 9007 " f(); \\\n" 9008 " if (true)\n" 9009 "#define B", 9010 ShortMergedIf); 9011 verifyFormat("#define A \\\n" 9012 " f(); \\\n" 9013 " if (true)\n" 9014 "g();", 9015 ShortMergedIf); 9016 verifyFormat("{\n" 9017 "#ifdef A\n" 9018 " // Comment\n" 9019 " if (true) continue;\n" 9020 "#endif\n" 9021 " // Comment\n" 9022 " if (true) continue;\n" 9023 "}", 9024 ShortMergedIf); 9025 ShortMergedIf.ColumnLimit = 33; 9026 verifyFormat("#define A \\\n" 9027 " if constexpr (true) return 42;", 9028 ShortMergedIf); 9029 verifyFormat("#define A \\\n" 9030 " if CONSTEXPR (true) return 42;", 9031 ShortMergedIf); 9032 ShortMergedIf.ColumnLimit = 29; 9033 verifyFormat("#define A \\\n" 9034 " if (aaaaaaaaaa) return 1; \\\n" 9035 " return 2;", 9036 ShortMergedIf); 9037 ShortMergedIf.ColumnLimit = 28; 9038 verifyFormat("#define A \\\n" 9039 " if (aaaaaaaaaa) \\\n" 9040 " return 1; \\\n" 9041 " return 2;", 9042 ShortMergedIf); 9043 verifyFormat("#define A \\\n" 9044 " if constexpr (aaaaaaa) \\\n" 9045 " return 1; \\\n" 9046 " return 2;", 9047 ShortMergedIf); 9048 verifyFormat("#define A \\\n" 9049 " if CONSTEXPR (aaaaaaa) \\\n" 9050 " return 1; \\\n" 9051 " return 2;", 9052 ShortMergedIf); 9053 } 9054 9055 TEST_F(FormatTest, FormatStarDependingOnContext) { 9056 verifyFormat("void f(int *a);"); 9057 verifyFormat("void f() { f(fint * b); }"); 9058 verifyFormat("class A {\n void f(int *a);\n};"); 9059 verifyFormat("class A {\n int *a;\n};"); 9060 verifyFormat("namespace a {\n" 9061 "namespace b {\n" 9062 "class A {\n" 9063 " void f() {}\n" 9064 " int *a;\n" 9065 "};\n" 9066 "} // namespace b\n" 9067 "} // namespace a"); 9068 } 9069 9070 TEST_F(FormatTest, SpecialTokensAtEndOfLine) { 9071 verifyFormat("while"); 9072 verifyFormat("operator"); 9073 } 9074 9075 TEST_F(FormatTest, SkipsDeeplyNestedLines) { 9076 // This code would be painfully slow to format if we didn't skip it. 9077 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 9078 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 9079 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 9080 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 9081 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 9082 "A(1, 1)\n" 9083 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" // 10x 9084 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9085 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9086 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9087 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9088 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9089 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9090 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9091 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9092 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1);\n"); 9093 // Deeply nested part is untouched, rest is formatted. 9094 EXPECT_EQ(std::string("int i;\n") + Code + "int j;\n", 9095 format(std::string("int i;\n") + Code + "int j;\n", 9096 getLLVMStyle(), SC_ExpectIncomplete)); 9097 } 9098 9099 //===----------------------------------------------------------------------===// 9100 // Objective-C tests. 9101 //===----------------------------------------------------------------------===// 9102 9103 TEST_F(FormatTest, FormatForObjectiveCMethodDecls) { 9104 verifyFormat("- (void)sendAction:(SEL)aSelector to:(BOOL)anObject;"); 9105 EXPECT_EQ("- (NSUInteger)indexOfObject:(id)anObject;", 9106 format("-(NSUInteger)indexOfObject:(id)anObject;")); 9107 EXPECT_EQ("- (NSInteger)Mthod1;", format("-(NSInteger)Mthod1;")); 9108 EXPECT_EQ("+ (id)Mthod2;", format("+(id)Mthod2;")); 9109 EXPECT_EQ("- (NSInteger)Method3:(id)anObject;", 9110 format("-(NSInteger)Method3:(id)anObject;")); 9111 EXPECT_EQ("- (NSInteger)Method4:(id)anObject;", 9112 format("-(NSInteger)Method4:(id)anObject;")); 9113 EXPECT_EQ("- (NSInteger)Method5:(id)anObject:(id)AnotherObject;", 9114 format("-(NSInteger)Method5:(id)anObject:(id)AnotherObject;")); 9115 EXPECT_EQ("- (id)Method6:(id)A:(id)B:(id)C:(id)D;", 9116 format("- (id)Method6:(id)A:(id)B:(id)C:(id)D;")); 9117 EXPECT_EQ("- (void)sendAction:(SEL)aSelector to:(id)anObject " 9118 "forAllCells:(BOOL)flag;", 9119 format("- (void)sendAction:(SEL)aSelector to:(id)anObject " 9120 "forAllCells:(BOOL)flag;")); 9121 9122 // Very long objectiveC method declaration. 9123 verifyFormat("- (void)aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n" 9124 " (SoooooooooooooooooooooomeType *)bbbbbbbbbb;"); 9125 verifyFormat("- (NSUInteger)indexOfObject:(id)anObject\n" 9126 " inRange:(NSRange)range\n" 9127 " outRange:(NSRange)out_range\n" 9128 " outRange1:(NSRange)out_range1\n" 9129 " outRange2:(NSRange)out_range2\n" 9130 " outRange3:(NSRange)out_range3\n" 9131 " outRange4:(NSRange)out_range4\n" 9132 " outRange5:(NSRange)out_range5\n" 9133 " outRange6:(NSRange)out_range6\n" 9134 " outRange7:(NSRange)out_range7\n" 9135 " outRange8:(NSRange)out_range8\n" 9136 " outRange9:(NSRange)out_range9;"); 9137 9138 // When the function name has to be wrapped. 9139 FormatStyle Style = getLLVMStyle(); 9140 // ObjC ignores IndentWrappedFunctionNames when wrapping methods 9141 // and always indents instead. 9142 Style.IndentWrappedFunctionNames = false; 9143 verifyFormat("- (SomeLooooooooooooooooooooongType *)\n" 9144 " veryLooooooooooongName:(NSString)aaaaaaaaaaaaaa\n" 9145 " anotherName:(NSString)bbbbbbbbbbbbbb {\n" 9146 "}", 9147 Style); 9148 Style.IndentWrappedFunctionNames = true; 9149 verifyFormat("- (SomeLooooooooooooooooooooongType *)\n" 9150 " veryLooooooooooongName:(NSString)cccccccccccccc\n" 9151 " anotherName:(NSString)dddddddddddddd {\n" 9152 "}", 9153 Style); 9154 9155 verifyFormat("- (int)sum:(vector<int>)numbers;"); 9156 verifyGoogleFormat("- (void)setDelegate:(id<Protocol>)delegate;"); 9157 // FIXME: In LLVM style, there should be a space in front of a '<' for ObjC 9158 // protocol lists (but not for template classes): 9159 // verifyFormat("- (void)setDelegate:(id <Protocol>)delegate;"); 9160 9161 verifyFormat("- (int (*)())foo:(int (*)())f;"); 9162 verifyGoogleFormat("- (int (*)())foo:(int (*)())foo;"); 9163 9164 // If there's no return type (very rare in practice!), LLVM and Google style 9165 // agree. 9166 verifyFormat("- foo;"); 9167 verifyFormat("- foo:(int)f;"); 9168 verifyGoogleFormat("- foo:(int)foo;"); 9169 } 9170 9171 TEST_F(FormatTest, BreaksStringLiterals) { 9172 EXPECT_EQ("\"some text \"\n" 9173 "\"other\";", 9174 format("\"some text other\";", getLLVMStyleWithColumns(12))); 9175 EXPECT_EQ("\"some text \"\n" 9176 "\"other\";", 9177 format("\\\n\"some text other\";", getLLVMStyleWithColumns(12))); 9178 EXPECT_EQ( 9179 "#define A \\\n" 9180 " \"some \" \\\n" 9181 " \"text \" \\\n" 9182 " \"other\";", 9183 format("#define A \"some text other\";", getLLVMStyleWithColumns(12))); 9184 EXPECT_EQ( 9185 "#define A \\\n" 9186 " \"so \" \\\n" 9187 " \"text \" \\\n" 9188 " \"other\";", 9189 format("#define A \"so text other\";", getLLVMStyleWithColumns(12))); 9190 9191 EXPECT_EQ("\"some text\"", 9192 format("\"some text\"", getLLVMStyleWithColumns(1))); 9193 EXPECT_EQ("\"some text\"", 9194 format("\"some text\"", getLLVMStyleWithColumns(11))); 9195 EXPECT_EQ("\"some \"\n" 9196 "\"text\"", 9197 format("\"some text\"", getLLVMStyleWithColumns(10))); 9198 EXPECT_EQ("\"some \"\n" 9199 "\"text\"", 9200 format("\"some text\"", getLLVMStyleWithColumns(7))); 9201 EXPECT_EQ("\"some\"\n" 9202 "\" tex\"\n" 9203 "\"t\"", 9204 format("\"some text\"", getLLVMStyleWithColumns(6))); 9205 EXPECT_EQ("\"some\"\n" 9206 "\" tex\"\n" 9207 "\" and\"", 9208 format("\"some tex and\"", getLLVMStyleWithColumns(6))); 9209 EXPECT_EQ("\"some\"\n" 9210 "\"/tex\"\n" 9211 "\"/and\"", 9212 format("\"some/tex/and\"", getLLVMStyleWithColumns(6))); 9213 9214 EXPECT_EQ("variable =\n" 9215 " \"long string \"\n" 9216 " \"literal\";", 9217 format("variable = \"long string literal\";", 9218 getLLVMStyleWithColumns(20))); 9219 9220 EXPECT_EQ("variable = f(\n" 9221 " \"long string \"\n" 9222 " \"literal\",\n" 9223 " short,\n" 9224 " loooooooooooooooooooong);", 9225 format("variable = f(\"long string literal\", short, " 9226 "loooooooooooooooooooong);", 9227 getLLVMStyleWithColumns(20))); 9228 9229 EXPECT_EQ( 9230 "f(g(\"long string \"\n" 9231 " \"literal\"),\n" 9232 " b);", 9233 format("f(g(\"long string literal\"), b);", getLLVMStyleWithColumns(20))); 9234 EXPECT_EQ("f(g(\"long string \"\n" 9235 " \"literal\",\n" 9236 " a),\n" 9237 " b);", 9238 format("f(g(\"long string literal\", a), b);", 9239 getLLVMStyleWithColumns(20))); 9240 EXPECT_EQ( 9241 "f(\"one two\".split(\n" 9242 " variable));", 9243 format("f(\"one two\".split(variable));", getLLVMStyleWithColumns(20))); 9244 EXPECT_EQ("f(\"one two three four five six \"\n" 9245 " \"seven\".split(\n" 9246 " really_looooong_variable));", 9247 format("f(\"one two three four five six seven\"." 9248 "split(really_looooong_variable));", 9249 getLLVMStyleWithColumns(33))); 9250 9251 EXPECT_EQ("f(\"some \"\n" 9252 " \"text\",\n" 9253 " other);", 9254 format("f(\"some text\", other);", getLLVMStyleWithColumns(10))); 9255 9256 // Only break as a last resort. 9257 verifyFormat( 9258 "aaaaaaaaaaaaaaaaaaaa(\n" 9259 " aaaaaaaaaaaaaaaaaaaa,\n" 9260 " aaaaaa(\"aaa aaaaa aaa aaa aaaaa aaa aaaaa aaa aaa aaaaaa\"));"); 9261 9262 EXPECT_EQ("\"splitmea\"\n" 9263 "\"trandomp\"\n" 9264 "\"oint\"", 9265 format("\"splitmeatrandompoint\"", getLLVMStyleWithColumns(10))); 9266 9267 EXPECT_EQ("\"split/\"\n" 9268 "\"pathat/\"\n" 9269 "\"slashes\"", 9270 format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10))); 9271 9272 EXPECT_EQ("\"split/\"\n" 9273 "\"pathat/\"\n" 9274 "\"slashes\"", 9275 format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10))); 9276 EXPECT_EQ("\"split at \"\n" 9277 "\"spaces/at/\"\n" 9278 "\"slashes.at.any$\"\n" 9279 "\"non-alphanumeric%\"\n" 9280 "\"1111111111characte\"\n" 9281 "\"rs\"", 9282 format("\"split at " 9283 "spaces/at/" 9284 "slashes.at." 9285 "any$non-" 9286 "alphanumeric%" 9287 "1111111111characte" 9288 "rs\"", 9289 getLLVMStyleWithColumns(20))); 9290 9291 // Verify that splitting the strings understands 9292 // Style::AlwaysBreakBeforeMultilineStrings. 9293 EXPECT_EQ("aaaaaaaaaaaa(\n" 9294 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa \"\n" 9295 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\");", 9296 format("aaaaaaaaaaaa(\"aaaaaaaaaaaaaaaaaaaaaaaaaa " 9297 "aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa " 9298 "aaaaaaaaaaaaaaaaaaaaaa\");", 9299 getGoogleStyle())); 9300 EXPECT_EQ("return \"aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 9301 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\";", 9302 format("return \"aaaaaaaaaaaaaaaaaaaaaa " 9303 "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa " 9304 "aaaaaaaaaaaaaaaaaaaaaa\";", 9305 getGoogleStyle())); 9306 EXPECT_EQ("llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 9307 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";", 9308 format("llvm::outs() << " 9309 "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa" 9310 "aaaaaaaaaaaaaaaaaaa\";")); 9311 EXPECT_EQ("ffff(\n" 9312 " {\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 9313 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});", 9314 format("ffff({\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa " 9315 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});", 9316 getGoogleStyle())); 9317 9318 FormatStyle Style = getLLVMStyleWithColumns(12); 9319 Style.BreakStringLiterals = false; 9320 EXPECT_EQ("\"some text other\";", format("\"some text other\";", Style)); 9321 9322 FormatStyle AlignLeft = getLLVMStyleWithColumns(12); 9323 AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left; 9324 EXPECT_EQ("#define A \\\n" 9325 " \"some \" \\\n" 9326 " \"text \" \\\n" 9327 " \"other\";", 9328 format("#define A \"some text other\";", AlignLeft)); 9329 } 9330 9331 TEST_F(FormatTest, BreaksStringLiteralsAtColumnLimit) { 9332 EXPECT_EQ("C a = \"some more \"\n" 9333 " \"text\";", 9334 format("C a = \"some more text\";", getLLVMStyleWithColumns(18))); 9335 } 9336 9337 TEST_F(FormatTest, FullyRemoveEmptyLines) { 9338 FormatStyle NoEmptyLines = getLLVMStyleWithColumns(80); 9339 NoEmptyLines.MaxEmptyLinesToKeep = 0; 9340 EXPECT_EQ("int i = a(b());", 9341 format("int i=a(\n\n b(\n\n\n )\n\n);", NoEmptyLines)); 9342 } 9343 9344 TEST_F(FormatTest, BreaksStringLiteralsWithTabs) { 9345 EXPECT_EQ( 9346 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 9347 "(\n" 9348 " \"x\t\");", 9349 format("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 9350 "aaaaaaa(" 9351 "\"x\t\");")); 9352 } 9353 9354 TEST_F(FormatTest, BreaksWideAndNSStringLiterals) { 9355 EXPECT_EQ( 9356 "u8\"utf8 string \"\n" 9357 "u8\"literal\";", 9358 format("u8\"utf8 string literal\";", getGoogleStyleWithColumns(16))); 9359 EXPECT_EQ( 9360 "u\"utf16 string \"\n" 9361 "u\"literal\";", 9362 format("u\"utf16 string literal\";", getGoogleStyleWithColumns(16))); 9363 EXPECT_EQ( 9364 "U\"utf32 string \"\n" 9365 "U\"literal\";", 9366 format("U\"utf32 string literal\";", getGoogleStyleWithColumns(16))); 9367 EXPECT_EQ("L\"wide string \"\n" 9368 "L\"literal\";", 9369 format("L\"wide string literal\";", getGoogleStyleWithColumns(16))); 9370 EXPECT_EQ("@\"NSString \"\n" 9371 "@\"literal\";", 9372 format("@\"NSString literal\";", getGoogleStyleWithColumns(19))); 9373 verifyFormat(R"(NSString *s = @"那那那那";)", getLLVMStyleWithColumns(26)); 9374 9375 // This input makes clang-format try to split the incomplete unicode escape 9376 // sequence, which used to lead to a crasher. 9377 verifyNoCrash( 9378 "aaaaaaaaaaaaaaaaaaaa = L\"\\udff\"'; // aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 9379 getLLVMStyleWithColumns(60)); 9380 } 9381 9382 TEST_F(FormatTest, DoesNotBreakRawStringLiterals) { 9383 FormatStyle Style = getGoogleStyleWithColumns(15); 9384 EXPECT_EQ("R\"x(raw literal)x\";", format("R\"x(raw literal)x\";", Style)); 9385 EXPECT_EQ("uR\"x(raw literal)x\";", format("uR\"x(raw literal)x\";", Style)); 9386 EXPECT_EQ("LR\"x(raw literal)x\";", format("LR\"x(raw literal)x\";", Style)); 9387 EXPECT_EQ("UR\"x(raw literal)x\";", format("UR\"x(raw literal)x\";", Style)); 9388 EXPECT_EQ("u8R\"x(raw literal)x\";", 9389 format("u8R\"x(raw literal)x\";", Style)); 9390 } 9391 9392 TEST_F(FormatTest, BreaksStringLiteralsWithin_TMacro) { 9393 FormatStyle Style = getLLVMStyleWithColumns(20); 9394 EXPECT_EQ( 9395 "_T(\"aaaaaaaaaaaaaa\")\n" 9396 "_T(\"aaaaaaaaaaaaaa\")\n" 9397 "_T(\"aaaaaaaaaaaa\")", 9398 format(" _T(\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\")", Style)); 9399 EXPECT_EQ("f(x,\n" 9400 " _T(\"aaaaaaaaaaaa\")\n" 9401 " _T(\"aaa\"),\n" 9402 " z);", 9403 format("f(x, _T(\"aaaaaaaaaaaaaaa\"), z);", Style)); 9404 9405 // FIXME: Handle embedded spaces in one iteration. 9406 // EXPECT_EQ("_T(\"aaaaaaaaaaaaa\")\n" 9407 // "_T(\"aaaaaaaaaaaaa\")\n" 9408 // "_T(\"aaaaaaaaaaaaa\")\n" 9409 // "_T(\"a\")", 9410 // format(" _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", 9411 // getLLVMStyleWithColumns(20))); 9412 EXPECT_EQ( 9413 "_T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", 9414 format(" _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", Style)); 9415 EXPECT_EQ("f(\n" 9416 "#if !TEST\n" 9417 " _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n" 9418 "#endif\n" 9419 ");", 9420 format("f(\n" 9421 "#if !TEST\n" 9422 "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n" 9423 "#endif\n" 9424 ");")); 9425 EXPECT_EQ("f(\n" 9426 "\n" 9427 " _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));", 9428 format("f(\n" 9429 "\n" 9430 "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));")); 9431 } 9432 9433 TEST_F(FormatTest, BreaksStringLiteralOperands) { 9434 // In a function call with two operands, the second can be broken with no line 9435 // break before it. 9436 EXPECT_EQ( 9437 "func(a, \"long long \"\n" 9438 " \"long long\");", 9439 format("func(a, \"long long long long\");", getLLVMStyleWithColumns(24))); 9440 // In a function call with three operands, the second must be broken with a 9441 // line break before it. 9442 EXPECT_EQ("func(a,\n" 9443 " \"long long long \"\n" 9444 " \"long\",\n" 9445 " c);", 9446 format("func(a, \"long long long long\", c);", 9447 getLLVMStyleWithColumns(24))); 9448 // In a function call with three operands, the third must be broken with a 9449 // line break before it. 9450 EXPECT_EQ("func(a, b,\n" 9451 " \"long long long \"\n" 9452 " \"long\");", 9453 format("func(a, b, \"long long long long\");", 9454 getLLVMStyleWithColumns(24))); 9455 // In a function call with three operands, both the second and the third must 9456 // be broken with a line break before them. 9457 EXPECT_EQ("func(a,\n" 9458 " \"long long long \"\n" 9459 " \"long\",\n" 9460 " \"long long long \"\n" 9461 " \"long\");", 9462 format("func(a, \"long long long long\", \"long long long long\");", 9463 getLLVMStyleWithColumns(24))); 9464 // In a chain of << with two operands, the second can be broken with no line 9465 // break before it. 9466 EXPECT_EQ("a << \"line line \"\n" 9467 " \"line\";", 9468 format("a << \"line line line\";", getLLVMStyleWithColumns(20))); 9469 // In a chain of << with three operands, the second can be broken with no line 9470 // break before it. 9471 EXPECT_EQ( 9472 "abcde << \"line \"\n" 9473 " \"line line\"\n" 9474 " << c;", 9475 format("abcde << \"line line line\" << c;", getLLVMStyleWithColumns(20))); 9476 // In a chain of << with three operands, the third must be broken with a line 9477 // break before it. 9478 EXPECT_EQ( 9479 "a << b\n" 9480 " << \"line line \"\n" 9481 " \"line\";", 9482 format("a << b << \"line line line\";", getLLVMStyleWithColumns(20))); 9483 // In a chain of << with three operands, the second can be broken with no line 9484 // break before it and the third must be broken with a line break before it. 9485 EXPECT_EQ("abcd << \"line line \"\n" 9486 " \"line\"\n" 9487 " << \"line line \"\n" 9488 " \"line\";", 9489 format("abcd << \"line line line\" << \"line line line\";", 9490 getLLVMStyleWithColumns(20))); 9491 // In a chain of binary operators with two operands, the second can be broken 9492 // with no line break before it. 9493 EXPECT_EQ( 9494 "abcd + \"line line \"\n" 9495 " \"line line\";", 9496 format("abcd + \"line line line line\";", getLLVMStyleWithColumns(20))); 9497 // In a chain of binary operators with three operands, the second must be 9498 // broken with a line break before it. 9499 EXPECT_EQ("abcd +\n" 9500 " \"line line \"\n" 9501 " \"line line\" +\n" 9502 " e;", 9503 format("abcd + \"line line line line\" + e;", 9504 getLLVMStyleWithColumns(20))); 9505 // In a function call with two operands, with AlignAfterOpenBracket enabled, 9506 // the first must be broken with a line break before it. 9507 FormatStyle Style = getLLVMStyleWithColumns(25); 9508 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 9509 EXPECT_EQ("someFunction(\n" 9510 " \"long long long \"\n" 9511 " \"long\",\n" 9512 " a);", 9513 format("someFunction(\"long long long long\", a);", Style)); 9514 } 9515 9516 TEST_F(FormatTest, DontSplitStringLiteralsWithEscapedNewlines) { 9517 EXPECT_EQ( 9518 "aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 9519 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 9520 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";", 9521 format("aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 9522 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 9523 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";")); 9524 } 9525 9526 TEST_F(FormatTest, CountsCharactersInMultilineRawStringLiterals) { 9527 EXPECT_EQ("f(g(R\"x(raw literal)x\", a), b);", 9528 format("f(g(R\"x(raw literal)x\", a), b);", getGoogleStyle())); 9529 EXPECT_EQ("fffffffffff(g(R\"x(\n" 9530 "multiline raw string literal xxxxxxxxxxxxxx\n" 9531 ")x\",\n" 9532 " a),\n" 9533 " b);", 9534 format("fffffffffff(g(R\"x(\n" 9535 "multiline raw string literal xxxxxxxxxxxxxx\n" 9536 ")x\", a), b);", 9537 getGoogleStyleWithColumns(20))); 9538 EXPECT_EQ("fffffffffff(\n" 9539 " g(R\"x(qqq\n" 9540 "multiline raw string literal xxxxxxxxxxxxxx\n" 9541 ")x\",\n" 9542 " a),\n" 9543 " b);", 9544 format("fffffffffff(g(R\"x(qqq\n" 9545 "multiline raw string literal xxxxxxxxxxxxxx\n" 9546 ")x\", a), b);", 9547 getGoogleStyleWithColumns(20))); 9548 9549 EXPECT_EQ("fffffffffff(R\"x(\n" 9550 "multiline raw string literal xxxxxxxxxxxxxx\n" 9551 ")x\");", 9552 format("fffffffffff(R\"x(\n" 9553 "multiline raw string literal xxxxxxxxxxxxxx\n" 9554 ")x\");", 9555 getGoogleStyleWithColumns(20))); 9556 EXPECT_EQ("fffffffffff(R\"x(\n" 9557 "multiline raw string literal xxxxxxxxxxxxxx\n" 9558 ")x\" + bbbbbb);", 9559 format("fffffffffff(R\"x(\n" 9560 "multiline raw string literal xxxxxxxxxxxxxx\n" 9561 ")x\" + bbbbbb);", 9562 getGoogleStyleWithColumns(20))); 9563 EXPECT_EQ("fffffffffff(\n" 9564 " R\"x(\n" 9565 "multiline raw string literal xxxxxxxxxxxxxx\n" 9566 ")x\" +\n" 9567 " bbbbbb);", 9568 format("fffffffffff(\n" 9569 " R\"x(\n" 9570 "multiline raw string literal xxxxxxxxxxxxxx\n" 9571 ")x\" + bbbbbb);", 9572 getGoogleStyleWithColumns(20))); 9573 EXPECT_EQ("fffffffffff(R\"(single line raw string)\" + bbbbbb);", 9574 format("fffffffffff(\n" 9575 " R\"(single line raw string)\" + bbbbbb);")); 9576 } 9577 9578 TEST_F(FormatTest, SkipsUnknownStringLiterals) { 9579 verifyFormat("string a = \"unterminated;"); 9580 EXPECT_EQ("function(\"unterminated,\n" 9581 " OtherParameter);", 9582 format("function( \"unterminated,\n" 9583 " OtherParameter);")); 9584 } 9585 9586 TEST_F(FormatTest, DoesNotTryToParseUDLiteralsInPreCpp11Code) { 9587 FormatStyle Style = getLLVMStyle(); 9588 Style.Standard = FormatStyle::LS_Cpp03; 9589 EXPECT_EQ("#define x(_a) printf(\"foo\" _a);", 9590 format("#define x(_a) printf(\"foo\"_a);", Style)); 9591 } 9592 9593 TEST_F(FormatTest, CppLexVersion) { 9594 FormatStyle Style = getLLVMStyle(); 9595 // Formatting of x * y differs if x is a type. 9596 verifyFormat("void foo() { MACRO(a * b); }", Style); 9597 verifyFormat("void foo() { MACRO(int *b); }", Style); 9598 9599 // LLVM style uses latest lexer. 9600 verifyFormat("void foo() { MACRO(char8_t *b); }", Style); 9601 Style.Standard = FormatStyle::LS_Cpp17; 9602 // But in c++17, char8_t isn't a keyword. 9603 verifyFormat("void foo() { MACRO(char8_t * b); }", Style); 9604 } 9605 9606 TEST_F(FormatTest, UnderstandsCpp1y) { verifyFormat("int bi{1'000'000};"); } 9607 9608 TEST_F(FormatTest, BreakStringLiteralsBeforeUnbreakableTokenSequence) { 9609 EXPECT_EQ("someFunction(\"aaabbbcccd\"\n" 9610 " \"ddeeefff\");", 9611 format("someFunction(\"aaabbbcccdddeeefff\");", 9612 getLLVMStyleWithColumns(25))); 9613 EXPECT_EQ("someFunction1234567890(\n" 9614 " \"aaabbbcccdddeeefff\");", 9615 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 9616 getLLVMStyleWithColumns(26))); 9617 EXPECT_EQ("someFunction1234567890(\n" 9618 " \"aaabbbcccdddeeeff\"\n" 9619 " \"f\");", 9620 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 9621 getLLVMStyleWithColumns(25))); 9622 EXPECT_EQ("someFunction1234567890(\n" 9623 " \"aaabbbcccdddeeeff\"\n" 9624 " \"f\");", 9625 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 9626 getLLVMStyleWithColumns(24))); 9627 EXPECT_EQ("someFunction(\n" 9628 " \"aaabbbcc ddde \"\n" 9629 " \"efff\");", 9630 format("someFunction(\"aaabbbcc ddde efff\");", 9631 getLLVMStyleWithColumns(25))); 9632 EXPECT_EQ("someFunction(\"aaabbbccc \"\n" 9633 " \"ddeeefff\");", 9634 format("someFunction(\"aaabbbccc ddeeefff\");", 9635 getLLVMStyleWithColumns(25))); 9636 EXPECT_EQ("someFunction1234567890(\n" 9637 " \"aaabb \"\n" 9638 " \"cccdddeeefff\");", 9639 format("someFunction1234567890(\"aaabb cccdddeeefff\");", 9640 getLLVMStyleWithColumns(25))); 9641 EXPECT_EQ("#define A \\\n" 9642 " string s = \\\n" 9643 " \"123456789\" \\\n" 9644 " \"0\"; \\\n" 9645 " int i;", 9646 format("#define A string s = \"1234567890\"; int i;", 9647 getLLVMStyleWithColumns(20))); 9648 EXPECT_EQ("someFunction(\n" 9649 " \"aaabbbcc \"\n" 9650 " \"dddeeefff\");", 9651 format("someFunction(\"aaabbbcc dddeeefff\");", 9652 getLLVMStyleWithColumns(25))); 9653 } 9654 9655 TEST_F(FormatTest, DoNotBreakStringLiteralsInEscapeSequence) { 9656 EXPECT_EQ("\"\\a\"", format("\"\\a\"", getLLVMStyleWithColumns(3))); 9657 EXPECT_EQ("\"\\\"", format("\"\\\"", getLLVMStyleWithColumns(2))); 9658 EXPECT_EQ("\"test\"\n" 9659 "\"\\n\"", 9660 format("\"test\\n\"", getLLVMStyleWithColumns(7))); 9661 EXPECT_EQ("\"tes\\\\\"\n" 9662 "\"n\"", 9663 format("\"tes\\\\n\"", getLLVMStyleWithColumns(7))); 9664 EXPECT_EQ("\"\\\\\\\\\"\n" 9665 "\"\\n\"", 9666 format("\"\\\\\\\\\\n\"", getLLVMStyleWithColumns(7))); 9667 EXPECT_EQ("\"\\uff01\"", format("\"\\uff01\"", getLLVMStyleWithColumns(7))); 9668 EXPECT_EQ("\"\\uff01\"\n" 9669 "\"test\"", 9670 format("\"\\uff01test\"", getLLVMStyleWithColumns(8))); 9671 EXPECT_EQ("\"\\Uff01ff02\"", 9672 format("\"\\Uff01ff02\"", getLLVMStyleWithColumns(11))); 9673 EXPECT_EQ("\"\\x000000000001\"\n" 9674 "\"next\"", 9675 format("\"\\x000000000001next\"", getLLVMStyleWithColumns(16))); 9676 EXPECT_EQ("\"\\x000000000001next\"", 9677 format("\"\\x000000000001next\"", getLLVMStyleWithColumns(15))); 9678 EXPECT_EQ("\"\\x000000000001\"", 9679 format("\"\\x000000000001\"", getLLVMStyleWithColumns(7))); 9680 EXPECT_EQ("\"test\"\n" 9681 "\"\\000000\"\n" 9682 "\"000001\"", 9683 format("\"test\\000000000001\"", getLLVMStyleWithColumns(9))); 9684 EXPECT_EQ("\"test\\000\"\n" 9685 "\"00000000\"\n" 9686 "\"1\"", 9687 format("\"test\\000000000001\"", getLLVMStyleWithColumns(10))); 9688 } 9689 9690 TEST_F(FormatTest, DoNotCreateUnreasonableUnwrappedLines) { 9691 verifyFormat("void f() {\n" 9692 " return g() {}\n" 9693 " void h() {}"); 9694 verifyFormat("int a[] = {void forgot_closing_brace(){f();\n" 9695 "g();\n" 9696 "}"); 9697 } 9698 9699 TEST_F(FormatTest, DoNotPrematurelyEndUnwrappedLineForReturnStatements) { 9700 verifyFormat( 9701 "void f() { return C{param1, param2}.SomeCall(param1, param2); }"); 9702 } 9703 9704 TEST_F(FormatTest, FormatsClosingBracesInEmptyNestedBlocks) { 9705 verifyFormat("class X {\n" 9706 " void f() {\n" 9707 " }\n" 9708 "};", 9709 getLLVMStyleWithColumns(12)); 9710 } 9711 9712 TEST_F(FormatTest, ConfigurableIndentWidth) { 9713 FormatStyle EightIndent = getLLVMStyleWithColumns(18); 9714 EightIndent.IndentWidth = 8; 9715 EightIndent.ContinuationIndentWidth = 8; 9716 verifyFormat("void f() {\n" 9717 " someFunction();\n" 9718 " if (true) {\n" 9719 " f();\n" 9720 " }\n" 9721 "}", 9722 EightIndent); 9723 verifyFormat("class X {\n" 9724 " void f() {\n" 9725 " }\n" 9726 "};", 9727 EightIndent); 9728 verifyFormat("int x[] = {\n" 9729 " call(),\n" 9730 " call()};", 9731 EightIndent); 9732 } 9733 9734 TEST_F(FormatTest, ConfigurableFunctionDeclarationIndentAfterType) { 9735 verifyFormat("double\n" 9736 "f();", 9737 getLLVMStyleWithColumns(8)); 9738 } 9739 9740 TEST_F(FormatTest, ConfigurableUseOfTab) { 9741 FormatStyle Tab = getLLVMStyleWithColumns(42); 9742 Tab.IndentWidth = 8; 9743 Tab.UseTab = FormatStyle::UT_Always; 9744 Tab.AlignEscapedNewlines = FormatStyle::ENAS_Left; 9745 9746 EXPECT_EQ("if (aaaaaaaa && // q\n" 9747 " bb)\t\t// w\n" 9748 "\t;", 9749 format("if (aaaaaaaa &&// q\n" 9750 "bb)// w\n" 9751 ";", 9752 Tab)); 9753 EXPECT_EQ("if (aaa && bbb) // w\n" 9754 "\t;", 9755 format("if(aaa&&bbb)// w\n" 9756 ";", 9757 Tab)); 9758 9759 verifyFormat("class X {\n" 9760 "\tvoid f() {\n" 9761 "\t\tsomeFunction(parameter1,\n" 9762 "\t\t\t parameter2);\n" 9763 "\t}\n" 9764 "};", 9765 Tab); 9766 verifyFormat("#define A \\\n" 9767 "\tvoid f() { \\\n" 9768 "\t\tsomeFunction( \\\n" 9769 "\t\t parameter1, \\\n" 9770 "\t\t parameter2); \\\n" 9771 "\t}", 9772 Tab); 9773 verifyFormat("int a;\t // x\n" 9774 "int bbbbbbbb; // x\n", 9775 Tab); 9776 9777 Tab.TabWidth = 4; 9778 Tab.IndentWidth = 8; 9779 verifyFormat("class TabWidth4Indent8 {\n" 9780 "\t\tvoid f() {\n" 9781 "\t\t\t\tsomeFunction(parameter1,\n" 9782 "\t\t\t\t\t\t\t parameter2);\n" 9783 "\t\t}\n" 9784 "};", 9785 Tab); 9786 9787 Tab.TabWidth = 4; 9788 Tab.IndentWidth = 4; 9789 verifyFormat("class TabWidth4Indent4 {\n" 9790 "\tvoid f() {\n" 9791 "\t\tsomeFunction(parameter1,\n" 9792 "\t\t\t\t\t parameter2);\n" 9793 "\t}\n" 9794 "};", 9795 Tab); 9796 9797 Tab.TabWidth = 8; 9798 Tab.IndentWidth = 4; 9799 verifyFormat("class TabWidth8Indent4 {\n" 9800 " void f() {\n" 9801 "\tsomeFunction(parameter1,\n" 9802 "\t\t parameter2);\n" 9803 " }\n" 9804 "};", 9805 Tab); 9806 9807 Tab.TabWidth = 8; 9808 Tab.IndentWidth = 8; 9809 EXPECT_EQ("/*\n" 9810 "\t a\t\tcomment\n" 9811 "\t in multiple lines\n" 9812 " */", 9813 format(" /*\t \t \n" 9814 " \t \t a\t\tcomment\t \t\n" 9815 " \t \t in multiple lines\t\n" 9816 " \t */", 9817 Tab)); 9818 9819 Tab.UseTab = FormatStyle::UT_ForIndentation; 9820 verifyFormat("{\n" 9821 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9822 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9823 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9824 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9825 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9826 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9827 "};", 9828 Tab); 9829 verifyFormat("enum AA {\n" 9830 "\ta1, // Force multiple lines\n" 9831 "\ta2,\n" 9832 "\ta3\n" 9833 "};", 9834 Tab); 9835 EXPECT_EQ("if (aaaaaaaa && // q\n" 9836 " bb) // w\n" 9837 "\t;", 9838 format("if (aaaaaaaa &&// q\n" 9839 "bb)// w\n" 9840 ";", 9841 Tab)); 9842 verifyFormat("class X {\n" 9843 "\tvoid f() {\n" 9844 "\t\tsomeFunction(parameter1,\n" 9845 "\t\t parameter2);\n" 9846 "\t}\n" 9847 "};", 9848 Tab); 9849 verifyFormat("{\n" 9850 "\tQ(\n" 9851 "\t {\n" 9852 "\t\t int a;\n" 9853 "\t\t someFunction(aaaaaaaa,\n" 9854 "\t\t bbbbbbb);\n" 9855 "\t },\n" 9856 "\t p);\n" 9857 "}", 9858 Tab); 9859 EXPECT_EQ("{\n" 9860 "\t/* aaaa\n" 9861 "\t bbbb */\n" 9862 "}", 9863 format("{\n" 9864 "/* aaaa\n" 9865 " bbbb */\n" 9866 "}", 9867 Tab)); 9868 EXPECT_EQ("{\n" 9869 "\t/*\n" 9870 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 9871 "\t bbbbbbbbbbbbb\n" 9872 "\t*/\n" 9873 "}", 9874 format("{\n" 9875 "/*\n" 9876 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 9877 "*/\n" 9878 "}", 9879 Tab)); 9880 EXPECT_EQ("{\n" 9881 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 9882 "\t// bbbbbbbbbbbbb\n" 9883 "}", 9884 format("{\n" 9885 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 9886 "}", 9887 Tab)); 9888 EXPECT_EQ("{\n" 9889 "\t/*\n" 9890 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 9891 "\t bbbbbbbbbbbbb\n" 9892 "\t*/\n" 9893 "}", 9894 format("{\n" 9895 "\t/*\n" 9896 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 9897 "\t*/\n" 9898 "}", 9899 Tab)); 9900 EXPECT_EQ("{\n" 9901 "\t/*\n" 9902 "\n" 9903 "\t*/\n" 9904 "}", 9905 format("{\n" 9906 "\t/*\n" 9907 "\n" 9908 "\t*/\n" 9909 "}", 9910 Tab)); 9911 EXPECT_EQ("{\n" 9912 "\t/*\n" 9913 " asdf\n" 9914 "\t*/\n" 9915 "}", 9916 format("{\n" 9917 "\t/*\n" 9918 " asdf\n" 9919 "\t*/\n" 9920 "}", 9921 Tab)); 9922 9923 Tab.UseTab = FormatStyle::UT_Never; 9924 EXPECT_EQ("/*\n" 9925 " a\t\tcomment\n" 9926 " in multiple lines\n" 9927 " */", 9928 format(" /*\t \t \n" 9929 " \t \t a\t\tcomment\t \t\n" 9930 " \t \t in multiple lines\t\n" 9931 " \t */", 9932 Tab)); 9933 EXPECT_EQ("/* some\n" 9934 " comment */", 9935 format(" \t \t /* some\n" 9936 " \t \t comment */", 9937 Tab)); 9938 EXPECT_EQ("int a; /* some\n" 9939 " comment */", 9940 format(" \t \t int a; /* some\n" 9941 " \t \t comment */", 9942 Tab)); 9943 9944 EXPECT_EQ("int a; /* some\n" 9945 "comment */", 9946 format(" \t \t int\ta; /* some\n" 9947 " \t \t comment */", 9948 Tab)); 9949 EXPECT_EQ("f(\"\t\t\"); /* some\n" 9950 " comment */", 9951 format(" \t \t f(\"\t\t\"); /* some\n" 9952 " \t \t comment */", 9953 Tab)); 9954 EXPECT_EQ("{\n" 9955 " /*\n" 9956 " * Comment\n" 9957 " */\n" 9958 " int i;\n" 9959 "}", 9960 format("{\n" 9961 "\t/*\n" 9962 "\t * Comment\n" 9963 "\t */\n" 9964 "\t int i;\n" 9965 "}")); 9966 9967 Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation; 9968 Tab.TabWidth = 8; 9969 Tab.IndentWidth = 8; 9970 EXPECT_EQ("if (aaaaaaaa && // q\n" 9971 " bb) // w\n" 9972 "\t;", 9973 format("if (aaaaaaaa &&// q\n" 9974 "bb)// w\n" 9975 ";", 9976 Tab)); 9977 EXPECT_EQ("if (aaa && bbb) // w\n" 9978 "\t;", 9979 format("if(aaa&&bbb)// w\n" 9980 ";", 9981 Tab)); 9982 verifyFormat("class X {\n" 9983 "\tvoid f() {\n" 9984 "\t\tsomeFunction(parameter1,\n" 9985 "\t\t\t parameter2);\n" 9986 "\t}\n" 9987 "};", 9988 Tab); 9989 verifyFormat("#define A \\\n" 9990 "\tvoid f() { \\\n" 9991 "\t\tsomeFunction( \\\n" 9992 "\t\t parameter1, \\\n" 9993 "\t\t parameter2); \\\n" 9994 "\t}", 9995 Tab); 9996 Tab.TabWidth = 4; 9997 Tab.IndentWidth = 8; 9998 verifyFormat("class TabWidth4Indent8 {\n" 9999 "\t\tvoid f() {\n" 10000 "\t\t\t\tsomeFunction(parameter1,\n" 10001 "\t\t\t\t\t\t\t parameter2);\n" 10002 "\t\t}\n" 10003 "};", 10004 Tab); 10005 Tab.TabWidth = 4; 10006 Tab.IndentWidth = 4; 10007 verifyFormat("class TabWidth4Indent4 {\n" 10008 "\tvoid f() {\n" 10009 "\t\tsomeFunction(parameter1,\n" 10010 "\t\t\t\t\t parameter2);\n" 10011 "\t}\n" 10012 "};", 10013 Tab); 10014 Tab.TabWidth = 8; 10015 Tab.IndentWidth = 4; 10016 verifyFormat("class TabWidth8Indent4 {\n" 10017 " void f() {\n" 10018 "\tsomeFunction(parameter1,\n" 10019 "\t\t parameter2);\n" 10020 " }\n" 10021 "};", 10022 Tab); 10023 Tab.TabWidth = 8; 10024 Tab.IndentWidth = 8; 10025 EXPECT_EQ("/*\n" 10026 "\t a\t\tcomment\n" 10027 "\t in multiple lines\n" 10028 " */", 10029 format(" /*\t \t \n" 10030 " \t \t a\t\tcomment\t \t\n" 10031 " \t \t in multiple lines\t\n" 10032 " \t */", 10033 Tab)); 10034 verifyFormat("{\n" 10035 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10036 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10037 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10038 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10039 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10040 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10041 "};", 10042 Tab); 10043 verifyFormat("enum AA {\n" 10044 "\ta1, // Force multiple lines\n" 10045 "\ta2,\n" 10046 "\ta3\n" 10047 "};", 10048 Tab); 10049 EXPECT_EQ("if (aaaaaaaa && // q\n" 10050 " bb) // w\n" 10051 "\t;", 10052 format("if (aaaaaaaa &&// q\n" 10053 "bb)// w\n" 10054 ";", 10055 Tab)); 10056 verifyFormat("class X {\n" 10057 "\tvoid f() {\n" 10058 "\t\tsomeFunction(parameter1,\n" 10059 "\t\t\t parameter2);\n" 10060 "\t}\n" 10061 "};", 10062 Tab); 10063 verifyFormat("{\n" 10064 "\tQ(\n" 10065 "\t {\n" 10066 "\t\t int a;\n" 10067 "\t\t someFunction(aaaaaaaa,\n" 10068 "\t\t\t\t bbbbbbb);\n" 10069 "\t },\n" 10070 "\t p);\n" 10071 "}", 10072 Tab); 10073 EXPECT_EQ("{\n" 10074 "\t/* aaaa\n" 10075 "\t bbbb */\n" 10076 "}", 10077 format("{\n" 10078 "/* aaaa\n" 10079 " bbbb */\n" 10080 "}", 10081 Tab)); 10082 EXPECT_EQ("{\n" 10083 "\t/*\n" 10084 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10085 "\t bbbbbbbbbbbbb\n" 10086 "\t*/\n" 10087 "}", 10088 format("{\n" 10089 "/*\n" 10090 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10091 "*/\n" 10092 "}", 10093 Tab)); 10094 EXPECT_EQ("{\n" 10095 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10096 "\t// bbbbbbbbbbbbb\n" 10097 "}", 10098 format("{\n" 10099 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10100 "}", 10101 Tab)); 10102 EXPECT_EQ("{\n" 10103 "\t/*\n" 10104 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10105 "\t bbbbbbbbbbbbb\n" 10106 "\t*/\n" 10107 "}", 10108 format("{\n" 10109 "\t/*\n" 10110 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10111 "\t*/\n" 10112 "}", 10113 Tab)); 10114 EXPECT_EQ("{\n" 10115 "\t/*\n" 10116 "\n" 10117 "\t*/\n" 10118 "}", 10119 format("{\n" 10120 "\t/*\n" 10121 "\n" 10122 "\t*/\n" 10123 "}", 10124 Tab)); 10125 EXPECT_EQ("{\n" 10126 "\t/*\n" 10127 " asdf\n" 10128 "\t*/\n" 10129 "}", 10130 format("{\n" 10131 "\t/*\n" 10132 " asdf\n" 10133 "\t*/\n" 10134 "}", 10135 Tab)); 10136 EXPECT_EQ("/*\n" 10137 "\t a\t\tcomment\n" 10138 "\t in multiple lines\n" 10139 " */", 10140 format(" /*\t \t \n" 10141 " \t \t a\t\tcomment\t \t\n" 10142 " \t \t in multiple lines\t\n" 10143 " \t */", 10144 Tab)); 10145 EXPECT_EQ("/* some\n" 10146 " comment */", 10147 format(" \t \t /* some\n" 10148 " \t \t comment */", 10149 Tab)); 10150 EXPECT_EQ("int a; /* some\n" 10151 " comment */", 10152 format(" \t \t int a; /* some\n" 10153 " \t \t comment */", 10154 Tab)); 10155 EXPECT_EQ("int a; /* some\n" 10156 "comment */", 10157 format(" \t \t int\ta; /* some\n" 10158 " \t \t comment */", 10159 Tab)); 10160 EXPECT_EQ("f(\"\t\t\"); /* some\n" 10161 " comment */", 10162 format(" \t \t f(\"\t\t\"); /* some\n" 10163 " \t \t comment */", 10164 Tab)); 10165 EXPECT_EQ("{\n" 10166 " /*\n" 10167 " * Comment\n" 10168 " */\n" 10169 " int i;\n" 10170 "}", 10171 format("{\n" 10172 "\t/*\n" 10173 "\t * Comment\n" 10174 "\t */\n" 10175 "\t int i;\n" 10176 "}")); 10177 Tab.AlignConsecutiveAssignments = true; 10178 Tab.AlignConsecutiveDeclarations = true; 10179 Tab.TabWidth = 4; 10180 Tab.IndentWidth = 4; 10181 verifyFormat("class Assign {\n" 10182 "\tvoid f() {\n" 10183 "\t\tint x = 123;\n" 10184 "\t\tint random = 4;\n" 10185 "\t\tstd::string alphabet =\n" 10186 "\t\t\t\"abcdefghijklmnopqrstuvwxyz\";\n" 10187 "\t}\n" 10188 "};", 10189 Tab); 10190 } 10191 10192 TEST_F(FormatTest, ZeroTabWidth) { 10193 FormatStyle Tab = getLLVMStyleWithColumns(42); 10194 Tab.IndentWidth = 8; 10195 Tab.UseTab = FormatStyle::UT_Never; 10196 Tab.TabWidth = 0; 10197 EXPECT_EQ("void a(){\n" 10198 " // line starts with '\t'\n" 10199 "};", 10200 format("void a(){\n" 10201 "\t// line starts with '\t'\n" 10202 "};", 10203 Tab)); 10204 10205 EXPECT_EQ("void a(){\n" 10206 " // line starts with '\t'\n" 10207 "};", 10208 format("void a(){\n" 10209 "\t\t// line starts with '\t'\n" 10210 "};", 10211 Tab)); 10212 10213 Tab.UseTab = FormatStyle::UT_ForIndentation; 10214 EXPECT_EQ("void a(){\n" 10215 " // line starts with '\t'\n" 10216 "};", 10217 format("void a(){\n" 10218 "\t// line starts with '\t'\n" 10219 "};", 10220 Tab)); 10221 10222 EXPECT_EQ("void a(){\n" 10223 " // line starts with '\t'\n" 10224 "};", 10225 format("void a(){\n" 10226 "\t\t// line starts with '\t'\n" 10227 "};", 10228 Tab)); 10229 10230 Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation; 10231 EXPECT_EQ("void a(){\n" 10232 " // line starts with '\t'\n" 10233 "};", 10234 format("void a(){\n" 10235 "\t// line starts with '\t'\n" 10236 "};", 10237 Tab)); 10238 10239 EXPECT_EQ("void a(){\n" 10240 " // line starts with '\t'\n" 10241 "};", 10242 format("void a(){\n" 10243 "\t\t// line starts with '\t'\n" 10244 "};", 10245 Tab)); 10246 10247 Tab.UseTab = FormatStyle::UT_Always; 10248 EXPECT_EQ("void a(){\n" 10249 "// line starts with '\t'\n" 10250 "};", 10251 format("void a(){\n" 10252 "\t// line starts with '\t'\n" 10253 "};", 10254 Tab)); 10255 10256 EXPECT_EQ("void a(){\n" 10257 "// line starts with '\t'\n" 10258 "};", 10259 format("void a(){\n" 10260 "\t\t// line starts with '\t'\n" 10261 "};", 10262 Tab)); 10263 } 10264 10265 TEST_F(FormatTest, CalculatesOriginalColumn) { 10266 EXPECT_EQ("\"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 10267 "q\"; /* some\n" 10268 " comment */", 10269 format(" \"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 10270 "q\"; /* some\n" 10271 " comment */", 10272 getLLVMStyle())); 10273 EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n" 10274 "/* some\n" 10275 " comment */", 10276 format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n" 10277 " /* some\n" 10278 " comment */", 10279 getLLVMStyle())); 10280 EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 10281 "qqq\n" 10282 "/* some\n" 10283 " comment */", 10284 format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 10285 "qqq\n" 10286 " /* some\n" 10287 " comment */", 10288 getLLVMStyle())); 10289 EXPECT_EQ("inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 10290 "wwww; /* some\n" 10291 " comment */", 10292 format(" inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 10293 "wwww; /* some\n" 10294 " comment */", 10295 getLLVMStyle())); 10296 } 10297 10298 TEST_F(FormatTest, ConfigurableSpaceBeforeParens) { 10299 FormatStyle NoSpace = getLLVMStyle(); 10300 NoSpace.SpaceBeforeParens = FormatStyle::SBPO_Never; 10301 10302 verifyFormat("while(true)\n" 10303 " continue;", 10304 NoSpace); 10305 verifyFormat("for(;;)\n" 10306 " continue;", 10307 NoSpace); 10308 verifyFormat("if(true)\n" 10309 " f();\n" 10310 "else if(true)\n" 10311 " f();", 10312 NoSpace); 10313 verifyFormat("do {\n" 10314 " do_something();\n" 10315 "} while(something());", 10316 NoSpace); 10317 verifyFormat("switch(x) {\n" 10318 "default:\n" 10319 " break;\n" 10320 "}", 10321 NoSpace); 10322 verifyFormat("auto i = std::make_unique<int>(5);", NoSpace); 10323 verifyFormat("size_t x = sizeof(x);", NoSpace); 10324 verifyFormat("auto f(int x) -> decltype(x);", NoSpace); 10325 verifyFormat("int f(T x) noexcept(x.create());", NoSpace); 10326 verifyFormat("alignas(128) char a[128];", NoSpace); 10327 verifyFormat("size_t x = alignof(MyType);", NoSpace); 10328 verifyFormat("static_assert(sizeof(char) == 1, \"Impossible!\");", NoSpace); 10329 verifyFormat("int f() throw(Deprecated);", NoSpace); 10330 verifyFormat("typedef void (*cb)(int);", NoSpace); 10331 verifyFormat("T A::operator()();", NoSpace); 10332 verifyFormat("X A::operator++(T);", NoSpace); 10333 verifyFormat("auto lambda = []() { return 0; };", NoSpace); 10334 10335 FormatStyle Space = getLLVMStyle(); 10336 Space.SpaceBeforeParens = FormatStyle::SBPO_Always; 10337 10338 verifyFormat("int f ();", Space); 10339 verifyFormat("void f (int a, T b) {\n" 10340 " while (true)\n" 10341 " continue;\n" 10342 "}", 10343 Space); 10344 verifyFormat("if (true)\n" 10345 " f ();\n" 10346 "else if (true)\n" 10347 " f ();", 10348 Space); 10349 verifyFormat("do {\n" 10350 " do_something ();\n" 10351 "} while (something ());", 10352 Space); 10353 verifyFormat("switch (x) {\n" 10354 "default:\n" 10355 " break;\n" 10356 "}", 10357 Space); 10358 verifyFormat("A::A () : a (1) {}", Space); 10359 verifyFormat("void f () __attribute__ ((asdf));", Space); 10360 verifyFormat("*(&a + 1);\n" 10361 "&((&a)[1]);\n" 10362 "a[(b + c) * d];\n" 10363 "(((a + 1) * 2) + 3) * 4;", 10364 Space); 10365 verifyFormat("#define A(x) x", Space); 10366 verifyFormat("#define A (x) x", Space); 10367 verifyFormat("#if defined(x)\n" 10368 "#endif", 10369 Space); 10370 verifyFormat("auto i = std::make_unique<int> (5);", Space); 10371 verifyFormat("size_t x = sizeof (x);", Space); 10372 verifyFormat("auto f (int x) -> decltype (x);", Space); 10373 verifyFormat("int f (T x) noexcept (x.create ());", Space); 10374 verifyFormat("alignas (128) char a[128];", Space); 10375 verifyFormat("size_t x = alignof (MyType);", Space); 10376 verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");", Space); 10377 verifyFormat("int f () throw (Deprecated);", Space); 10378 verifyFormat("typedef void (*cb) (int);", Space); 10379 verifyFormat("T A::operator() ();", Space); 10380 verifyFormat("X A::operator++ (T);", Space); 10381 verifyFormat("auto lambda = [] () { return 0; };", Space); 10382 verifyFormat("int x = int (y);", Space); 10383 10384 FormatStyle SomeSpace = getLLVMStyle(); 10385 SomeSpace.SpaceBeforeParens = FormatStyle::SBPO_NonEmptyParentheses; 10386 10387 verifyFormat("[]() -> float {}", SomeSpace); 10388 verifyFormat("[] (auto foo) {}", SomeSpace); 10389 verifyFormat("[foo]() -> int {}", SomeSpace); 10390 verifyFormat("int f();", SomeSpace); 10391 verifyFormat("void f (int a, T b) {\n" 10392 " while (true)\n" 10393 " continue;\n" 10394 "}", 10395 SomeSpace); 10396 verifyFormat("if (true)\n" 10397 " f();\n" 10398 "else if (true)\n" 10399 " f();", 10400 SomeSpace); 10401 verifyFormat("do {\n" 10402 " do_something();\n" 10403 "} while (something());", 10404 SomeSpace); 10405 verifyFormat("switch (x) {\n" 10406 "default:\n" 10407 " break;\n" 10408 "}", 10409 SomeSpace); 10410 verifyFormat("A::A() : a (1) {}", SomeSpace); 10411 verifyFormat("void f() __attribute__ ((asdf));", SomeSpace); 10412 verifyFormat("*(&a + 1);\n" 10413 "&((&a)[1]);\n" 10414 "a[(b + c) * d];\n" 10415 "(((a + 1) * 2) + 3) * 4;", 10416 SomeSpace); 10417 verifyFormat("#define A(x) x", SomeSpace); 10418 verifyFormat("#define A (x) x", SomeSpace); 10419 verifyFormat("#if defined(x)\n" 10420 "#endif", 10421 SomeSpace); 10422 verifyFormat("auto i = std::make_unique<int> (5);", SomeSpace); 10423 verifyFormat("size_t x = sizeof (x);", SomeSpace); 10424 verifyFormat("auto f (int x) -> decltype (x);", SomeSpace); 10425 verifyFormat("int f (T x) noexcept (x.create());", SomeSpace); 10426 verifyFormat("alignas (128) char a[128];", SomeSpace); 10427 verifyFormat("size_t x = alignof (MyType);", SomeSpace); 10428 verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");", 10429 SomeSpace); 10430 verifyFormat("int f() throw (Deprecated);", SomeSpace); 10431 verifyFormat("typedef void (*cb) (int);", SomeSpace); 10432 verifyFormat("T A::operator()();", SomeSpace); 10433 verifyFormat("X A::operator++ (T);", SomeSpace); 10434 verifyFormat("int x = int (y);", SomeSpace); 10435 verifyFormat("auto lambda = []() { return 0; };", SomeSpace); 10436 } 10437 10438 TEST_F(FormatTest, SpaceAfterLogicalNot) { 10439 FormatStyle Spaces = getLLVMStyle(); 10440 Spaces.SpaceAfterLogicalNot = true; 10441 10442 verifyFormat("bool x = ! y", Spaces); 10443 verifyFormat("if (! isFailure())", Spaces); 10444 verifyFormat("if (! (a && b))", Spaces); 10445 verifyFormat("\"Error!\"", Spaces); 10446 verifyFormat("! ! x", Spaces); 10447 } 10448 10449 TEST_F(FormatTest, ConfigurableSpacesInParentheses) { 10450 FormatStyle Spaces = getLLVMStyle(); 10451 10452 Spaces.SpacesInParentheses = true; 10453 verifyFormat("do_something( ::globalVar );", Spaces); 10454 verifyFormat("call( x, y, z );", Spaces); 10455 verifyFormat("call();", Spaces); 10456 verifyFormat("std::function<void( int, int )> callback;", Spaces); 10457 verifyFormat("void inFunction() { std::function<void( int, int )> fct; }", 10458 Spaces); 10459 verifyFormat("while ( (bool)1 )\n" 10460 " continue;", 10461 Spaces); 10462 verifyFormat("for ( ;; )\n" 10463 " continue;", 10464 Spaces); 10465 verifyFormat("if ( true )\n" 10466 " f();\n" 10467 "else if ( true )\n" 10468 " f();", 10469 Spaces); 10470 verifyFormat("do {\n" 10471 " do_something( (int)i );\n" 10472 "} while ( something() );", 10473 Spaces); 10474 verifyFormat("switch ( x ) {\n" 10475 "default:\n" 10476 " break;\n" 10477 "}", 10478 Spaces); 10479 10480 Spaces.SpacesInParentheses = false; 10481 Spaces.SpacesInCStyleCastParentheses = true; 10482 verifyFormat("Type *A = ( Type * )P;", Spaces); 10483 verifyFormat("Type *A = ( vector<Type *, int *> )P;", Spaces); 10484 verifyFormat("x = ( int32 )y;", Spaces); 10485 verifyFormat("int a = ( int )(2.0f);", Spaces); 10486 verifyFormat("#define AA(X) sizeof((( X * )NULL)->a)", Spaces); 10487 verifyFormat("my_int a = ( my_int )sizeof(int);", Spaces); 10488 verifyFormat("#define x (( int )-1)", Spaces); 10489 10490 // Run the first set of tests again with: 10491 Spaces.SpacesInParentheses = false; 10492 Spaces.SpaceInEmptyParentheses = true; 10493 Spaces.SpacesInCStyleCastParentheses = true; 10494 verifyFormat("call(x, y, z);", Spaces); 10495 verifyFormat("call( );", Spaces); 10496 verifyFormat("std::function<void(int, int)> callback;", Spaces); 10497 verifyFormat("while (( bool )1)\n" 10498 " continue;", 10499 Spaces); 10500 verifyFormat("for (;;)\n" 10501 " continue;", 10502 Spaces); 10503 verifyFormat("if (true)\n" 10504 " f( );\n" 10505 "else if (true)\n" 10506 " f( );", 10507 Spaces); 10508 verifyFormat("do {\n" 10509 " do_something(( int )i);\n" 10510 "} while (something( ));", 10511 Spaces); 10512 verifyFormat("switch (x) {\n" 10513 "default:\n" 10514 " break;\n" 10515 "}", 10516 Spaces); 10517 10518 // Run the first set of tests again with: 10519 Spaces.SpaceAfterCStyleCast = true; 10520 verifyFormat("call(x, y, z);", Spaces); 10521 verifyFormat("call( );", Spaces); 10522 verifyFormat("std::function<void(int, int)> callback;", Spaces); 10523 verifyFormat("while (( bool ) 1)\n" 10524 " continue;", 10525 Spaces); 10526 verifyFormat("for (;;)\n" 10527 " continue;", 10528 Spaces); 10529 verifyFormat("if (true)\n" 10530 " f( );\n" 10531 "else if (true)\n" 10532 " f( );", 10533 Spaces); 10534 verifyFormat("do {\n" 10535 " do_something(( int ) i);\n" 10536 "} while (something( ));", 10537 Spaces); 10538 verifyFormat("switch (x) {\n" 10539 "default:\n" 10540 " break;\n" 10541 "}", 10542 Spaces); 10543 10544 // Run subset of tests again with: 10545 Spaces.SpacesInCStyleCastParentheses = false; 10546 Spaces.SpaceAfterCStyleCast = true; 10547 verifyFormat("while ((bool) 1)\n" 10548 " continue;", 10549 Spaces); 10550 verifyFormat("do {\n" 10551 " do_something((int) i);\n" 10552 "} while (something( ));", 10553 Spaces); 10554 } 10555 10556 TEST_F(FormatTest, ConfigurableSpacesInSquareBrackets) { 10557 verifyFormat("int a[5];"); 10558 verifyFormat("a[3] += 42;"); 10559 10560 FormatStyle Spaces = getLLVMStyle(); 10561 Spaces.SpacesInSquareBrackets = true; 10562 // Not lambdas. 10563 verifyFormat("int a[ 5 ];", Spaces); 10564 verifyFormat("a[ 3 ] += 42;", Spaces); 10565 verifyFormat("constexpr char hello[]{\"hello\"};", Spaces); 10566 verifyFormat("double &operator[](int i) { return 0; }\n" 10567 "int i;", 10568 Spaces); 10569 verifyFormat("std::unique_ptr<int[]> foo() {}", Spaces); 10570 verifyFormat("int i = a[ a ][ a ]->f();", Spaces); 10571 verifyFormat("int i = (*b)[ a ]->f();", Spaces); 10572 // Lambdas. 10573 verifyFormat("int c = []() -> int { return 2; }();\n", Spaces); 10574 verifyFormat("return [ i, args... ] {};", Spaces); 10575 } 10576 10577 TEST_F(FormatTest, ConfigurableSpaceBeforeAssignmentOperators) { 10578 verifyFormat("int a = 5;"); 10579 verifyFormat("a += 42;"); 10580 verifyFormat("a or_eq 8;"); 10581 10582 FormatStyle Spaces = getLLVMStyle(); 10583 Spaces.SpaceBeforeAssignmentOperators = false; 10584 verifyFormat("int a= 5;", Spaces); 10585 verifyFormat("a+= 42;", Spaces); 10586 verifyFormat("a or_eq 8;", Spaces); 10587 } 10588 10589 TEST_F(FormatTest, ConfigurableSpaceBeforeColon) { 10590 verifyFormat("class Foo : public Bar {};"); 10591 verifyFormat("Foo::Foo() : foo(1) {}"); 10592 verifyFormat("for (auto a : b) {\n}"); 10593 verifyFormat("int x = a ? b : c;"); 10594 verifyFormat("{\n" 10595 "label0:\n" 10596 " int x = 0;\n" 10597 "}"); 10598 verifyFormat("switch (x) {\n" 10599 "case 1:\n" 10600 "default:\n" 10601 "}"); 10602 10603 FormatStyle CtorInitializerStyle = getLLVMStyleWithColumns(30); 10604 CtorInitializerStyle.SpaceBeforeCtorInitializerColon = false; 10605 verifyFormat("class Foo : public Bar {};", CtorInitializerStyle); 10606 verifyFormat("Foo::Foo(): foo(1) {}", CtorInitializerStyle); 10607 verifyFormat("for (auto a : b) {\n}", CtorInitializerStyle); 10608 verifyFormat("int x = a ? b : c;", CtorInitializerStyle); 10609 verifyFormat("{\n" 10610 "label1:\n" 10611 " int x = 0;\n" 10612 "}", 10613 CtorInitializerStyle); 10614 verifyFormat("switch (x) {\n" 10615 "case 1:\n" 10616 "default:\n" 10617 "}", 10618 CtorInitializerStyle); 10619 CtorInitializerStyle.BreakConstructorInitializers = 10620 FormatStyle::BCIS_AfterColon; 10621 verifyFormat("Fooooooooooo::Fooooooooooo():\n" 10622 " aaaaaaaaaaaaaaaa(1),\n" 10623 " bbbbbbbbbbbbbbbb(2) {}", 10624 CtorInitializerStyle); 10625 CtorInitializerStyle.BreakConstructorInitializers = 10626 FormatStyle::BCIS_BeforeComma; 10627 verifyFormat("Fooooooooooo::Fooooooooooo()\n" 10628 " : aaaaaaaaaaaaaaaa(1)\n" 10629 " , bbbbbbbbbbbbbbbb(2) {}", 10630 CtorInitializerStyle); 10631 CtorInitializerStyle.BreakConstructorInitializers = 10632 FormatStyle::BCIS_BeforeColon; 10633 verifyFormat("Fooooooooooo::Fooooooooooo()\n" 10634 " : aaaaaaaaaaaaaaaa(1),\n" 10635 " bbbbbbbbbbbbbbbb(2) {}", 10636 CtorInitializerStyle); 10637 CtorInitializerStyle.ConstructorInitializerIndentWidth = 0; 10638 verifyFormat("Fooooooooooo::Fooooooooooo()\n" 10639 ": aaaaaaaaaaaaaaaa(1),\n" 10640 " bbbbbbbbbbbbbbbb(2) {}", 10641 CtorInitializerStyle); 10642 10643 FormatStyle InheritanceStyle = getLLVMStyleWithColumns(30); 10644 InheritanceStyle.SpaceBeforeInheritanceColon = false; 10645 verifyFormat("class Foo: public Bar {};", InheritanceStyle); 10646 verifyFormat("Foo::Foo() : foo(1) {}", InheritanceStyle); 10647 verifyFormat("for (auto a : b) {\n}", InheritanceStyle); 10648 verifyFormat("int x = a ? b : c;", InheritanceStyle); 10649 verifyFormat("{\n" 10650 "label2:\n" 10651 " int x = 0;\n" 10652 "}", 10653 InheritanceStyle); 10654 verifyFormat("switch (x) {\n" 10655 "case 1:\n" 10656 "default:\n" 10657 "}", 10658 InheritanceStyle); 10659 InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_AfterColon; 10660 verifyFormat("class Foooooooooooooooooooooo:\n" 10661 " public aaaaaaaaaaaaaaaaaa,\n" 10662 " public bbbbbbbbbbbbbbbbbb {\n" 10663 "}", 10664 InheritanceStyle); 10665 InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeComma; 10666 verifyFormat("class Foooooooooooooooooooooo\n" 10667 " : public aaaaaaaaaaaaaaaaaa\n" 10668 " , public bbbbbbbbbbbbbbbbbb {\n" 10669 "}", 10670 InheritanceStyle); 10671 InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeColon; 10672 verifyFormat("class Foooooooooooooooooooooo\n" 10673 " : public aaaaaaaaaaaaaaaaaa,\n" 10674 " public bbbbbbbbbbbbbbbbbb {\n" 10675 "}", 10676 InheritanceStyle); 10677 InheritanceStyle.ConstructorInitializerIndentWidth = 0; 10678 verifyFormat("class Foooooooooooooooooooooo\n" 10679 ": public aaaaaaaaaaaaaaaaaa,\n" 10680 " public bbbbbbbbbbbbbbbbbb {}", 10681 InheritanceStyle); 10682 10683 FormatStyle ForLoopStyle = getLLVMStyle(); 10684 ForLoopStyle.SpaceBeforeRangeBasedForLoopColon = false; 10685 verifyFormat("class Foo : public Bar {};", ForLoopStyle); 10686 verifyFormat("Foo::Foo() : foo(1) {}", ForLoopStyle); 10687 verifyFormat("for (auto a: b) {\n}", ForLoopStyle); 10688 verifyFormat("int x = a ? b : c;", ForLoopStyle); 10689 verifyFormat("{\n" 10690 "label2:\n" 10691 " int x = 0;\n" 10692 "}", 10693 ForLoopStyle); 10694 verifyFormat("switch (x) {\n" 10695 "case 1:\n" 10696 "default:\n" 10697 "}", 10698 ForLoopStyle); 10699 10700 FormatStyle NoSpaceStyle = getLLVMStyle(); 10701 NoSpaceStyle.SpaceBeforeCtorInitializerColon = false; 10702 NoSpaceStyle.SpaceBeforeInheritanceColon = false; 10703 NoSpaceStyle.SpaceBeforeRangeBasedForLoopColon = false; 10704 verifyFormat("class Foo: public Bar {};", NoSpaceStyle); 10705 verifyFormat("Foo::Foo(): foo(1) {}", NoSpaceStyle); 10706 verifyFormat("for (auto a: b) {\n}", NoSpaceStyle); 10707 verifyFormat("int x = a ? b : c;", NoSpaceStyle); 10708 verifyFormat("{\n" 10709 "label3:\n" 10710 " int x = 0;\n" 10711 "}", 10712 NoSpaceStyle); 10713 verifyFormat("switch (x) {\n" 10714 "case 1:\n" 10715 "default:\n" 10716 "}", 10717 NoSpaceStyle); 10718 } 10719 10720 TEST_F(FormatTest, AlignConsecutiveMacros) { 10721 FormatStyle Style = getLLVMStyle(); 10722 Style.AlignConsecutiveAssignments = true; 10723 Style.AlignConsecutiveDeclarations = true; 10724 Style.AlignConsecutiveMacros = false; 10725 10726 verifyFormat("#define a 3\n" 10727 "#define bbbb 4\n" 10728 "#define ccc (5)", 10729 Style); 10730 10731 verifyFormat("#define f(x) (x * x)\n" 10732 "#define fff(x, y, z) (x * y + z)\n" 10733 "#define ffff(x, y) (x - y)", 10734 Style); 10735 10736 verifyFormat("#define foo(x, y) (x + y)\n" 10737 "#define bar (5, 6)(2 + 2)", 10738 Style); 10739 10740 verifyFormat("#define a 3\n" 10741 "#define bbbb 4\n" 10742 "#define ccc (5)\n" 10743 "#define f(x) (x * x)\n" 10744 "#define fff(x, y, z) (x * y + z)\n" 10745 "#define ffff(x, y) (x - y)", 10746 Style); 10747 10748 Style.AlignConsecutiveMacros = true; 10749 verifyFormat("#define a 3\n" 10750 "#define bbbb 4\n" 10751 "#define ccc (5)", 10752 Style); 10753 10754 verifyFormat("#define f(x) (x * x)\n" 10755 "#define fff(x, y, z) (x * y + z)\n" 10756 "#define ffff(x, y) (x - y)", 10757 Style); 10758 10759 verifyFormat("#define foo(x, y) (x + y)\n" 10760 "#define bar (5, 6)(2 + 2)", 10761 Style); 10762 10763 verifyFormat("#define a 3\n" 10764 "#define bbbb 4\n" 10765 "#define ccc (5)\n" 10766 "#define f(x) (x * x)\n" 10767 "#define fff(x, y, z) (x * y + z)\n" 10768 "#define ffff(x, y) (x - y)", 10769 Style); 10770 10771 verifyFormat("#define a 5\n" 10772 "#define foo(x, y) (x + y)\n" 10773 "#define CCC (6)\n" 10774 "auto lambda = []() {\n" 10775 " auto ii = 0;\n" 10776 " float j = 0;\n" 10777 " return 0;\n" 10778 "};\n" 10779 "int i = 0;\n" 10780 "float i2 = 0;\n" 10781 "auto v = type{\n" 10782 " i = 1, //\n" 10783 " (i = 2), //\n" 10784 " i = 3 //\n" 10785 "};", 10786 Style); 10787 10788 Style.AlignConsecutiveMacros = false; 10789 Style.ColumnLimit = 20; 10790 10791 verifyFormat("#define a \\\n" 10792 " \"aabbbbbbbbbbbb\"\n" 10793 "#define D \\\n" 10794 " \"aabbbbbbbbbbbb\" \\\n" 10795 " \"ccddeeeeeeeee\"\n" 10796 "#define B \\\n" 10797 " \"QQQQQQQQQQQQQ\" \\\n" 10798 " \"FFFFFFFFFFFFF\" \\\n" 10799 " \"LLLLLLLL\"\n", 10800 Style); 10801 10802 Style.AlignConsecutiveMacros = true; 10803 verifyFormat("#define a \\\n" 10804 " \"aabbbbbbbbbbbb\"\n" 10805 "#define D \\\n" 10806 " \"aabbbbbbbbbbbb\" \\\n" 10807 " \"ccddeeeeeeeee\"\n" 10808 "#define B \\\n" 10809 " \"QQQQQQQQQQQQQ\" \\\n" 10810 " \"FFFFFFFFFFFFF\" \\\n" 10811 " \"LLLLLLLL\"\n", 10812 Style); 10813 } 10814 10815 TEST_F(FormatTest, AlignConsecutiveAssignments) { 10816 FormatStyle Alignment = getLLVMStyle(); 10817 Alignment.AlignConsecutiveMacros = true; 10818 Alignment.AlignConsecutiveAssignments = false; 10819 verifyFormat("int a = 5;\n" 10820 "int oneTwoThree = 123;", 10821 Alignment); 10822 verifyFormat("int a = 5;\n" 10823 "int oneTwoThree = 123;", 10824 Alignment); 10825 10826 Alignment.AlignConsecutiveAssignments = true; 10827 verifyFormat("int a = 5;\n" 10828 "int oneTwoThree = 123;", 10829 Alignment); 10830 verifyFormat("int a = method();\n" 10831 "int oneTwoThree = 133;", 10832 Alignment); 10833 verifyFormat("a &= 5;\n" 10834 "bcd *= 5;\n" 10835 "ghtyf += 5;\n" 10836 "dvfvdb -= 5;\n" 10837 "a /= 5;\n" 10838 "vdsvsv %= 5;\n" 10839 "sfdbddfbdfbb ^= 5;\n" 10840 "dvsdsv |= 5;\n" 10841 "int dsvvdvsdvvv = 123;", 10842 Alignment); 10843 verifyFormat("int i = 1, j = 10;\n" 10844 "something = 2000;", 10845 Alignment); 10846 verifyFormat("something = 2000;\n" 10847 "int i = 1, j = 10;\n", 10848 Alignment); 10849 verifyFormat("something = 2000;\n" 10850 "another = 911;\n" 10851 "int i = 1, j = 10;\n" 10852 "oneMore = 1;\n" 10853 "i = 2;", 10854 Alignment); 10855 verifyFormat("int a = 5;\n" 10856 "int one = 1;\n" 10857 "method();\n" 10858 "int oneTwoThree = 123;\n" 10859 "int oneTwo = 12;", 10860 Alignment); 10861 verifyFormat("int oneTwoThree = 123;\n" 10862 "int oneTwo = 12;\n" 10863 "method();\n", 10864 Alignment); 10865 verifyFormat("int oneTwoThree = 123; // comment\n" 10866 "int oneTwo = 12; // comment", 10867 Alignment); 10868 EXPECT_EQ("int a = 5;\n" 10869 "\n" 10870 "int oneTwoThree = 123;", 10871 format("int a = 5;\n" 10872 "\n" 10873 "int oneTwoThree= 123;", 10874 Alignment)); 10875 EXPECT_EQ("int a = 5;\n" 10876 "int one = 1;\n" 10877 "\n" 10878 "int oneTwoThree = 123;", 10879 format("int a = 5;\n" 10880 "int one = 1;\n" 10881 "\n" 10882 "int oneTwoThree = 123;", 10883 Alignment)); 10884 EXPECT_EQ("int a = 5;\n" 10885 "int one = 1;\n" 10886 "\n" 10887 "int oneTwoThree = 123;\n" 10888 "int oneTwo = 12;", 10889 format("int a = 5;\n" 10890 "int one = 1;\n" 10891 "\n" 10892 "int oneTwoThree = 123;\n" 10893 "int oneTwo = 12;", 10894 Alignment)); 10895 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign; 10896 verifyFormat("#define A \\\n" 10897 " int aaaa = 12; \\\n" 10898 " int b = 23; \\\n" 10899 " int ccc = 234; \\\n" 10900 " int dddddddddd = 2345;", 10901 Alignment); 10902 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left; 10903 verifyFormat("#define A \\\n" 10904 " int aaaa = 12; \\\n" 10905 " int b = 23; \\\n" 10906 " int ccc = 234; \\\n" 10907 " int dddddddddd = 2345;", 10908 Alignment); 10909 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right; 10910 verifyFormat("#define A " 10911 " \\\n" 10912 " int aaaa = 12; " 10913 " \\\n" 10914 " int b = 23; " 10915 " \\\n" 10916 " int ccc = 234; " 10917 " \\\n" 10918 " int dddddddddd = 2345;", 10919 Alignment); 10920 verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int " 10921 "k = 4, int l = 5,\n" 10922 " int m = 6) {\n" 10923 " int j = 10;\n" 10924 " otherThing = 1;\n" 10925 "}", 10926 Alignment); 10927 verifyFormat("void SomeFunction(int parameter = 0) {\n" 10928 " int i = 1;\n" 10929 " int j = 2;\n" 10930 " int big = 10000;\n" 10931 "}", 10932 Alignment); 10933 verifyFormat("class C {\n" 10934 "public:\n" 10935 " int i = 1;\n" 10936 " virtual void f() = 0;\n" 10937 "};", 10938 Alignment); 10939 verifyFormat("int i = 1;\n" 10940 "if (SomeType t = getSomething()) {\n" 10941 "}\n" 10942 "int j = 2;\n" 10943 "int big = 10000;", 10944 Alignment); 10945 verifyFormat("int j = 7;\n" 10946 "for (int k = 0; k < N; ++k) {\n" 10947 "}\n" 10948 "int j = 2;\n" 10949 "int big = 10000;\n" 10950 "}", 10951 Alignment); 10952 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 10953 verifyFormat("int i = 1;\n" 10954 "LooooooooooongType loooooooooooooooooooooongVariable\n" 10955 " = someLooooooooooooooooongFunction();\n" 10956 "int j = 2;", 10957 Alignment); 10958 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 10959 verifyFormat("int i = 1;\n" 10960 "LooooooooooongType loooooooooooooooooooooongVariable =\n" 10961 " someLooooooooooooooooongFunction();\n" 10962 "int j = 2;", 10963 Alignment); 10964 10965 verifyFormat("auto lambda = []() {\n" 10966 " auto i = 0;\n" 10967 " return 0;\n" 10968 "};\n" 10969 "int i = 0;\n" 10970 "auto v = type{\n" 10971 " i = 1, //\n" 10972 " (i = 2), //\n" 10973 " i = 3 //\n" 10974 "};", 10975 Alignment); 10976 10977 verifyFormat( 10978 "int i = 1;\n" 10979 "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n" 10980 " loooooooooooooooooooooongParameterB);\n" 10981 "int j = 2;", 10982 Alignment); 10983 10984 verifyFormat("template <typename T, typename T_0 = very_long_type_name_0,\n" 10985 " typename B = very_long_type_name_1,\n" 10986 " typename T_2 = very_long_type_name_2>\n" 10987 "auto foo() {}\n", 10988 Alignment); 10989 verifyFormat("int a, b = 1;\n" 10990 "int c = 2;\n" 10991 "int dd = 3;\n", 10992 Alignment); 10993 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n" 10994 "float b[1][] = {{3.f}};\n", 10995 Alignment); 10996 verifyFormat("for (int i = 0; i < 1; i++)\n" 10997 " int x = 1;\n", 10998 Alignment); 10999 verifyFormat("for (i = 0; i < 1; i++)\n" 11000 " x = 1;\n" 11001 "y = 1;\n", 11002 Alignment); 11003 } 11004 11005 TEST_F(FormatTest, AlignConsecutiveDeclarations) { 11006 FormatStyle Alignment = getLLVMStyle(); 11007 Alignment.AlignConsecutiveMacros = true; 11008 Alignment.AlignConsecutiveDeclarations = false; 11009 verifyFormat("float const a = 5;\n" 11010 "int oneTwoThree = 123;", 11011 Alignment); 11012 verifyFormat("int a = 5;\n" 11013 "float const oneTwoThree = 123;", 11014 Alignment); 11015 11016 Alignment.AlignConsecutiveDeclarations = true; 11017 verifyFormat("float const a = 5;\n" 11018 "int oneTwoThree = 123;", 11019 Alignment); 11020 verifyFormat("int a = method();\n" 11021 "float const oneTwoThree = 133;", 11022 Alignment); 11023 verifyFormat("int i = 1, j = 10;\n" 11024 "something = 2000;", 11025 Alignment); 11026 verifyFormat("something = 2000;\n" 11027 "int i = 1, j = 10;\n", 11028 Alignment); 11029 verifyFormat("float something = 2000;\n" 11030 "double another = 911;\n" 11031 "int i = 1, j = 10;\n" 11032 "const int *oneMore = 1;\n" 11033 "unsigned i = 2;", 11034 Alignment); 11035 verifyFormat("float a = 5;\n" 11036 "int one = 1;\n" 11037 "method();\n" 11038 "const double oneTwoThree = 123;\n" 11039 "const unsigned int oneTwo = 12;", 11040 Alignment); 11041 verifyFormat("int oneTwoThree{0}; // comment\n" 11042 "unsigned oneTwo; // comment", 11043 Alignment); 11044 EXPECT_EQ("float const a = 5;\n" 11045 "\n" 11046 "int oneTwoThree = 123;", 11047 format("float const a = 5;\n" 11048 "\n" 11049 "int oneTwoThree= 123;", 11050 Alignment)); 11051 EXPECT_EQ("float a = 5;\n" 11052 "int one = 1;\n" 11053 "\n" 11054 "unsigned oneTwoThree = 123;", 11055 format("float a = 5;\n" 11056 "int one = 1;\n" 11057 "\n" 11058 "unsigned oneTwoThree = 123;", 11059 Alignment)); 11060 EXPECT_EQ("float a = 5;\n" 11061 "int one = 1;\n" 11062 "\n" 11063 "unsigned oneTwoThree = 123;\n" 11064 "int oneTwo = 12;", 11065 format("float a = 5;\n" 11066 "int one = 1;\n" 11067 "\n" 11068 "unsigned oneTwoThree = 123;\n" 11069 "int oneTwo = 12;", 11070 Alignment)); 11071 // Function prototype alignment 11072 verifyFormat("int a();\n" 11073 "double b();", 11074 Alignment); 11075 verifyFormat("int a(int x);\n" 11076 "double b();", 11077 Alignment); 11078 unsigned OldColumnLimit = Alignment.ColumnLimit; 11079 // We need to set ColumnLimit to zero, in order to stress nested alignments, 11080 // otherwise the function parameters will be re-flowed onto a single line. 11081 Alignment.ColumnLimit = 0; 11082 EXPECT_EQ("int a(int x,\n" 11083 " float y);\n" 11084 "double b(int x,\n" 11085 " double y);", 11086 format("int a(int x,\n" 11087 " float y);\n" 11088 "double b(int x,\n" 11089 " double y);", 11090 Alignment)); 11091 // This ensures that function parameters of function declarations are 11092 // correctly indented when their owning functions are indented. 11093 // The failure case here is for 'double y' to not be indented enough. 11094 EXPECT_EQ("double a(int x);\n" 11095 "int b(int y,\n" 11096 " double z);", 11097 format("double a(int x);\n" 11098 "int b(int y,\n" 11099 " double z);", 11100 Alignment)); 11101 // Set ColumnLimit low so that we induce wrapping immediately after 11102 // the function name and opening paren. 11103 Alignment.ColumnLimit = 13; 11104 verifyFormat("int function(\n" 11105 " int x,\n" 11106 " bool y);", 11107 Alignment); 11108 Alignment.ColumnLimit = OldColumnLimit; 11109 // Ensure function pointers don't screw up recursive alignment 11110 verifyFormat("int a(int x, void (*fp)(int y));\n" 11111 "double b();", 11112 Alignment); 11113 Alignment.AlignConsecutiveAssignments = true; 11114 // Ensure recursive alignment is broken by function braces, so that the 11115 // "a = 1" does not align with subsequent assignments inside the function 11116 // body. 11117 verifyFormat("int func(int a = 1) {\n" 11118 " int b = 2;\n" 11119 " int cc = 3;\n" 11120 "}", 11121 Alignment); 11122 verifyFormat("float something = 2000;\n" 11123 "double another = 911;\n" 11124 "int i = 1, j = 10;\n" 11125 "const int *oneMore = 1;\n" 11126 "unsigned i = 2;", 11127 Alignment); 11128 verifyFormat("int oneTwoThree = {0}; // comment\n" 11129 "unsigned oneTwo = 0; // comment", 11130 Alignment); 11131 // Make sure that scope is correctly tracked, in the absence of braces 11132 verifyFormat("for (int i = 0; i < n; i++)\n" 11133 " j = i;\n" 11134 "double x = 1;\n", 11135 Alignment); 11136 verifyFormat("if (int i = 0)\n" 11137 " j = i;\n" 11138 "double x = 1;\n", 11139 Alignment); 11140 // Ensure operator[] and operator() are comprehended 11141 verifyFormat("struct test {\n" 11142 " long long int foo();\n" 11143 " int operator[](int a);\n" 11144 " double bar();\n" 11145 "};\n", 11146 Alignment); 11147 verifyFormat("struct test {\n" 11148 " long long int foo();\n" 11149 " int operator()(int a);\n" 11150 " double bar();\n" 11151 "};\n", 11152 Alignment); 11153 EXPECT_EQ("void SomeFunction(int parameter = 0) {\n" 11154 " int const i = 1;\n" 11155 " int * j = 2;\n" 11156 " int big = 10000;\n" 11157 "\n" 11158 " unsigned oneTwoThree = 123;\n" 11159 " int oneTwo = 12;\n" 11160 " method();\n" 11161 " float k = 2;\n" 11162 " int ll = 10000;\n" 11163 "}", 11164 format("void SomeFunction(int parameter= 0) {\n" 11165 " int const i= 1;\n" 11166 " int *j=2;\n" 11167 " int big = 10000;\n" 11168 "\n" 11169 "unsigned oneTwoThree =123;\n" 11170 "int oneTwo = 12;\n" 11171 " method();\n" 11172 "float k= 2;\n" 11173 "int ll=10000;\n" 11174 "}", 11175 Alignment)); 11176 Alignment.AlignConsecutiveAssignments = false; 11177 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign; 11178 verifyFormat("#define A \\\n" 11179 " int aaaa = 12; \\\n" 11180 " float b = 23; \\\n" 11181 " const int ccc = 234; \\\n" 11182 " unsigned dddddddddd = 2345;", 11183 Alignment); 11184 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left; 11185 verifyFormat("#define A \\\n" 11186 " int aaaa = 12; \\\n" 11187 " float b = 23; \\\n" 11188 " const int ccc = 234; \\\n" 11189 " unsigned dddddddddd = 2345;", 11190 Alignment); 11191 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right; 11192 Alignment.ColumnLimit = 30; 11193 verifyFormat("#define A \\\n" 11194 " int aaaa = 12; \\\n" 11195 " float b = 23; \\\n" 11196 " const int ccc = 234; \\\n" 11197 " int dddddddddd = 2345;", 11198 Alignment); 11199 Alignment.ColumnLimit = 80; 11200 verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int " 11201 "k = 4, int l = 5,\n" 11202 " int m = 6) {\n" 11203 " const int j = 10;\n" 11204 " otherThing = 1;\n" 11205 "}", 11206 Alignment); 11207 verifyFormat("void SomeFunction(int parameter = 0) {\n" 11208 " int const i = 1;\n" 11209 " int * j = 2;\n" 11210 " int big = 10000;\n" 11211 "}", 11212 Alignment); 11213 verifyFormat("class C {\n" 11214 "public:\n" 11215 " int i = 1;\n" 11216 " virtual void f() = 0;\n" 11217 "};", 11218 Alignment); 11219 verifyFormat("float i = 1;\n" 11220 "if (SomeType t = getSomething()) {\n" 11221 "}\n" 11222 "const unsigned j = 2;\n" 11223 "int big = 10000;", 11224 Alignment); 11225 verifyFormat("float j = 7;\n" 11226 "for (int k = 0; k < N; ++k) {\n" 11227 "}\n" 11228 "unsigned j = 2;\n" 11229 "int big = 10000;\n" 11230 "}", 11231 Alignment); 11232 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 11233 verifyFormat("float i = 1;\n" 11234 "LooooooooooongType loooooooooooooooooooooongVariable\n" 11235 " = someLooooooooooooooooongFunction();\n" 11236 "int j = 2;", 11237 Alignment); 11238 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 11239 verifyFormat("int i = 1;\n" 11240 "LooooooooooongType loooooooooooooooooooooongVariable =\n" 11241 " someLooooooooooooooooongFunction();\n" 11242 "int j = 2;", 11243 Alignment); 11244 11245 Alignment.AlignConsecutiveAssignments = true; 11246 verifyFormat("auto lambda = []() {\n" 11247 " auto ii = 0;\n" 11248 " float j = 0;\n" 11249 " return 0;\n" 11250 "};\n" 11251 "int i = 0;\n" 11252 "float i2 = 0;\n" 11253 "auto v = type{\n" 11254 " i = 1, //\n" 11255 " (i = 2), //\n" 11256 " i = 3 //\n" 11257 "};", 11258 Alignment); 11259 Alignment.AlignConsecutiveAssignments = false; 11260 11261 verifyFormat( 11262 "int i = 1;\n" 11263 "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n" 11264 " loooooooooooooooooooooongParameterB);\n" 11265 "int j = 2;", 11266 Alignment); 11267 11268 // Test interactions with ColumnLimit and AlignConsecutiveAssignments: 11269 // We expect declarations and assignments to align, as long as it doesn't 11270 // exceed the column limit, starting a new alignment sequence whenever it 11271 // happens. 11272 Alignment.AlignConsecutiveAssignments = true; 11273 Alignment.ColumnLimit = 30; 11274 verifyFormat("float ii = 1;\n" 11275 "unsigned j = 2;\n" 11276 "int someVerylongVariable = 1;\n" 11277 "AnotherLongType ll = 123456;\n" 11278 "VeryVeryLongType k = 2;\n" 11279 "int myvar = 1;", 11280 Alignment); 11281 Alignment.ColumnLimit = 80; 11282 Alignment.AlignConsecutiveAssignments = false; 11283 11284 verifyFormat( 11285 "template <typename LongTemplate, typename VeryLongTemplateTypeName,\n" 11286 " typename LongType, typename B>\n" 11287 "auto foo() {}\n", 11288 Alignment); 11289 verifyFormat("float a, b = 1;\n" 11290 "int c = 2;\n" 11291 "int dd = 3;\n", 11292 Alignment); 11293 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n" 11294 "float b[1][] = {{3.f}};\n", 11295 Alignment); 11296 Alignment.AlignConsecutiveAssignments = true; 11297 verifyFormat("float a, b = 1;\n" 11298 "int c = 2;\n" 11299 "int dd = 3;\n", 11300 Alignment); 11301 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n" 11302 "float b[1][] = {{3.f}};\n", 11303 Alignment); 11304 Alignment.AlignConsecutiveAssignments = false; 11305 11306 Alignment.ColumnLimit = 30; 11307 Alignment.BinPackParameters = false; 11308 verifyFormat("void foo(float a,\n" 11309 " float b,\n" 11310 " int c,\n" 11311 " uint32_t *d) {\n" 11312 " int * e = 0;\n" 11313 " float f = 0;\n" 11314 " double g = 0;\n" 11315 "}\n" 11316 "void bar(ino_t a,\n" 11317 " int b,\n" 11318 " uint32_t *c,\n" 11319 " bool d) {}\n", 11320 Alignment); 11321 Alignment.BinPackParameters = true; 11322 Alignment.ColumnLimit = 80; 11323 11324 // Bug 33507 11325 Alignment.PointerAlignment = FormatStyle::PAS_Middle; 11326 verifyFormat( 11327 "auto found = range::find_if(vsProducts, [&](auto * aProduct) {\n" 11328 " static const Version verVs2017;\n" 11329 " return true;\n" 11330 "});\n", 11331 Alignment); 11332 Alignment.PointerAlignment = FormatStyle::PAS_Right; 11333 11334 // See llvm.org/PR35641 11335 Alignment.AlignConsecutiveDeclarations = true; 11336 verifyFormat("int func() { //\n" 11337 " int b;\n" 11338 " unsigned c;\n" 11339 "}", 11340 Alignment); 11341 11342 // See PR37175 11343 FormatStyle Style = getMozillaStyle(); 11344 Style.AlignConsecutiveDeclarations = true; 11345 EXPECT_EQ("DECOR1 /**/ int8_t /**/ DECOR2 /**/\n" 11346 "foo(int a);", 11347 format("DECOR1 /**/ int8_t /**/ DECOR2 /**/ foo (int a);", Style)); 11348 } 11349 11350 TEST_F(FormatTest, LinuxBraceBreaking) { 11351 FormatStyle LinuxBraceStyle = getLLVMStyle(); 11352 LinuxBraceStyle.BreakBeforeBraces = FormatStyle::BS_Linux; 11353 verifyFormat("namespace a\n" 11354 "{\n" 11355 "class A\n" 11356 "{\n" 11357 " void f()\n" 11358 " {\n" 11359 " if (true) {\n" 11360 " a();\n" 11361 " b();\n" 11362 " } else {\n" 11363 " a();\n" 11364 " }\n" 11365 " }\n" 11366 " void g() { return; }\n" 11367 "};\n" 11368 "struct B {\n" 11369 " int x;\n" 11370 "};\n" 11371 "} // namespace a\n", 11372 LinuxBraceStyle); 11373 verifyFormat("enum X {\n" 11374 " Y = 0,\n" 11375 "}\n", 11376 LinuxBraceStyle); 11377 verifyFormat("struct S {\n" 11378 " int Type;\n" 11379 " union {\n" 11380 " int x;\n" 11381 " double y;\n" 11382 " } Value;\n" 11383 " class C\n" 11384 " {\n" 11385 " MyFavoriteType Value;\n" 11386 " } Class;\n" 11387 "}\n", 11388 LinuxBraceStyle); 11389 } 11390 11391 TEST_F(FormatTest, MozillaBraceBreaking) { 11392 FormatStyle MozillaBraceStyle = getLLVMStyle(); 11393 MozillaBraceStyle.BreakBeforeBraces = FormatStyle::BS_Mozilla; 11394 MozillaBraceStyle.FixNamespaceComments = false; 11395 verifyFormat("namespace a {\n" 11396 "class A\n" 11397 "{\n" 11398 " void f()\n" 11399 " {\n" 11400 " if (true) {\n" 11401 " a();\n" 11402 " b();\n" 11403 " }\n" 11404 " }\n" 11405 " void g() { return; }\n" 11406 "};\n" 11407 "enum E\n" 11408 "{\n" 11409 " A,\n" 11410 " // foo\n" 11411 " B,\n" 11412 " C\n" 11413 "};\n" 11414 "struct B\n" 11415 "{\n" 11416 " int x;\n" 11417 "};\n" 11418 "}\n", 11419 MozillaBraceStyle); 11420 verifyFormat("struct S\n" 11421 "{\n" 11422 " int Type;\n" 11423 " union\n" 11424 " {\n" 11425 " int x;\n" 11426 " double y;\n" 11427 " } Value;\n" 11428 " class C\n" 11429 " {\n" 11430 " MyFavoriteType Value;\n" 11431 " } Class;\n" 11432 "}\n", 11433 MozillaBraceStyle); 11434 } 11435 11436 TEST_F(FormatTest, StroustrupBraceBreaking) { 11437 FormatStyle StroustrupBraceStyle = getLLVMStyle(); 11438 StroustrupBraceStyle.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 11439 verifyFormat("namespace a {\n" 11440 "class A {\n" 11441 " void f()\n" 11442 " {\n" 11443 " if (true) {\n" 11444 " a();\n" 11445 " b();\n" 11446 " }\n" 11447 " }\n" 11448 " void g() { return; }\n" 11449 "};\n" 11450 "struct B {\n" 11451 " int x;\n" 11452 "};\n" 11453 "} // namespace a\n", 11454 StroustrupBraceStyle); 11455 11456 verifyFormat("void foo()\n" 11457 "{\n" 11458 " if (a) {\n" 11459 " a();\n" 11460 " }\n" 11461 " else {\n" 11462 " b();\n" 11463 " }\n" 11464 "}\n", 11465 StroustrupBraceStyle); 11466 11467 verifyFormat("#ifdef _DEBUG\n" 11468 "int foo(int i = 0)\n" 11469 "#else\n" 11470 "int foo(int i = 5)\n" 11471 "#endif\n" 11472 "{\n" 11473 " return i;\n" 11474 "}", 11475 StroustrupBraceStyle); 11476 11477 verifyFormat("void foo() {}\n" 11478 "void bar()\n" 11479 "#ifdef _DEBUG\n" 11480 "{\n" 11481 " foo();\n" 11482 "}\n" 11483 "#else\n" 11484 "{\n" 11485 "}\n" 11486 "#endif", 11487 StroustrupBraceStyle); 11488 11489 verifyFormat("void foobar() { int i = 5; }\n" 11490 "#ifdef _DEBUG\n" 11491 "void bar() {}\n" 11492 "#else\n" 11493 "void bar() { foobar(); }\n" 11494 "#endif", 11495 StroustrupBraceStyle); 11496 } 11497 11498 TEST_F(FormatTest, AllmanBraceBreaking) { 11499 FormatStyle AllmanBraceStyle = getLLVMStyle(); 11500 AllmanBraceStyle.BreakBeforeBraces = FormatStyle::BS_Allman; 11501 11502 EXPECT_EQ("namespace a\n" 11503 "{\n" 11504 "void f();\n" 11505 "void g();\n" 11506 "} // namespace a\n", 11507 format("namespace a\n" 11508 "{\n" 11509 "void f();\n" 11510 "void g();\n" 11511 "}\n", 11512 AllmanBraceStyle)); 11513 11514 verifyFormat("namespace a\n" 11515 "{\n" 11516 "class A\n" 11517 "{\n" 11518 " void f()\n" 11519 " {\n" 11520 " if (true)\n" 11521 " {\n" 11522 " a();\n" 11523 " b();\n" 11524 " }\n" 11525 " }\n" 11526 " void g() { return; }\n" 11527 "};\n" 11528 "struct B\n" 11529 "{\n" 11530 " int x;\n" 11531 "};\n" 11532 "union C\n" 11533 "{\n" 11534 "};\n" 11535 "} // namespace a", 11536 AllmanBraceStyle); 11537 11538 verifyFormat("void f()\n" 11539 "{\n" 11540 " if (true)\n" 11541 " {\n" 11542 " a();\n" 11543 " }\n" 11544 " else if (false)\n" 11545 " {\n" 11546 " b();\n" 11547 " }\n" 11548 " else\n" 11549 " {\n" 11550 " c();\n" 11551 " }\n" 11552 "}\n", 11553 AllmanBraceStyle); 11554 11555 verifyFormat("void f()\n" 11556 "{\n" 11557 " for (int i = 0; i < 10; ++i)\n" 11558 " {\n" 11559 " a();\n" 11560 " }\n" 11561 " while (false)\n" 11562 " {\n" 11563 " b();\n" 11564 " }\n" 11565 " do\n" 11566 " {\n" 11567 " c();\n" 11568 " } while (false)\n" 11569 "}\n", 11570 AllmanBraceStyle); 11571 11572 verifyFormat("void f(int a)\n" 11573 "{\n" 11574 " switch (a)\n" 11575 " {\n" 11576 " case 0:\n" 11577 " break;\n" 11578 " case 1:\n" 11579 " {\n" 11580 " break;\n" 11581 " }\n" 11582 " case 2:\n" 11583 " {\n" 11584 " }\n" 11585 " break;\n" 11586 " default:\n" 11587 " break;\n" 11588 " }\n" 11589 "}\n", 11590 AllmanBraceStyle); 11591 11592 verifyFormat("enum X\n" 11593 "{\n" 11594 " Y = 0,\n" 11595 "}\n", 11596 AllmanBraceStyle); 11597 verifyFormat("enum X\n" 11598 "{\n" 11599 " Y = 0\n" 11600 "}\n", 11601 AllmanBraceStyle); 11602 11603 verifyFormat("@interface BSApplicationController ()\n" 11604 "{\n" 11605 "@private\n" 11606 " id _extraIvar;\n" 11607 "}\n" 11608 "@end\n", 11609 AllmanBraceStyle); 11610 11611 verifyFormat("#ifdef _DEBUG\n" 11612 "int foo(int i = 0)\n" 11613 "#else\n" 11614 "int foo(int i = 5)\n" 11615 "#endif\n" 11616 "{\n" 11617 " return i;\n" 11618 "}", 11619 AllmanBraceStyle); 11620 11621 verifyFormat("void foo() {}\n" 11622 "void bar()\n" 11623 "#ifdef _DEBUG\n" 11624 "{\n" 11625 " foo();\n" 11626 "}\n" 11627 "#else\n" 11628 "{\n" 11629 "}\n" 11630 "#endif", 11631 AllmanBraceStyle); 11632 11633 verifyFormat("void foobar() { int i = 5; }\n" 11634 "#ifdef _DEBUG\n" 11635 "void bar() {}\n" 11636 "#else\n" 11637 "void bar() { foobar(); }\n" 11638 "#endif", 11639 AllmanBraceStyle); 11640 11641 // This shouldn't affect ObjC blocks.. 11642 verifyFormat("[self doSomeThingWithACompletionHandler:^{\n" 11643 " // ...\n" 11644 " int i;\n" 11645 "}];", 11646 AllmanBraceStyle); 11647 verifyFormat("void (^block)(void) = ^{\n" 11648 " // ...\n" 11649 " int i;\n" 11650 "};", 11651 AllmanBraceStyle); 11652 // .. or dict literals. 11653 verifyFormat("void f()\n" 11654 "{\n" 11655 " // ...\n" 11656 " [object someMethod:@{@\"a\" : @\"b\"}];\n" 11657 "}", 11658 AllmanBraceStyle); 11659 verifyFormat("void f()\n" 11660 "{\n" 11661 " // ...\n" 11662 " [object someMethod:@{a : @\"b\"}];\n" 11663 "}", 11664 AllmanBraceStyle); 11665 verifyFormat("int f()\n" 11666 "{ // comment\n" 11667 " return 42;\n" 11668 "}", 11669 AllmanBraceStyle); 11670 11671 AllmanBraceStyle.ColumnLimit = 19; 11672 verifyFormat("void f() { int i; }", AllmanBraceStyle); 11673 AllmanBraceStyle.ColumnLimit = 18; 11674 verifyFormat("void f()\n" 11675 "{\n" 11676 " int i;\n" 11677 "}", 11678 AllmanBraceStyle); 11679 AllmanBraceStyle.ColumnLimit = 80; 11680 11681 FormatStyle BreakBeforeBraceShortIfs = AllmanBraceStyle; 11682 BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine = 11683 FormatStyle::SIS_WithoutElse; 11684 BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true; 11685 verifyFormat("void f(bool b)\n" 11686 "{\n" 11687 " if (b)\n" 11688 " {\n" 11689 " return;\n" 11690 " }\n" 11691 "}\n", 11692 BreakBeforeBraceShortIfs); 11693 verifyFormat("void f(bool b)\n" 11694 "{\n" 11695 " if constexpr (b)\n" 11696 " {\n" 11697 " return;\n" 11698 " }\n" 11699 "}\n", 11700 BreakBeforeBraceShortIfs); 11701 verifyFormat("void f(bool b)\n" 11702 "{\n" 11703 " if CONSTEXPR (b)\n" 11704 " {\n" 11705 " return;\n" 11706 " }\n" 11707 "}\n", 11708 BreakBeforeBraceShortIfs); 11709 verifyFormat("void f(bool b)\n" 11710 "{\n" 11711 " if (b) return;\n" 11712 "}\n", 11713 BreakBeforeBraceShortIfs); 11714 verifyFormat("void f(bool b)\n" 11715 "{\n" 11716 " if constexpr (b) return;\n" 11717 "}\n", 11718 BreakBeforeBraceShortIfs); 11719 verifyFormat("void f(bool b)\n" 11720 "{\n" 11721 " if CONSTEXPR (b) return;\n" 11722 "}\n", 11723 BreakBeforeBraceShortIfs); 11724 verifyFormat("void f(bool b)\n" 11725 "{\n" 11726 " while (b)\n" 11727 " {\n" 11728 " return;\n" 11729 " }\n" 11730 "}\n", 11731 BreakBeforeBraceShortIfs); 11732 } 11733 11734 TEST_F(FormatTest, WhitesmithsBraceBreaking) { 11735 FormatStyle WhitesmithsBraceStyle = getLLVMStyle(); 11736 WhitesmithsBraceStyle.BreakBeforeBraces = FormatStyle::BS_Whitesmiths; 11737 11738 // Make a few changes to the style for testing purposes 11739 WhitesmithsBraceStyle.AllowShortFunctionsOnASingleLine = 11740 FormatStyle::SFS_Empty; 11741 WhitesmithsBraceStyle.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None; 11742 WhitesmithsBraceStyle.ColumnLimit = 0; 11743 11744 // FIXME: this test case can't decide whether there should be a blank line 11745 // after the ~D() line or not. It adds one if one doesn't exist in the test 11746 // and it removes the line if one exists. 11747 /* 11748 verifyFormat("class A;\n" 11749 "namespace B\n" 11750 " {\n" 11751 "class C;\n" 11752 "// Comment\n" 11753 "class D\n" 11754 " {\n" 11755 "public:\n" 11756 " D();\n" 11757 " ~D() {}\n" 11758 "private:\n" 11759 " enum E\n" 11760 " {\n" 11761 " F\n" 11762 " }\n" 11763 " };\n" 11764 " } // namespace B\n", 11765 WhitesmithsBraceStyle); 11766 */ 11767 11768 verifyFormat("namespace a\n" 11769 " {\n" 11770 "class A\n" 11771 " {\n" 11772 " void f()\n" 11773 " {\n" 11774 " if (true)\n" 11775 " {\n" 11776 " a();\n" 11777 " b();\n" 11778 " }\n" 11779 " }\n" 11780 " void g()\n" 11781 " {\n" 11782 " return;\n" 11783 " }\n" 11784 " };\n" 11785 "struct B\n" 11786 " {\n" 11787 " int x;\n" 11788 " };\n" 11789 " } // namespace a", 11790 WhitesmithsBraceStyle); 11791 11792 verifyFormat("void f()\n" 11793 " {\n" 11794 " if (true)\n" 11795 " {\n" 11796 " a();\n" 11797 " }\n" 11798 " else if (false)\n" 11799 " {\n" 11800 " b();\n" 11801 " }\n" 11802 " else\n" 11803 " {\n" 11804 " c();\n" 11805 " }\n" 11806 " }\n", 11807 WhitesmithsBraceStyle); 11808 11809 verifyFormat("void f()\n" 11810 " {\n" 11811 " for (int i = 0; i < 10; ++i)\n" 11812 " {\n" 11813 " a();\n" 11814 " }\n" 11815 " while (false)\n" 11816 " {\n" 11817 " b();\n" 11818 " }\n" 11819 " do\n" 11820 " {\n" 11821 " c();\n" 11822 " } while (false)\n" 11823 " }\n", 11824 WhitesmithsBraceStyle); 11825 11826 // FIXME: the block and the break under case 2 in this test don't get indented 11827 // correctly 11828 /* 11829 verifyFormat("void switchTest1(int a)\n" 11830 " {\n" 11831 " switch (a)\n" 11832 " {\n" 11833 " case 2:\n" 11834 " {\n" 11835 " }\n" 11836 " break;\n" 11837 " }\n" 11838 " }\n", 11839 WhitesmithsBraceStyle); 11840 */ 11841 11842 // FIXME: the block and the break under case 2 in this test don't get indented 11843 // correctly 11844 /* 11845 verifyFormat("void switchTest2(int a)\n" 11846 " {\n" 11847 " switch (a)\n" 11848 " {\n" 11849 " case 0:\n" 11850 " break;\n" 11851 " case 1:\n" 11852 " {\n" 11853 " break;\n" 11854 " }\n" 11855 " case 2:\n" 11856 " {\n" 11857 " }\n" 11858 " break;\n" 11859 " default:\n" 11860 " break;\n" 11861 " }\n" 11862 " }\n", 11863 WhitesmithsBraceStyle); 11864 */ 11865 11866 verifyFormat("enum X\n" 11867 " {\n" 11868 " Y = 0, // testing\n" 11869 " }\n", 11870 WhitesmithsBraceStyle); 11871 11872 verifyFormat("enum X\n" 11873 " {\n" 11874 " Y = 0\n" 11875 " }\n", 11876 WhitesmithsBraceStyle); 11877 verifyFormat("enum X\n" 11878 " {\n" 11879 " Y = 0,\n" 11880 " Z = 1\n" 11881 " };\n", 11882 WhitesmithsBraceStyle); 11883 11884 verifyFormat("@interface BSApplicationController ()\n" 11885 " {\n" 11886 "@private\n" 11887 " id _extraIvar;\n" 11888 " }\n" 11889 "@end\n", 11890 WhitesmithsBraceStyle); 11891 11892 verifyFormat("#ifdef _DEBUG\n" 11893 "int foo(int i = 0)\n" 11894 "#else\n" 11895 "int foo(int i = 5)\n" 11896 "#endif\n" 11897 " {\n" 11898 " return i;\n" 11899 " }", 11900 WhitesmithsBraceStyle); 11901 11902 verifyFormat("void foo() {}\n" 11903 "void bar()\n" 11904 "#ifdef _DEBUG\n" 11905 " {\n" 11906 " foo();\n" 11907 " }\n" 11908 "#else\n" 11909 " {\n" 11910 " }\n" 11911 "#endif", 11912 WhitesmithsBraceStyle); 11913 11914 verifyFormat("void foobar()\n" 11915 " {\n" 11916 " int i = 5;\n" 11917 " }\n" 11918 "#ifdef _DEBUG\n" 11919 "void bar()\n" 11920 " {\n" 11921 " }\n" 11922 "#else\n" 11923 "void bar()\n" 11924 " {\n" 11925 " foobar();\n" 11926 " }\n" 11927 "#endif", 11928 WhitesmithsBraceStyle); 11929 11930 // This shouldn't affect ObjC blocks.. 11931 verifyFormat("[self doSomeThingWithACompletionHandler:^{\n" 11932 " // ...\n" 11933 " int i;\n" 11934 "}];", 11935 WhitesmithsBraceStyle); 11936 verifyFormat("void (^block)(void) = ^{\n" 11937 " // ...\n" 11938 " int i;\n" 11939 "};", 11940 WhitesmithsBraceStyle); 11941 // .. or dict literals. 11942 verifyFormat("void f()\n" 11943 " {\n" 11944 " [object someMethod:@{@\"a\" : @\"b\"}];\n" 11945 " }", 11946 WhitesmithsBraceStyle); 11947 11948 verifyFormat("int f()\n" 11949 " { // comment\n" 11950 " return 42;\n" 11951 " }", 11952 WhitesmithsBraceStyle); 11953 11954 FormatStyle BreakBeforeBraceShortIfs = WhitesmithsBraceStyle; 11955 BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine = 11956 FormatStyle::SIS_Always; 11957 BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true; 11958 verifyFormat("void f(bool b)\n" 11959 " {\n" 11960 " if (b)\n" 11961 " {\n" 11962 " return;\n" 11963 " }\n" 11964 " }\n", 11965 BreakBeforeBraceShortIfs); 11966 verifyFormat("void f(bool b)\n" 11967 " {\n" 11968 " if (b) return;\n" 11969 " }\n", 11970 BreakBeforeBraceShortIfs); 11971 verifyFormat("void f(bool b)\n" 11972 " {\n" 11973 " while (b)\n" 11974 " {\n" 11975 " return;\n" 11976 " }\n" 11977 " }\n", 11978 BreakBeforeBraceShortIfs); 11979 } 11980 11981 TEST_F(FormatTest, GNUBraceBreaking) { 11982 FormatStyle GNUBraceStyle = getLLVMStyle(); 11983 GNUBraceStyle.BreakBeforeBraces = FormatStyle::BS_GNU; 11984 verifyFormat("namespace a\n" 11985 "{\n" 11986 "class A\n" 11987 "{\n" 11988 " void f()\n" 11989 " {\n" 11990 " int a;\n" 11991 " {\n" 11992 " int b;\n" 11993 " }\n" 11994 " if (true)\n" 11995 " {\n" 11996 " a();\n" 11997 " b();\n" 11998 " }\n" 11999 " }\n" 12000 " void g() { return; }\n" 12001 "}\n" 12002 "} // namespace a", 12003 GNUBraceStyle); 12004 12005 verifyFormat("void f()\n" 12006 "{\n" 12007 " if (true)\n" 12008 " {\n" 12009 " a();\n" 12010 " }\n" 12011 " else if (false)\n" 12012 " {\n" 12013 " b();\n" 12014 " }\n" 12015 " else\n" 12016 " {\n" 12017 " c();\n" 12018 " }\n" 12019 "}\n", 12020 GNUBraceStyle); 12021 12022 verifyFormat("void f()\n" 12023 "{\n" 12024 " for (int i = 0; i < 10; ++i)\n" 12025 " {\n" 12026 " a();\n" 12027 " }\n" 12028 " while (false)\n" 12029 " {\n" 12030 " b();\n" 12031 " }\n" 12032 " do\n" 12033 " {\n" 12034 " c();\n" 12035 " }\n" 12036 " while (false);\n" 12037 "}\n", 12038 GNUBraceStyle); 12039 12040 verifyFormat("void f(int a)\n" 12041 "{\n" 12042 " switch (a)\n" 12043 " {\n" 12044 " case 0:\n" 12045 " break;\n" 12046 " case 1:\n" 12047 " {\n" 12048 " break;\n" 12049 " }\n" 12050 " case 2:\n" 12051 " {\n" 12052 " }\n" 12053 " break;\n" 12054 " default:\n" 12055 " break;\n" 12056 " }\n" 12057 "}\n", 12058 GNUBraceStyle); 12059 12060 verifyFormat("enum X\n" 12061 "{\n" 12062 " Y = 0,\n" 12063 "}\n", 12064 GNUBraceStyle); 12065 12066 verifyFormat("@interface BSApplicationController ()\n" 12067 "{\n" 12068 "@private\n" 12069 " id _extraIvar;\n" 12070 "}\n" 12071 "@end\n", 12072 GNUBraceStyle); 12073 12074 verifyFormat("#ifdef _DEBUG\n" 12075 "int foo(int i = 0)\n" 12076 "#else\n" 12077 "int foo(int i = 5)\n" 12078 "#endif\n" 12079 "{\n" 12080 " return i;\n" 12081 "}", 12082 GNUBraceStyle); 12083 12084 verifyFormat("void foo() {}\n" 12085 "void bar()\n" 12086 "#ifdef _DEBUG\n" 12087 "{\n" 12088 " foo();\n" 12089 "}\n" 12090 "#else\n" 12091 "{\n" 12092 "}\n" 12093 "#endif", 12094 GNUBraceStyle); 12095 12096 verifyFormat("void foobar() { int i = 5; }\n" 12097 "#ifdef _DEBUG\n" 12098 "void bar() {}\n" 12099 "#else\n" 12100 "void bar() { foobar(); }\n" 12101 "#endif", 12102 GNUBraceStyle); 12103 } 12104 12105 TEST_F(FormatTest, WebKitBraceBreaking) { 12106 FormatStyle WebKitBraceStyle = getLLVMStyle(); 12107 WebKitBraceStyle.BreakBeforeBraces = FormatStyle::BS_WebKit; 12108 WebKitBraceStyle.FixNamespaceComments = false; 12109 verifyFormat("namespace a {\n" 12110 "class A {\n" 12111 " void f()\n" 12112 " {\n" 12113 " if (true) {\n" 12114 " a();\n" 12115 " b();\n" 12116 " }\n" 12117 " }\n" 12118 " void g() { return; }\n" 12119 "};\n" 12120 "enum E {\n" 12121 " A,\n" 12122 " // foo\n" 12123 " B,\n" 12124 " C\n" 12125 "};\n" 12126 "struct B {\n" 12127 " int x;\n" 12128 "};\n" 12129 "}\n", 12130 WebKitBraceStyle); 12131 verifyFormat("struct S {\n" 12132 " int Type;\n" 12133 " union {\n" 12134 " int x;\n" 12135 " double y;\n" 12136 " } Value;\n" 12137 " class C {\n" 12138 " MyFavoriteType Value;\n" 12139 " } Class;\n" 12140 "};\n", 12141 WebKitBraceStyle); 12142 } 12143 12144 TEST_F(FormatTest, CatchExceptionReferenceBinding) { 12145 verifyFormat("void f() {\n" 12146 " try {\n" 12147 " } catch (const Exception &e) {\n" 12148 " }\n" 12149 "}\n", 12150 getLLVMStyle()); 12151 } 12152 12153 TEST_F(FormatTest, UnderstandsPragmas) { 12154 verifyFormat("#pragma omp reduction(| : var)"); 12155 verifyFormat("#pragma omp reduction(+ : var)"); 12156 12157 EXPECT_EQ("#pragma mark Any non-hyphenated or hyphenated string " 12158 "(including parentheses).", 12159 format("#pragma mark Any non-hyphenated or hyphenated string " 12160 "(including parentheses).")); 12161 } 12162 12163 TEST_F(FormatTest, UnderstandPragmaOption) { 12164 verifyFormat("#pragma option -C -A"); 12165 12166 EXPECT_EQ("#pragma option -C -A", format("#pragma option -C -A")); 12167 } 12168 12169 TEST_F(FormatTest, OptimizeBreakPenaltyVsExcess) { 12170 FormatStyle Style = getLLVMStyle(); 12171 Style.ColumnLimit = 20; 12172 12173 // See PR41213 12174 EXPECT_EQ("/*\n" 12175 " *\t9012345\n" 12176 " * /8901\n" 12177 " */", 12178 format("/*\n" 12179 " *\t9012345 /8901\n" 12180 " */", 12181 Style)); 12182 EXPECT_EQ("/*\n" 12183 " *345678\n" 12184 " *\t/8901\n" 12185 " */", 12186 format("/*\n" 12187 " *345678\t/8901\n" 12188 " */", 12189 Style)); 12190 12191 verifyFormat("int a; // the\n" 12192 " // comment", 12193 Style); 12194 EXPECT_EQ("int a; /* first line\n" 12195 " * second\n" 12196 " * line third\n" 12197 " * line\n" 12198 " */", 12199 format("int a; /* first line\n" 12200 " * second\n" 12201 " * line third\n" 12202 " * line\n" 12203 " */", 12204 Style)); 12205 EXPECT_EQ("int a; // first line\n" 12206 " // second\n" 12207 " // line third\n" 12208 " // line", 12209 format("int a; // first line\n" 12210 " // second line\n" 12211 " // third line", 12212 Style)); 12213 12214 Style.PenaltyExcessCharacter = 90; 12215 verifyFormat("int a; // the comment", Style); 12216 EXPECT_EQ("int a; // the comment\n" 12217 " // aaa", 12218 format("int a; // the comment aaa", Style)); 12219 EXPECT_EQ("int a; /* first line\n" 12220 " * second line\n" 12221 " * third line\n" 12222 " */", 12223 format("int a; /* first line\n" 12224 " * second line\n" 12225 " * third line\n" 12226 " */", 12227 Style)); 12228 EXPECT_EQ("int a; // first line\n" 12229 " // second line\n" 12230 " // third line", 12231 format("int a; // first line\n" 12232 " // second line\n" 12233 " // third line", 12234 Style)); 12235 // FIXME: Investigate why this is not getting the same layout as the test 12236 // above. 12237 EXPECT_EQ("int a; /* first line\n" 12238 " * second line\n" 12239 " * third line\n" 12240 " */", 12241 format("int a; /* first line second line third line" 12242 "\n*/", 12243 Style)); 12244 12245 EXPECT_EQ("// foo bar baz bazfoo\n" 12246 "// foo bar foo bar\n", 12247 format("// foo bar baz bazfoo\n" 12248 "// foo bar foo bar\n", 12249 Style)); 12250 EXPECT_EQ("// foo bar baz bazfoo\n" 12251 "// foo bar foo bar\n", 12252 format("// foo bar baz bazfoo\n" 12253 "// foo bar foo bar\n", 12254 Style)); 12255 12256 // FIXME: Optimally, we'd keep bazfoo on the first line and reflow bar to the 12257 // next one. 12258 EXPECT_EQ("// foo bar baz bazfoo\n" 12259 "// bar foo bar\n", 12260 format("// foo bar baz bazfoo bar\n" 12261 "// foo bar\n", 12262 Style)); 12263 12264 EXPECT_EQ("// foo bar baz bazfoo\n" 12265 "// foo bar baz bazfoo\n" 12266 "// bar foo bar\n", 12267 format("// foo bar baz bazfoo\n" 12268 "// foo bar baz bazfoo bar\n" 12269 "// foo bar\n", 12270 Style)); 12271 12272 EXPECT_EQ("// foo bar baz bazfoo\n" 12273 "// foo bar baz bazfoo\n" 12274 "// bar foo bar\n", 12275 format("// foo bar baz bazfoo\n" 12276 "// foo bar baz bazfoo bar\n" 12277 "// foo bar\n", 12278 Style)); 12279 12280 // Make sure we do not keep protruding characters if strict mode reflow is 12281 // cheaper than keeping protruding characters. 12282 Style.ColumnLimit = 21; 12283 EXPECT_EQ( 12284 "// foo foo foo foo\n" 12285 "// foo foo foo foo\n" 12286 "// foo foo foo foo\n", 12287 format("// foo foo foo foo foo foo foo foo foo foo foo foo\n", Style)); 12288 12289 EXPECT_EQ("int a = /* long block\n" 12290 " comment */\n" 12291 " 42;", 12292 format("int a = /* long block comment */ 42;", Style)); 12293 } 12294 12295 #define EXPECT_ALL_STYLES_EQUAL(Styles) \ 12296 for (size_t i = 1; i < Styles.size(); ++i) \ 12297 EXPECT_EQ(Styles[0], Styles[i]) \ 12298 << "Style #" << i << " of " << Styles.size() << " differs from Style #0" 12299 12300 TEST_F(FormatTest, GetsPredefinedStyleByName) { 12301 SmallVector<FormatStyle, 3> Styles; 12302 Styles.resize(3); 12303 12304 Styles[0] = getLLVMStyle(); 12305 EXPECT_TRUE(getPredefinedStyle("LLVM", FormatStyle::LK_Cpp, &Styles[1])); 12306 EXPECT_TRUE(getPredefinedStyle("lLvM", FormatStyle::LK_Cpp, &Styles[2])); 12307 EXPECT_ALL_STYLES_EQUAL(Styles); 12308 12309 Styles[0] = getGoogleStyle(); 12310 EXPECT_TRUE(getPredefinedStyle("Google", FormatStyle::LK_Cpp, &Styles[1])); 12311 EXPECT_TRUE(getPredefinedStyle("gOOgle", FormatStyle::LK_Cpp, &Styles[2])); 12312 EXPECT_ALL_STYLES_EQUAL(Styles); 12313 12314 Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript); 12315 EXPECT_TRUE( 12316 getPredefinedStyle("Google", FormatStyle::LK_JavaScript, &Styles[1])); 12317 EXPECT_TRUE( 12318 getPredefinedStyle("gOOgle", FormatStyle::LK_JavaScript, &Styles[2])); 12319 EXPECT_ALL_STYLES_EQUAL(Styles); 12320 12321 Styles[0] = getChromiumStyle(FormatStyle::LK_Cpp); 12322 EXPECT_TRUE(getPredefinedStyle("Chromium", FormatStyle::LK_Cpp, &Styles[1])); 12323 EXPECT_TRUE(getPredefinedStyle("cHRoMiUM", FormatStyle::LK_Cpp, &Styles[2])); 12324 EXPECT_ALL_STYLES_EQUAL(Styles); 12325 12326 Styles[0] = getMozillaStyle(); 12327 EXPECT_TRUE(getPredefinedStyle("Mozilla", FormatStyle::LK_Cpp, &Styles[1])); 12328 EXPECT_TRUE(getPredefinedStyle("moZILla", FormatStyle::LK_Cpp, &Styles[2])); 12329 EXPECT_ALL_STYLES_EQUAL(Styles); 12330 12331 Styles[0] = getWebKitStyle(); 12332 EXPECT_TRUE(getPredefinedStyle("WebKit", FormatStyle::LK_Cpp, &Styles[1])); 12333 EXPECT_TRUE(getPredefinedStyle("wEbKit", FormatStyle::LK_Cpp, &Styles[2])); 12334 EXPECT_ALL_STYLES_EQUAL(Styles); 12335 12336 Styles[0] = getGNUStyle(); 12337 EXPECT_TRUE(getPredefinedStyle("GNU", FormatStyle::LK_Cpp, &Styles[1])); 12338 EXPECT_TRUE(getPredefinedStyle("gnU", FormatStyle::LK_Cpp, &Styles[2])); 12339 EXPECT_ALL_STYLES_EQUAL(Styles); 12340 12341 EXPECT_FALSE(getPredefinedStyle("qwerty", FormatStyle::LK_Cpp, &Styles[0])); 12342 } 12343 12344 TEST_F(FormatTest, GetsCorrectBasedOnStyle) { 12345 SmallVector<FormatStyle, 8> Styles; 12346 Styles.resize(2); 12347 12348 Styles[0] = getGoogleStyle(); 12349 Styles[1] = getLLVMStyle(); 12350 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value()); 12351 EXPECT_ALL_STYLES_EQUAL(Styles); 12352 12353 Styles.resize(5); 12354 Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript); 12355 Styles[1] = getLLVMStyle(); 12356 Styles[1].Language = FormatStyle::LK_JavaScript; 12357 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value()); 12358 12359 Styles[2] = getLLVMStyle(); 12360 Styles[2].Language = FormatStyle::LK_JavaScript; 12361 EXPECT_EQ(0, parseConfiguration("Language: JavaScript\n" 12362 "BasedOnStyle: Google", 12363 &Styles[2]) 12364 .value()); 12365 12366 Styles[3] = getLLVMStyle(); 12367 Styles[3].Language = FormatStyle::LK_JavaScript; 12368 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google\n" 12369 "Language: JavaScript", 12370 &Styles[3]) 12371 .value()); 12372 12373 Styles[4] = getLLVMStyle(); 12374 Styles[4].Language = FormatStyle::LK_JavaScript; 12375 EXPECT_EQ(0, parseConfiguration("---\n" 12376 "BasedOnStyle: LLVM\n" 12377 "IndentWidth: 123\n" 12378 "---\n" 12379 "BasedOnStyle: Google\n" 12380 "Language: JavaScript", 12381 &Styles[4]) 12382 .value()); 12383 EXPECT_ALL_STYLES_EQUAL(Styles); 12384 } 12385 12386 #define CHECK_PARSE_BOOL_FIELD(FIELD, CONFIG_NAME) \ 12387 Style.FIELD = false; \ 12388 EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": true", &Style).value()); \ 12389 EXPECT_TRUE(Style.FIELD); \ 12390 EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": false", &Style).value()); \ 12391 EXPECT_FALSE(Style.FIELD); 12392 12393 #define CHECK_PARSE_BOOL(FIELD) CHECK_PARSE_BOOL_FIELD(FIELD, #FIELD) 12394 12395 #define CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, CONFIG_NAME) \ 12396 Style.STRUCT.FIELD = false; \ 12397 EXPECT_EQ(0, \ 12398 parseConfiguration(#STRUCT ":\n " CONFIG_NAME ": true", &Style) \ 12399 .value()); \ 12400 EXPECT_TRUE(Style.STRUCT.FIELD); \ 12401 EXPECT_EQ(0, \ 12402 parseConfiguration(#STRUCT ":\n " CONFIG_NAME ": false", &Style) \ 12403 .value()); \ 12404 EXPECT_FALSE(Style.STRUCT.FIELD); 12405 12406 #define CHECK_PARSE_NESTED_BOOL(STRUCT, FIELD) \ 12407 CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, #FIELD) 12408 12409 #define CHECK_PARSE(TEXT, FIELD, VALUE) \ 12410 EXPECT_NE(VALUE, Style.FIELD); \ 12411 EXPECT_EQ(0, parseConfiguration(TEXT, &Style).value()); \ 12412 EXPECT_EQ(VALUE, Style.FIELD) 12413 12414 TEST_F(FormatTest, ParsesConfigurationBools) { 12415 FormatStyle Style = {}; 12416 Style.Language = FormatStyle::LK_Cpp; 12417 CHECK_PARSE_BOOL(AlignOperands); 12418 CHECK_PARSE_BOOL(AlignTrailingComments); 12419 CHECK_PARSE_BOOL(AlignConsecutiveAssignments); 12420 CHECK_PARSE_BOOL(AlignConsecutiveDeclarations); 12421 CHECK_PARSE_BOOL(AlignConsecutiveMacros); 12422 CHECK_PARSE_BOOL(AllowAllArgumentsOnNextLine); 12423 CHECK_PARSE_BOOL(AllowAllConstructorInitializersOnNextLine); 12424 CHECK_PARSE_BOOL(AllowAllParametersOfDeclarationOnNextLine); 12425 CHECK_PARSE_BOOL(AllowShortCaseLabelsOnASingleLine); 12426 CHECK_PARSE_BOOL(AllowShortLoopsOnASingleLine); 12427 CHECK_PARSE_BOOL(BinPackArguments); 12428 CHECK_PARSE_BOOL(BinPackParameters); 12429 CHECK_PARSE_BOOL(BreakAfterJavaFieldAnnotations); 12430 CHECK_PARSE_BOOL(BreakBeforeTernaryOperators); 12431 CHECK_PARSE_BOOL(BreakStringLiterals); 12432 CHECK_PARSE_BOOL(CompactNamespaces); 12433 CHECK_PARSE_BOOL(ConstructorInitializerAllOnOneLineOrOnePerLine); 12434 CHECK_PARSE_BOOL(DerivePointerAlignment); 12435 CHECK_PARSE_BOOL_FIELD(DerivePointerAlignment, "DerivePointerBinding"); 12436 CHECK_PARSE_BOOL(DisableFormat); 12437 CHECK_PARSE_BOOL(IndentCaseLabels); 12438 CHECK_PARSE_BOOL(IndentGotoLabels); 12439 CHECK_PARSE_BOOL(IndentWrappedFunctionNames); 12440 CHECK_PARSE_BOOL(KeepEmptyLinesAtTheStartOfBlocks); 12441 CHECK_PARSE_BOOL(ObjCSpaceAfterProperty); 12442 CHECK_PARSE_BOOL(ObjCSpaceBeforeProtocolList); 12443 CHECK_PARSE_BOOL(Cpp11BracedListStyle); 12444 CHECK_PARSE_BOOL(ReflowComments); 12445 CHECK_PARSE_BOOL(SortIncludes); 12446 CHECK_PARSE_BOOL(SortUsingDeclarations); 12447 CHECK_PARSE_BOOL(SpacesInParentheses); 12448 CHECK_PARSE_BOOL(SpacesInSquareBrackets); 12449 CHECK_PARSE_BOOL(SpacesInAngles); 12450 CHECK_PARSE_BOOL(SpaceInEmptyBlock); 12451 CHECK_PARSE_BOOL(SpaceInEmptyParentheses); 12452 CHECK_PARSE_BOOL(SpacesInContainerLiterals); 12453 CHECK_PARSE_BOOL(SpacesInCStyleCastParentheses); 12454 CHECK_PARSE_BOOL(SpaceAfterCStyleCast); 12455 CHECK_PARSE_BOOL(SpaceAfterTemplateKeyword); 12456 CHECK_PARSE_BOOL(SpaceAfterLogicalNot); 12457 CHECK_PARSE_BOOL(SpaceBeforeAssignmentOperators); 12458 CHECK_PARSE_BOOL(SpaceBeforeCpp11BracedList); 12459 CHECK_PARSE_BOOL(SpaceBeforeCtorInitializerColon); 12460 CHECK_PARSE_BOOL(SpaceBeforeInheritanceColon); 12461 CHECK_PARSE_BOOL(SpaceBeforeRangeBasedForLoopColon); 12462 12463 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterCaseLabel); 12464 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterClass); 12465 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterEnum); 12466 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterFunction); 12467 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterNamespace); 12468 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterObjCDeclaration); 12469 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterStruct); 12470 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterUnion); 12471 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterExternBlock); 12472 CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeCatch); 12473 CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeElse); 12474 CHECK_PARSE_NESTED_BOOL(BraceWrapping, IndentBraces); 12475 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyFunction); 12476 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyRecord); 12477 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyNamespace); 12478 } 12479 12480 #undef CHECK_PARSE_BOOL 12481 12482 TEST_F(FormatTest, ParsesConfiguration) { 12483 FormatStyle Style = {}; 12484 Style.Language = FormatStyle::LK_Cpp; 12485 CHECK_PARSE("AccessModifierOffset: -1234", AccessModifierOffset, -1234); 12486 CHECK_PARSE("ConstructorInitializerIndentWidth: 1234", 12487 ConstructorInitializerIndentWidth, 1234u); 12488 CHECK_PARSE("ObjCBlockIndentWidth: 1234", ObjCBlockIndentWidth, 1234u); 12489 CHECK_PARSE("ColumnLimit: 1234", ColumnLimit, 1234u); 12490 CHECK_PARSE("MaxEmptyLinesToKeep: 1234", MaxEmptyLinesToKeep, 1234u); 12491 CHECK_PARSE("PenaltyBreakAssignment: 1234", PenaltyBreakAssignment, 1234u); 12492 CHECK_PARSE("PenaltyBreakBeforeFirstCallParameter: 1234", 12493 PenaltyBreakBeforeFirstCallParameter, 1234u); 12494 CHECK_PARSE("PenaltyBreakTemplateDeclaration: 1234", 12495 PenaltyBreakTemplateDeclaration, 1234u); 12496 CHECK_PARSE("PenaltyExcessCharacter: 1234", PenaltyExcessCharacter, 1234u); 12497 CHECK_PARSE("PenaltyReturnTypeOnItsOwnLine: 1234", 12498 PenaltyReturnTypeOnItsOwnLine, 1234u); 12499 CHECK_PARSE("SpacesBeforeTrailingComments: 1234", 12500 SpacesBeforeTrailingComments, 1234u); 12501 CHECK_PARSE("IndentWidth: 32", IndentWidth, 32u); 12502 CHECK_PARSE("ContinuationIndentWidth: 11", ContinuationIndentWidth, 11u); 12503 CHECK_PARSE("CommentPragmas: '// abc$'", CommentPragmas, "// abc$"); 12504 12505 Style.PointerAlignment = FormatStyle::PAS_Middle; 12506 CHECK_PARSE("PointerAlignment: Left", PointerAlignment, 12507 FormatStyle::PAS_Left); 12508 CHECK_PARSE("PointerAlignment: Right", PointerAlignment, 12509 FormatStyle::PAS_Right); 12510 CHECK_PARSE("PointerAlignment: Middle", PointerAlignment, 12511 FormatStyle::PAS_Middle); 12512 // For backward compatibility: 12513 CHECK_PARSE("PointerBindsToType: Left", PointerAlignment, 12514 FormatStyle::PAS_Left); 12515 CHECK_PARSE("PointerBindsToType: Right", PointerAlignment, 12516 FormatStyle::PAS_Right); 12517 CHECK_PARSE("PointerBindsToType: Middle", PointerAlignment, 12518 FormatStyle::PAS_Middle); 12519 12520 Style.Standard = FormatStyle::LS_Auto; 12521 CHECK_PARSE("Standard: c++03", Standard, FormatStyle::LS_Cpp03); 12522 CHECK_PARSE("Standard: c++11", Standard, FormatStyle::LS_Cpp11); 12523 CHECK_PARSE("Standard: c++14", Standard, FormatStyle::LS_Cpp14); 12524 CHECK_PARSE("Standard: c++17", Standard, FormatStyle::LS_Cpp17); 12525 CHECK_PARSE("Standard: c++20", Standard, FormatStyle::LS_Cpp20); 12526 CHECK_PARSE("Standard: Auto", Standard, FormatStyle::LS_Auto); 12527 CHECK_PARSE("Standard: Latest", Standard, FormatStyle::LS_Latest); 12528 // Legacy aliases: 12529 CHECK_PARSE("Standard: Cpp03", Standard, FormatStyle::LS_Cpp03); 12530 CHECK_PARSE("Standard: Cpp11", Standard, FormatStyle::LS_Latest); 12531 CHECK_PARSE("Standard: C++03", Standard, FormatStyle::LS_Cpp03); 12532 CHECK_PARSE("Standard: C++11", Standard, FormatStyle::LS_Cpp11); 12533 12534 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 12535 CHECK_PARSE("BreakBeforeBinaryOperators: NonAssignment", 12536 BreakBeforeBinaryOperators, FormatStyle::BOS_NonAssignment); 12537 CHECK_PARSE("BreakBeforeBinaryOperators: None", BreakBeforeBinaryOperators, 12538 FormatStyle::BOS_None); 12539 CHECK_PARSE("BreakBeforeBinaryOperators: All", BreakBeforeBinaryOperators, 12540 FormatStyle::BOS_All); 12541 // For backward compatibility: 12542 CHECK_PARSE("BreakBeforeBinaryOperators: false", BreakBeforeBinaryOperators, 12543 FormatStyle::BOS_None); 12544 CHECK_PARSE("BreakBeforeBinaryOperators: true", BreakBeforeBinaryOperators, 12545 FormatStyle::BOS_All); 12546 12547 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon; 12548 CHECK_PARSE("BreakConstructorInitializers: BeforeComma", 12549 BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma); 12550 CHECK_PARSE("BreakConstructorInitializers: AfterColon", 12551 BreakConstructorInitializers, FormatStyle::BCIS_AfterColon); 12552 CHECK_PARSE("BreakConstructorInitializers: BeforeColon", 12553 BreakConstructorInitializers, FormatStyle::BCIS_BeforeColon); 12554 // For backward compatibility: 12555 CHECK_PARSE("BreakConstructorInitializersBeforeComma: true", 12556 BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma); 12557 12558 Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon; 12559 CHECK_PARSE("BreakInheritanceList: BeforeComma", BreakInheritanceList, 12560 FormatStyle::BILS_BeforeComma); 12561 CHECK_PARSE("BreakInheritanceList: AfterColon", BreakInheritanceList, 12562 FormatStyle::BILS_AfterColon); 12563 CHECK_PARSE("BreakInheritanceList: BeforeColon", BreakInheritanceList, 12564 FormatStyle::BILS_BeforeColon); 12565 // For backward compatibility: 12566 CHECK_PARSE("BreakBeforeInheritanceComma: true", BreakInheritanceList, 12567 FormatStyle::BILS_BeforeComma); 12568 12569 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 12570 CHECK_PARSE("AlignAfterOpenBracket: Align", AlignAfterOpenBracket, 12571 FormatStyle::BAS_Align); 12572 CHECK_PARSE("AlignAfterOpenBracket: DontAlign", AlignAfterOpenBracket, 12573 FormatStyle::BAS_DontAlign); 12574 CHECK_PARSE("AlignAfterOpenBracket: AlwaysBreak", AlignAfterOpenBracket, 12575 FormatStyle::BAS_AlwaysBreak); 12576 // For backward compatibility: 12577 CHECK_PARSE("AlignAfterOpenBracket: false", AlignAfterOpenBracket, 12578 FormatStyle::BAS_DontAlign); 12579 CHECK_PARSE("AlignAfterOpenBracket: true", AlignAfterOpenBracket, 12580 FormatStyle::BAS_Align); 12581 12582 Style.AlignEscapedNewlines = FormatStyle::ENAS_Left; 12583 CHECK_PARSE("AlignEscapedNewlines: DontAlign", AlignEscapedNewlines, 12584 FormatStyle::ENAS_DontAlign); 12585 CHECK_PARSE("AlignEscapedNewlines: Left", AlignEscapedNewlines, 12586 FormatStyle::ENAS_Left); 12587 CHECK_PARSE("AlignEscapedNewlines: Right", AlignEscapedNewlines, 12588 FormatStyle::ENAS_Right); 12589 // For backward compatibility: 12590 CHECK_PARSE("AlignEscapedNewlinesLeft: true", AlignEscapedNewlines, 12591 FormatStyle::ENAS_Left); 12592 CHECK_PARSE("AlignEscapedNewlinesLeft: false", AlignEscapedNewlines, 12593 FormatStyle::ENAS_Right); 12594 12595 Style.UseTab = FormatStyle::UT_ForIndentation; 12596 CHECK_PARSE("UseTab: Never", UseTab, FormatStyle::UT_Never); 12597 CHECK_PARSE("UseTab: ForIndentation", UseTab, FormatStyle::UT_ForIndentation); 12598 CHECK_PARSE("UseTab: Always", UseTab, FormatStyle::UT_Always); 12599 CHECK_PARSE("UseTab: ForContinuationAndIndentation", UseTab, 12600 FormatStyle::UT_ForContinuationAndIndentation); 12601 // For backward compatibility: 12602 CHECK_PARSE("UseTab: false", UseTab, FormatStyle::UT_Never); 12603 CHECK_PARSE("UseTab: true", UseTab, FormatStyle::UT_Always); 12604 12605 Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty; 12606 CHECK_PARSE("AllowShortBlocksOnASingleLine: Never", 12607 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never); 12608 CHECK_PARSE("AllowShortBlocksOnASingleLine: Empty", 12609 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Empty); 12610 CHECK_PARSE("AllowShortBlocksOnASingleLine: Always", 12611 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always); 12612 // For backward compatibility: 12613 CHECK_PARSE("AllowShortBlocksOnASingleLine: false", 12614 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never); 12615 CHECK_PARSE("AllowShortBlocksOnASingleLine: true", 12616 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always); 12617 12618 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; 12619 CHECK_PARSE("AllowShortFunctionsOnASingleLine: None", 12620 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None); 12621 CHECK_PARSE("AllowShortFunctionsOnASingleLine: Inline", 12622 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Inline); 12623 CHECK_PARSE("AllowShortFunctionsOnASingleLine: Empty", 12624 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Empty); 12625 CHECK_PARSE("AllowShortFunctionsOnASingleLine: All", 12626 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All); 12627 // For backward compatibility: 12628 CHECK_PARSE("AllowShortFunctionsOnASingleLine: false", 12629 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None); 12630 CHECK_PARSE("AllowShortFunctionsOnASingleLine: true", 12631 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All); 12632 12633 Style.SpaceBeforeParens = FormatStyle::SBPO_Always; 12634 CHECK_PARSE("SpaceBeforeParens: Never", SpaceBeforeParens, 12635 FormatStyle::SBPO_Never); 12636 CHECK_PARSE("SpaceBeforeParens: Always", SpaceBeforeParens, 12637 FormatStyle::SBPO_Always); 12638 CHECK_PARSE("SpaceBeforeParens: ControlStatements", SpaceBeforeParens, 12639 FormatStyle::SBPO_ControlStatements); 12640 CHECK_PARSE("SpaceBeforeParens: NonEmptyParentheses", SpaceBeforeParens, 12641 FormatStyle::SBPO_NonEmptyParentheses); 12642 // For backward compatibility: 12643 CHECK_PARSE("SpaceAfterControlStatementKeyword: false", SpaceBeforeParens, 12644 FormatStyle::SBPO_Never); 12645 CHECK_PARSE("SpaceAfterControlStatementKeyword: true", SpaceBeforeParens, 12646 FormatStyle::SBPO_ControlStatements); 12647 12648 Style.ColumnLimit = 123; 12649 FormatStyle BaseStyle = getLLVMStyle(); 12650 CHECK_PARSE("BasedOnStyle: LLVM", ColumnLimit, BaseStyle.ColumnLimit); 12651 CHECK_PARSE("BasedOnStyle: LLVM\nColumnLimit: 1234", ColumnLimit, 1234u); 12652 12653 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 12654 CHECK_PARSE("BreakBeforeBraces: Attach", BreakBeforeBraces, 12655 FormatStyle::BS_Attach); 12656 CHECK_PARSE("BreakBeforeBraces: Linux", BreakBeforeBraces, 12657 FormatStyle::BS_Linux); 12658 CHECK_PARSE("BreakBeforeBraces: Mozilla", BreakBeforeBraces, 12659 FormatStyle::BS_Mozilla); 12660 CHECK_PARSE("BreakBeforeBraces: Stroustrup", BreakBeforeBraces, 12661 FormatStyle::BS_Stroustrup); 12662 CHECK_PARSE("BreakBeforeBraces: Allman", BreakBeforeBraces, 12663 FormatStyle::BS_Allman); 12664 CHECK_PARSE("BreakBeforeBraces: Whitesmiths", BreakBeforeBraces, 12665 FormatStyle::BS_Whitesmiths); 12666 CHECK_PARSE("BreakBeforeBraces: GNU", BreakBeforeBraces, FormatStyle::BS_GNU); 12667 CHECK_PARSE("BreakBeforeBraces: WebKit", BreakBeforeBraces, 12668 FormatStyle::BS_WebKit); 12669 CHECK_PARSE("BreakBeforeBraces: Custom", BreakBeforeBraces, 12670 FormatStyle::BS_Custom); 12671 12672 Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Never; 12673 CHECK_PARSE("BraceWrapping:\n" 12674 " AfterControlStatement: MultiLine", 12675 BraceWrapping.AfterControlStatement, 12676 FormatStyle::BWACS_MultiLine); 12677 CHECK_PARSE("BraceWrapping:\n" 12678 " AfterControlStatement: Always", 12679 BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Always); 12680 CHECK_PARSE("BraceWrapping:\n" 12681 " AfterControlStatement: Never", 12682 BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Never); 12683 // For backward compatibility: 12684 CHECK_PARSE("BraceWrapping:\n" 12685 " AfterControlStatement: true", 12686 BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Always); 12687 CHECK_PARSE("BraceWrapping:\n" 12688 " AfterControlStatement: false", 12689 BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Never); 12690 12691 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All; 12692 CHECK_PARSE("AlwaysBreakAfterReturnType: None", AlwaysBreakAfterReturnType, 12693 FormatStyle::RTBS_None); 12694 CHECK_PARSE("AlwaysBreakAfterReturnType: All", AlwaysBreakAfterReturnType, 12695 FormatStyle::RTBS_All); 12696 CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevel", 12697 AlwaysBreakAfterReturnType, FormatStyle::RTBS_TopLevel); 12698 CHECK_PARSE("AlwaysBreakAfterReturnType: AllDefinitions", 12699 AlwaysBreakAfterReturnType, FormatStyle::RTBS_AllDefinitions); 12700 CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevelDefinitions", 12701 AlwaysBreakAfterReturnType, 12702 FormatStyle::RTBS_TopLevelDefinitions); 12703 12704 Style.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes; 12705 CHECK_PARSE("AlwaysBreakTemplateDeclarations: No", 12706 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_No); 12707 CHECK_PARSE("AlwaysBreakTemplateDeclarations: MultiLine", 12708 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_MultiLine); 12709 CHECK_PARSE("AlwaysBreakTemplateDeclarations: Yes", 12710 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_Yes); 12711 CHECK_PARSE("AlwaysBreakTemplateDeclarations: false", 12712 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_MultiLine); 12713 CHECK_PARSE("AlwaysBreakTemplateDeclarations: true", 12714 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_Yes); 12715 12716 Style.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_All; 12717 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: None", 12718 AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_None); 12719 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: All", 12720 AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_All); 12721 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: TopLevel", 12722 AlwaysBreakAfterDefinitionReturnType, 12723 FormatStyle::DRTBS_TopLevel); 12724 12725 Style.NamespaceIndentation = FormatStyle::NI_All; 12726 CHECK_PARSE("NamespaceIndentation: None", NamespaceIndentation, 12727 FormatStyle::NI_None); 12728 CHECK_PARSE("NamespaceIndentation: Inner", NamespaceIndentation, 12729 FormatStyle::NI_Inner); 12730 CHECK_PARSE("NamespaceIndentation: All", NamespaceIndentation, 12731 FormatStyle::NI_All); 12732 12733 Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Always; 12734 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Never", 12735 AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never); 12736 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: WithoutElse", 12737 AllowShortIfStatementsOnASingleLine, 12738 FormatStyle::SIS_WithoutElse); 12739 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Always", 12740 AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Always); 12741 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: false", 12742 AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never); 12743 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: true", 12744 AllowShortIfStatementsOnASingleLine, 12745 FormatStyle::SIS_WithoutElse); 12746 12747 // FIXME: This is required because parsing a configuration simply overwrites 12748 // the first N elements of the list instead of resetting it. 12749 Style.ForEachMacros.clear(); 12750 std::vector<std::string> BoostForeach; 12751 BoostForeach.push_back("BOOST_FOREACH"); 12752 CHECK_PARSE("ForEachMacros: [BOOST_FOREACH]", ForEachMacros, BoostForeach); 12753 std::vector<std::string> BoostAndQForeach; 12754 BoostAndQForeach.push_back("BOOST_FOREACH"); 12755 BoostAndQForeach.push_back("Q_FOREACH"); 12756 CHECK_PARSE("ForEachMacros: [BOOST_FOREACH, Q_FOREACH]", ForEachMacros, 12757 BoostAndQForeach); 12758 12759 Style.StatementMacros.clear(); 12760 CHECK_PARSE("StatementMacros: [QUNUSED]", StatementMacros, 12761 std::vector<std::string>{"QUNUSED"}); 12762 CHECK_PARSE("StatementMacros: [QUNUSED, QT_REQUIRE_VERSION]", StatementMacros, 12763 std::vector<std::string>({"QUNUSED", "QT_REQUIRE_VERSION"})); 12764 12765 Style.NamespaceMacros.clear(); 12766 CHECK_PARSE("NamespaceMacros: [TESTSUITE]", NamespaceMacros, 12767 std::vector<std::string>{"TESTSUITE"}); 12768 CHECK_PARSE("NamespaceMacros: [TESTSUITE, SUITE]", NamespaceMacros, 12769 std::vector<std::string>({"TESTSUITE", "SUITE"})); 12770 12771 Style.IncludeStyle.IncludeCategories.clear(); 12772 std::vector<tooling::IncludeStyle::IncludeCategory> ExpectedCategories = { 12773 {"abc/.*", 2, 0}, {".*", 1, 0}}; 12774 CHECK_PARSE("IncludeCategories:\n" 12775 " - Regex: abc/.*\n" 12776 " Priority: 2\n" 12777 " - Regex: .*\n" 12778 " Priority: 1", 12779 IncludeStyle.IncludeCategories, ExpectedCategories); 12780 CHECK_PARSE("IncludeIsMainRegex: 'abc$'", IncludeStyle.IncludeIsMainRegex, 12781 "abc$"); 12782 12783 Style.RawStringFormats.clear(); 12784 std::vector<FormatStyle::RawStringFormat> ExpectedRawStringFormats = { 12785 { 12786 FormatStyle::LK_TextProto, 12787 {"pb", "proto"}, 12788 {"PARSE_TEXT_PROTO"}, 12789 /*CanonicalDelimiter=*/"", 12790 "llvm", 12791 }, 12792 { 12793 FormatStyle::LK_Cpp, 12794 {"cc", "cpp"}, 12795 {"C_CODEBLOCK", "CPPEVAL"}, 12796 /*CanonicalDelimiter=*/"cc", 12797 /*BasedOnStyle=*/"", 12798 }, 12799 }; 12800 12801 CHECK_PARSE("RawStringFormats:\n" 12802 " - Language: TextProto\n" 12803 " Delimiters:\n" 12804 " - 'pb'\n" 12805 " - 'proto'\n" 12806 " EnclosingFunctions:\n" 12807 " - 'PARSE_TEXT_PROTO'\n" 12808 " BasedOnStyle: llvm\n" 12809 " - Language: Cpp\n" 12810 " Delimiters:\n" 12811 " - 'cc'\n" 12812 " - 'cpp'\n" 12813 " EnclosingFunctions:\n" 12814 " - 'C_CODEBLOCK'\n" 12815 " - 'CPPEVAL'\n" 12816 " CanonicalDelimiter: 'cc'", 12817 RawStringFormats, ExpectedRawStringFormats); 12818 } 12819 12820 TEST_F(FormatTest, ParsesConfigurationWithLanguages) { 12821 FormatStyle Style = {}; 12822 Style.Language = FormatStyle::LK_Cpp; 12823 CHECK_PARSE("Language: Cpp\n" 12824 "IndentWidth: 12", 12825 IndentWidth, 12u); 12826 EXPECT_EQ(parseConfiguration("Language: JavaScript\n" 12827 "IndentWidth: 34", 12828 &Style), 12829 ParseError::Unsuitable); 12830 EXPECT_EQ(12u, Style.IndentWidth); 12831 CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u); 12832 EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language); 12833 12834 Style.Language = FormatStyle::LK_JavaScript; 12835 CHECK_PARSE("Language: JavaScript\n" 12836 "IndentWidth: 12", 12837 IndentWidth, 12u); 12838 CHECK_PARSE("IndentWidth: 23", IndentWidth, 23u); 12839 EXPECT_EQ(parseConfiguration("Language: Cpp\n" 12840 "IndentWidth: 34", 12841 &Style), 12842 ParseError::Unsuitable); 12843 EXPECT_EQ(23u, Style.IndentWidth); 12844 CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u); 12845 EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language); 12846 12847 CHECK_PARSE("BasedOnStyle: LLVM\n" 12848 "IndentWidth: 67", 12849 IndentWidth, 67u); 12850 12851 CHECK_PARSE("---\n" 12852 "Language: JavaScript\n" 12853 "IndentWidth: 12\n" 12854 "---\n" 12855 "Language: Cpp\n" 12856 "IndentWidth: 34\n" 12857 "...\n", 12858 IndentWidth, 12u); 12859 12860 Style.Language = FormatStyle::LK_Cpp; 12861 CHECK_PARSE("---\n" 12862 "Language: JavaScript\n" 12863 "IndentWidth: 12\n" 12864 "---\n" 12865 "Language: Cpp\n" 12866 "IndentWidth: 34\n" 12867 "...\n", 12868 IndentWidth, 34u); 12869 CHECK_PARSE("---\n" 12870 "IndentWidth: 78\n" 12871 "---\n" 12872 "Language: JavaScript\n" 12873 "IndentWidth: 56\n" 12874 "...\n", 12875 IndentWidth, 78u); 12876 12877 Style.ColumnLimit = 123; 12878 Style.IndentWidth = 234; 12879 Style.BreakBeforeBraces = FormatStyle::BS_Linux; 12880 Style.TabWidth = 345; 12881 EXPECT_FALSE(parseConfiguration("---\n" 12882 "IndentWidth: 456\n" 12883 "BreakBeforeBraces: Allman\n" 12884 "---\n" 12885 "Language: JavaScript\n" 12886 "IndentWidth: 111\n" 12887 "TabWidth: 111\n" 12888 "---\n" 12889 "Language: Cpp\n" 12890 "BreakBeforeBraces: Stroustrup\n" 12891 "TabWidth: 789\n" 12892 "...\n", 12893 &Style)); 12894 EXPECT_EQ(123u, Style.ColumnLimit); 12895 EXPECT_EQ(456u, Style.IndentWidth); 12896 EXPECT_EQ(FormatStyle::BS_Stroustrup, Style.BreakBeforeBraces); 12897 EXPECT_EQ(789u, Style.TabWidth); 12898 12899 EXPECT_EQ(parseConfiguration("---\n" 12900 "Language: JavaScript\n" 12901 "IndentWidth: 56\n" 12902 "---\n" 12903 "IndentWidth: 78\n" 12904 "...\n", 12905 &Style), 12906 ParseError::Error); 12907 EXPECT_EQ(parseConfiguration("---\n" 12908 "Language: JavaScript\n" 12909 "IndentWidth: 56\n" 12910 "---\n" 12911 "Language: JavaScript\n" 12912 "IndentWidth: 78\n" 12913 "...\n", 12914 &Style), 12915 ParseError::Error); 12916 12917 EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language); 12918 } 12919 12920 #undef CHECK_PARSE 12921 12922 TEST_F(FormatTest, UsesLanguageForBasedOnStyle) { 12923 FormatStyle Style = {}; 12924 Style.Language = FormatStyle::LK_JavaScript; 12925 Style.BreakBeforeTernaryOperators = true; 12926 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Style).value()); 12927 EXPECT_FALSE(Style.BreakBeforeTernaryOperators); 12928 12929 Style.BreakBeforeTernaryOperators = true; 12930 EXPECT_EQ(0, parseConfiguration("---\n" 12931 "BasedOnStyle: Google\n" 12932 "---\n" 12933 "Language: JavaScript\n" 12934 "IndentWidth: 76\n" 12935 "...\n", 12936 &Style) 12937 .value()); 12938 EXPECT_FALSE(Style.BreakBeforeTernaryOperators); 12939 EXPECT_EQ(76u, Style.IndentWidth); 12940 EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language); 12941 } 12942 12943 TEST_F(FormatTest, ConfigurationRoundTripTest) { 12944 FormatStyle Style = getLLVMStyle(); 12945 std::string YAML = configurationAsText(Style); 12946 FormatStyle ParsedStyle = {}; 12947 ParsedStyle.Language = FormatStyle::LK_Cpp; 12948 EXPECT_EQ(0, parseConfiguration(YAML, &ParsedStyle).value()); 12949 EXPECT_EQ(Style, ParsedStyle); 12950 } 12951 12952 TEST_F(FormatTest, WorksFor8bitEncodings) { 12953 EXPECT_EQ("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 \"\n" 12954 "\"\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \"\n" 12955 "\"\xe7\xe8\xec\xed\xfe\xfe \"\n" 12956 "\"\xef\xee\xf0\xf3...\"", 12957 format("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 " 12958 "\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \xe7\xe8\xec\xed\xfe\xfe " 12959 "\xef\xee\xf0\xf3...\"", 12960 getLLVMStyleWithColumns(12))); 12961 } 12962 12963 TEST_F(FormatTest, HandlesUTF8BOM) { 12964 EXPECT_EQ("\xef\xbb\xbf", format("\xef\xbb\xbf")); 12965 EXPECT_EQ("\xef\xbb\xbf#include <iostream>", 12966 format("\xef\xbb\xbf#include <iostream>")); 12967 EXPECT_EQ("\xef\xbb\xbf\n#include <iostream>", 12968 format("\xef\xbb\xbf\n#include <iostream>")); 12969 } 12970 12971 // FIXME: Encode Cyrillic and CJK characters below to appease MS compilers. 12972 #if !defined(_MSC_VER) 12973 12974 TEST_F(FormatTest, CountsUTF8CharactersProperly) { 12975 verifyFormat("\"Однажды в студёную зимнюю пору...\"", 12976 getLLVMStyleWithColumns(35)); 12977 verifyFormat("\"一 二 三 四 五 六 七 八 九 十\"", 12978 getLLVMStyleWithColumns(31)); 12979 verifyFormat("// Однажды в студёную зимнюю пору...", 12980 getLLVMStyleWithColumns(36)); 12981 verifyFormat("// 一 二 三 四 五 六 七 八 九 十", getLLVMStyleWithColumns(32)); 12982 verifyFormat("/* Однажды в студёную зимнюю пору... */", 12983 getLLVMStyleWithColumns(39)); 12984 verifyFormat("/* 一 二 三 四 五 六 七 八 九 十 */", 12985 getLLVMStyleWithColumns(35)); 12986 } 12987 12988 TEST_F(FormatTest, SplitsUTF8Strings) { 12989 // Non-printable characters' width is currently considered to be the length in 12990 // bytes in UTF8. The characters can be displayed in very different manner 12991 // (zero-width, single width with a substitution glyph, expanded to their code 12992 // (e.g. "<8d>"), so there's no single correct way to handle them. 12993 EXPECT_EQ("\"aaaaÄ\"\n" 12994 "\"\xc2\x8d\";", 12995 format("\"aaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10))); 12996 EXPECT_EQ("\"aaaaaaaÄ\"\n" 12997 "\"\xc2\x8d\";", 12998 format("\"aaaaaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10))); 12999 EXPECT_EQ("\"Однажды, в \"\n" 13000 "\"студёную \"\n" 13001 "\"зимнюю \"\n" 13002 "\"пору,\"", 13003 format("\"Однажды, в студёную зимнюю пору,\"", 13004 getLLVMStyleWithColumns(13))); 13005 EXPECT_EQ( 13006 "\"一 二 三 \"\n" 13007 "\"四 五六 \"\n" 13008 "\"七 八 九 \"\n" 13009 "\"十\"", 13010 format("\"一 二 三 四 五六 七 八 九 十\"", getLLVMStyleWithColumns(11))); 13011 EXPECT_EQ("\"一\t\"\n" 13012 "\"二 \t\"\n" 13013 "\"三 四 \"\n" 13014 "\"五\t\"\n" 13015 "\"六 \t\"\n" 13016 "\"七 \"\n" 13017 "\"八九十\tqq\"", 13018 format("\"一\t二 \t三 四 五\t六 \t七 八九十\tqq\"", 13019 getLLVMStyleWithColumns(11))); 13020 13021 // UTF8 character in an escape sequence. 13022 EXPECT_EQ("\"aaaaaa\"\n" 13023 "\"\\\xC2\x8D\"", 13024 format("\"aaaaaa\\\xC2\x8D\"", getLLVMStyleWithColumns(10))); 13025 } 13026 13027 TEST_F(FormatTest, HandlesDoubleWidthCharsInMultiLineStrings) { 13028 EXPECT_EQ("const char *sssss =\n" 13029 " \"一二三四五六七八\\\n" 13030 " 九 十\";", 13031 format("const char *sssss = \"一二三四五六七八\\\n" 13032 " 九 十\";", 13033 getLLVMStyleWithColumns(30))); 13034 } 13035 13036 TEST_F(FormatTest, SplitsUTF8LineComments) { 13037 EXPECT_EQ("// aaaaÄ\xc2\x8d", 13038 format("// aaaaÄ\xc2\x8d", getLLVMStyleWithColumns(10))); 13039 EXPECT_EQ("// Я из лесу\n" 13040 "// вышел; был\n" 13041 "// сильный\n" 13042 "// мороз.", 13043 format("// Я из лесу вышел; был сильный мороз.", 13044 getLLVMStyleWithColumns(13))); 13045 EXPECT_EQ("// 一二三\n" 13046 "// 四五六七\n" 13047 "// 八 九\n" 13048 "// 十", 13049 format("// 一二三 四五六七 八 九 十", getLLVMStyleWithColumns(9))); 13050 } 13051 13052 TEST_F(FormatTest, SplitsUTF8BlockComments) { 13053 EXPECT_EQ("/* Гляжу,\n" 13054 " * поднимается\n" 13055 " * медленно в\n" 13056 " * гору\n" 13057 " * Лошадка,\n" 13058 " * везущая\n" 13059 " * хворосту\n" 13060 " * воз. */", 13061 format("/* Гляжу, поднимается медленно в гору\n" 13062 " * Лошадка, везущая хворосту воз. */", 13063 getLLVMStyleWithColumns(13))); 13064 EXPECT_EQ( 13065 "/* 一二三\n" 13066 " * 四五六七\n" 13067 " * 八 九\n" 13068 " * 十 */", 13069 format("/* 一二三 四五六七 八 九 十 */", getLLVMStyleWithColumns(9))); 13070 EXPECT_EQ("/* �������� ��������\n" 13071 " * ��������\n" 13072 " * ������-�� */", 13073 format("/* �������� �������� �������� ������-�� */", getLLVMStyleWithColumns(12))); 13074 } 13075 13076 #endif // _MSC_VER 13077 13078 TEST_F(FormatTest, ConstructorInitializerIndentWidth) { 13079 FormatStyle Style = getLLVMStyle(); 13080 13081 Style.ConstructorInitializerIndentWidth = 4; 13082 verifyFormat( 13083 "SomeClass::Constructor()\n" 13084 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 13085 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 13086 Style); 13087 13088 Style.ConstructorInitializerIndentWidth = 2; 13089 verifyFormat( 13090 "SomeClass::Constructor()\n" 13091 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 13092 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 13093 Style); 13094 13095 Style.ConstructorInitializerIndentWidth = 0; 13096 verifyFormat( 13097 "SomeClass::Constructor()\n" 13098 ": aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 13099 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 13100 Style); 13101 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 13102 verifyFormat( 13103 "SomeLongTemplateVariableName<\n" 13104 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>", 13105 Style); 13106 verifyFormat("bool smaller = 1 < " 13107 "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 13108 " " 13109 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 13110 Style); 13111 13112 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 13113 verifyFormat("SomeClass::Constructor() :\n" 13114 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa),\n" 13115 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa) {}", 13116 Style); 13117 } 13118 13119 TEST_F(FormatTest, BreakConstructorInitializersBeforeComma) { 13120 FormatStyle Style = getLLVMStyle(); 13121 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 13122 Style.ConstructorInitializerIndentWidth = 4; 13123 verifyFormat("SomeClass::Constructor()\n" 13124 " : a(a)\n" 13125 " , b(b)\n" 13126 " , c(c) {}", 13127 Style); 13128 verifyFormat("SomeClass::Constructor()\n" 13129 " : a(a) {}", 13130 Style); 13131 13132 Style.ColumnLimit = 0; 13133 verifyFormat("SomeClass::Constructor()\n" 13134 " : a(a) {}", 13135 Style); 13136 verifyFormat("SomeClass::Constructor() noexcept\n" 13137 " : a(a) {}", 13138 Style); 13139 verifyFormat("SomeClass::Constructor()\n" 13140 " : a(a)\n" 13141 " , b(b)\n" 13142 " , c(c) {}", 13143 Style); 13144 verifyFormat("SomeClass::Constructor()\n" 13145 " : a(a) {\n" 13146 " foo();\n" 13147 " bar();\n" 13148 "}", 13149 Style); 13150 13151 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 13152 verifyFormat("SomeClass::Constructor()\n" 13153 " : a(a)\n" 13154 " , b(b)\n" 13155 " , c(c) {\n}", 13156 Style); 13157 verifyFormat("SomeClass::Constructor()\n" 13158 " : a(a) {\n}", 13159 Style); 13160 13161 Style.ColumnLimit = 80; 13162 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 13163 Style.ConstructorInitializerIndentWidth = 2; 13164 verifyFormat("SomeClass::Constructor()\n" 13165 " : a(a)\n" 13166 " , b(b)\n" 13167 " , c(c) {}", 13168 Style); 13169 13170 Style.ConstructorInitializerIndentWidth = 0; 13171 verifyFormat("SomeClass::Constructor()\n" 13172 ": a(a)\n" 13173 ", b(b)\n" 13174 ", c(c) {}", 13175 Style); 13176 13177 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 13178 Style.ConstructorInitializerIndentWidth = 4; 13179 verifyFormat("SomeClass::Constructor() : aaaaaaaa(aaaaaaaa) {}", Style); 13180 verifyFormat( 13181 "SomeClass::Constructor() : aaaaa(aaaaa), aaaaa(aaaaa), aaaaa(aaaaa)\n", 13182 Style); 13183 verifyFormat( 13184 "SomeClass::Constructor()\n" 13185 " : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa) {}", 13186 Style); 13187 Style.ConstructorInitializerIndentWidth = 4; 13188 Style.ColumnLimit = 60; 13189 verifyFormat("SomeClass::Constructor()\n" 13190 " : aaaaaaaa(aaaaaaaa)\n" 13191 " , aaaaaaaa(aaaaaaaa)\n" 13192 " , aaaaaaaa(aaaaaaaa) {}", 13193 Style); 13194 } 13195 13196 TEST_F(FormatTest, Destructors) { 13197 verifyFormat("void F(int &i) { i.~int(); }"); 13198 verifyFormat("void F(int &i) { i->~int(); }"); 13199 } 13200 13201 TEST_F(FormatTest, FormatsWithWebKitStyle) { 13202 FormatStyle Style = getWebKitStyle(); 13203 13204 // Don't indent in outer namespaces. 13205 verifyFormat("namespace outer {\n" 13206 "int i;\n" 13207 "namespace inner {\n" 13208 " int i;\n" 13209 "} // namespace inner\n" 13210 "} // namespace outer\n" 13211 "namespace other_outer {\n" 13212 "int i;\n" 13213 "}", 13214 Style); 13215 13216 // Don't indent case labels. 13217 verifyFormat("switch (variable) {\n" 13218 "case 1:\n" 13219 "case 2:\n" 13220 " doSomething();\n" 13221 " break;\n" 13222 "default:\n" 13223 " ++variable;\n" 13224 "}", 13225 Style); 13226 13227 // Wrap before binary operators. 13228 EXPECT_EQ("void f()\n" 13229 "{\n" 13230 " if (aaaaaaaaaaaaaaaa\n" 13231 " && bbbbbbbbbbbbbbbbbbbbbbbb\n" 13232 " && (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n" 13233 " return;\n" 13234 "}", 13235 format("void f() {\n" 13236 "if (aaaaaaaaaaaaaaaa\n" 13237 "&& bbbbbbbbbbbbbbbbbbbbbbbb\n" 13238 "&& (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n" 13239 "return;\n" 13240 "}", 13241 Style)); 13242 13243 // Allow functions on a single line. 13244 verifyFormat("void f() { return; }", Style); 13245 13246 // Allow empty blocks on a single line and insert a space in empty blocks. 13247 EXPECT_EQ("void f() { }", format("void f() {}", Style)); 13248 EXPECT_EQ("while (true) { }", format("while (true) {}", Style)); 13249 // However, don't merge non-empty short loops. 13250 EXPECT_EQ("while (true) {\n" 13251 " continue;\n" 13252 "}", 13253 format("while (true) { continue; }", Style)); 13254 13255 // Constructor initializers are formatted one per line with the "," on the 13256 // new line. 13257 verifyFormat("Constructor()\n" 13258 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 13259 " , aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaa, // break\n" 13260 " aaaaaaaaaaaaaa)\n" 13261 " , aaaaaaaaaaaaaaaaaaaaaaa()\n" 13262 "{\n" 13263 "}", 13264 Style); 13265 verifyFormat("SomeClass::Constructor()\n" 13266 " : a(a)\n" 13267 "{\n" 13268 "}", 13269 Style); 13270 EXPECT_EQ("SomeClass::Constructor()\n" 13271 " : a(a)\n" 13272 "{\n" 13273 "}", 13274 format("SomeClass::Constructor():a(a){}", Style)); 13275 verifyFormat("SomeClass::Constructor()\n" 13276 " : a(a)\n" 13277 " , b(b)\n" 13278 " , c(c)\n" 13279 "{\n" 13280 "}", 13281 Style); 13282 verifyFormat("SomeClass::Constructor()\n" 13283 " : a(a)\n" 13284 "{\n" 13285 " foo();\n" 13286 " bar();\n" 13287 "}", 13288 Style); 13289 13290 // Access specifiers should be aligned left. 13291 verifyFormat("class C {\n" 13292 "public:\n" 13293 " int i;\n" 13294 "};", 13295 Style); 13296 13297 // Do not align comments. 13298 verifyFormat("int a; // Do not\n" 13299 "double b; // align comments.", 13300 Style); 13301 13302 // Do not align operands. 13303 EXPECT_EQ("ASSERT(aaaa\n" 13304 " || bbbb);", 13305 format("ASSERT ( aaaa\n||bbbb);", Style)); 13306 13307 // Accept input's line breaks. 13308 EXPECT_EQ("if (aaaaaaaaaaaaaaa\n" 13309 " || bbbbbbbbbbbbbbb) {\n" 13310 " i++;\n" 13311 "}", 13312 format("if (aaaaaaaaaaaaaaa\n" 13313 "|| bbbbbbbbbbbbbbb) { i++; }", 13314 Style)); 13315 EXPECT_EQ("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) {\n" 13316 " i++;\n" 13317 "}", 13318 format("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) { i++; }", Style)); 13319 13320 // Don't automatically break all macro definitions (llvm.org/PR17842). 13321 verifyFormat("#define aNumber 10", Style); 13322 // However, generally keep the line breaks that the user authored. 13323 EXPECT_EQ("#define aNumber \\\n" 13324 " 10", 13325 format("#define aNumber \\\n" 13326 " 10", 13327 Style)); 13328 13329 // Keep empty and one-element array literals on a single line. 13330 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[]\n" 13331 " copyItems:YES];", 13332 format("NSArray*a=[[NSArray alloc] initWithArray:@[]\n" 13333 "copyItems:YES];", 13334 Style)); 13335 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\" ]\n" 13336 " copyItems:YES];", 13337 format("NSArray*a=[[NSArray alloc]initWithArray:@[ @\"a\" ]\n" 13338 " copyItems:YES];", 13339 Style)); 13340 // FIXME: This does not seem right, there should be more indentation before 13341 // the array literal's entries. Nested blocks have the same problem. 13342 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[\n" 13343 " @\"a\",\n" 13344 " @\"a\"\n" 13345 "]\n" 13346 " copyItems:YES];", 13347 format("NSArray* a = [[NSArray alloc] initWithArray:@[\n" 13348 " @\"a\",\n" 13349 " @\"a\"\n" 13350 " ]\n" 13351 " copyItems:YES];", 13352 Style)); 13353 EXPECT_EQ( 13354 "NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n" 13355 " copyItems:YES];", 13356 format("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n" 13357 " copyItems:YES];", 13358 Style)); 13359 13360 verifyFormat("[self.a b:c c:d];", Style); 13361 EXPECT_EQ("[self.a b:c\n" 13362 " c:d];", 13363 format("[self.a b:c\n" 13364 "c:d];", 13365 Style)); 13366 } 13367 13368 TEST_F(FormatTest, FormatsLambdas) { 13369 verifyFormat("int c = [b]() mutable { return [&b] { return b++; }(); }();\n"); 13370 verifyFormat( 13371 "int c = [b]() mutable noexcept { return [&b] { return b++; }(); }();\n"); 13372 verifyFormat("int c = [&] { [=] { return b++; }(); }();\n"); 13373 verifyFormat("int c = [&, &a, a] { [=, c, &d] { return b++; }(); }();\n"); 13374 verifyFormat("int c = [&a, &a, a] { [=, a, b, &c] { return b++; }(); }();\n"); 13375 verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] { return b++; }(); }}\n"); 13376 verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] {}(); }}\n"); 13377 verifyFormat("auto c = [a = [b = 42] {}] {};\n"); 13378 verifyFormat("auto c = [a = &i + 10, b = [] {}] {};\n"); 13379 verifyFormat("int x = f(*+[] {});"); 13380 verifyFormat("void f() {\n" 13381 " other(x.begin(), x.end(), [&](int, int) { return 1; });\n" 13382 "}\n"); 13383 verifyFormat("void f() {\n" 13384 " other(x.begin(), //\n" 13385 " x.end(), //\n" 13386 " [&](int, int) { return 1; });\n" 13387 "}\n"); 13388 verifyFormat("void f() {\n" 13389 " other.other.other.other.other(\n" 13390 " x.begin(), x.end(),\n" 13391 " [something, rather](int, int, int, int, int, int, int) { " 13392 "return 1; });\n" 13393 "}\n"); 13394 verifyFormat( 13395 "void f() {\n" 13396 " other.other.other.other.other(\n" 13397 " x.begin(), x.end(),\n" 13398 " [something, rather](int, int, int, int, int, int, int) {\n" 13399 " //\n" 13400 " });\n" 13401 "}\n"); 13402 verifyFormat("SomeFunction([]() { // A cool function...\n" 13403 " return 43;\n" 13404 "});"); 13405 EXPECT_EQ("SomeFunction([]() {\n" 13406 "#define A a\n" 13407 " return 43;\n" 13408 "});", 13409 format("SomeFunction([](){\n" 13410 "#define A a\n" 13411 "return 43;\n" 13412 "});")); 13413 verifyFormat("void f() {\n" 13414 " SomeFunction([](decltype(x), A *a) {});\n" 13415 "}"); 13416 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 13417 " [](const aaaaaaaaaa &a) { return a; });"); 13418 verifyFormat("string abc = SomeFunction(aaaaaaaaaaaaa, aaaaa, []() {\n" 13419 " SomeOtherFunctioooooooooooooooooooooooooon();\n" 13420 "});"); 13421 verifyFormat("Constructor()\n" 13422 " : Field([] { // comment\n" 13423 " int i;\n" 13424 " }) {}"); 13425 verifyFormat("auto my_lambda = [](const string &some_parameter) {\n" 13426 " return some_parameter.size();\n" 13427 "};"); 13428 verifyFormat("std::function<std::string(const std::string &)> my_lambda =\n" 13429 " [](const string &s) { return s; };"); 13430 verifyFormat("int i = aaaaaa ? 1 //\n" 13431 " : [] {\n" 13432 " return 2; //\n" 13433 " }();"); 13434 verifyFormat("llvm::errs() << \"number of twos is \"\n" 13435 " << std::count_if(v.begin(), v.end(), [](int x) {\n" 13436 " return x == 2; // force break\n" 13437 " });"); 13438 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 13439 " [=](int iiiiiiiiiiii) {\n" 13440 " return aaaaaaaaaaaaaaaaaaaaaaa !=\n" 13441 " aaaaaaaaaaaaaaaaaaaaaaa;\n" 13442 " });", 13443 getLLVMStyleWithColumns(60)); 13444 verifyFormat("SomeFunction({[&] {\n" 13445 " // comment\n" 13446 " },\n" 13447 " [&] {\n" 13448 " // comment\n" 13449 " }});"); 13450 verifyFormat("SomeFunction({[&] {\n" 13451 " // comment\n" 13452 "}});"); 13453 verifyFormat( 13454 "virtual aaaaaaaaaaaaaaaa(\n" 13455 " std::function<bool()> bbbbbbbbbbbb = [&]() { return true; },\n" 13456 " aaaaa aaaaaaaaa);"); 13457 13458 // Lambdas with return types. 13459 verifyFormat("int c = []() -> int { return 2; }();\n"); 13460 verifyFormat("int c = []() -> int * { return 2; }();\n"); 13461 verifyFormat("int c = []() -> vector<int> { return {2}; }();\n"); 13462 verifyFormat("Foo([]() -> std::vector<int> { return {2}; }());"); 13463 verifyGoogleFormat("auto a = [&b, c](D* d) -> D* {};"); 13464 verifyGoogleFormat("auto a = [&b, c](D* d) -> pair<D*, D*> {};"); 13465 verifyGoogleFormat("auto a = [&b, c](D* d) -> D& {};"); 13466 verifyGoogleFormat("auto a = [&b, c](D* d) -> const D* {};"); 13467 verifyFormat("[a, a]() -> a<1> {};"); 13468 verifyFormat("[]() -> foo<5 + 2> { return {}; };"); 13469 verifyFormat("[]() -> foo<5 - 2> { return {}; };"); 13470 verifyFormat("[]() -> foo<5 / 2> { return {}; };"); 13471 verifyFormat("[]() -> foo<5 * 2> { return {}; };"); 13472 verifyFormat("[]() -> foo<5 % 2> { return {}; };"); 13473 verifyFormat("[]() -> foo<5 << 2> { return {}; };"); 13474 verifyFormat("[]() -> foo<!5> { return {}; };"); 13475 verifyFormat("[]() -> foo<~5> { return {}; };"); 13476 verifyFormat("[]() -> foo<5 | 2> { return {}; };"); 13477 verifyFormat("[]() -> foo<5 || 2> { return {}; };"); 13478 verifyFormat("[]() -> foo<5 & 2> { return {}; };"); 13479 verifyFormat("[]() -> foo<5 && 2> { return {}; };"); 13480 verifyFormat("[]() -> foo<5 == 2> { return {}; };"); 13481 verifyFormat("[]() -> foo<5 != 2> { return {}; };"); 13482 verifyFormat("[]() -> foo<5 >= 2> { return {}; };"); 13483 verifyFormat("[]() -> foo<5 <= 2> { return {}; };"); 13484 verifyFormat("[]() -> foo<5 < 2> { return {}; };"); 13485 verifyFormat("[]() -> foo<2 ? 1 : 0> { return {}; };"); 13486 verifyFormat("namespace bar {\n" 13487 "// broken:\n" 13488 "auto foo{[]() -> foo<5 + 2> { return {}; }};\n" 13489 "} // namespace bar"); 13490 verifyFormat("namespace bar {\n" 13491 "// broken:\n" 13492 "auto foo{[]() -> foo<5 - 2> { return {}; }};\n" 13493 "} // namespace bar"); 13494 verifyFormat("namespace bar {\n" 13495 "// broken:\n" 13496 "auto foo{[]() -> foo<5 / 2> { return {}; }};\n" 13497 "} // namespace bar"); 13498 verifyFormat("namespace bar {\n" 13499 "// broken:\n" 13500 "auto foo{[]() -> foo<5 * 2> { return {}; }};\n" 13501 "} // namespace bar"); 13502 verifyFormat("namespace bar {\n" 13503 "// broken:\n" 13504 "auto foo{[]() -> foo<5 % 2> { return {}; }};\n" 13505 "} // namespace bar"); 13506 verifyFormat("namespace bar {\n" 13507 "// broken:\n" 13508 "auto foo{[]() -> foo<5 << 2> { return {}; }};\n" 13509 "} // namespace bar"); 13510 verifyFormat("namespace bar {\n" 13511 "// broken:\n" 13512 "auto foo{[]() -> foo<!5> { return {}; }};\n" 13513 "} // namespace bar"); 13514 verifyFormat("namespace bar {\n" 13515 "// broken:\n" 13516 "auto foo{[]() -> foo<~5> { return {}; }};\n" 13517 "} // namespace bar"); 13518 verifyFormat("namespace bar {\n" 13519 "// broken:\n" 13520 "auto foo{[]() -> foo<5 | 2> { return {}; }};\n" 13521 "} // namespace bar"); 13522 verifyFormat("namespace bar {\n" 13523 "// broken:\n" 13524 "auto foo{[]() -> foo<5 || 2> { return {}; }};\n" 13525 "} // namespace bar"); 13526 verifyFormat("namespace bar {\n" 13527 "// broken:\n" 13528 "auto foo{[]() -> foo<5 & 2> { return {}; }};\n" 13529 "} // namespace bar"); 13530 verifyFormat("namespace bar {\n" 13531 "// broken:\n" 13532 "auto foo{[]() -> foo<5 && 2> { return {}; }};\n" 13533 "} // namespace bar"); 13534 verifyFormat("namespace bar {\n" 13535 "// broken:\n" 13536 "auto foo{[]() -> foo<5 == 2> { return {}; }};\n" 13537 "} // namespace bar"); 13538 verifyFormat("namespace bar {\n" 13539 "// broken:\n" 13540 "auto foo{[]() -> foo<5 != 2> { return {}; }};\n" 13541 "} // namespace bar"); 13542 verifyFormat("namespace bar {\n" 13543 "// broken:\n" 13544 "auto foo{[]() -> foo<5 >= 2> { return {}; }};\n" 13545 "} // namespace bar"); 13546 verifyFormat("namespace bar {\n" 13547 "// broken:\n" 13548 "auto foo{[]() -> foo<5 <= 2> { return {}; }};\n" 13549 "} // namespace bar"); 13550 verifyFormat("namespace bar {\n" 13551 "// broken:\n" 13552 "auto foo{[]() -> foo<5 < 2> { return {}; }};\n" 13553 "} // namespace bar"); 13554 verifyFormat("namespace bar {\n" 13555 "// broken:\n" 13556 "auto foo{[]() -> foo<2 ? 1 : 0> { return {}; }};\n" 13557 "} // namespace bar"); 13558 verifyFormat("[]() -> a<1> {};"); 13559 verifyFormat("[]() -> a<1> { ; };"); 13560 verifyFormat("[]() -> a<1> { ; }();"); 13561 verifyFormat("[a, a]() -> a<true> {};"); 13562 verifyFormat("[]() -> a<true> {};"); 13563 verifyFormat("[]() -> a<true> { ; };"); 13564 verifyFormat("[]() -> a<true> { ; }();"); 13565 verifyFormat("[a, a]() -> a<false> {};"); 13566 verifyFormat("[]() -> a<false> {};"); 13567 verifyFormat("[]() -> a<false> { ; };"); 13568 verifyFormat("[]() -> a<false> { ; }();"); 13569 verifyFormat("auto foo{[]() -> foo<false> { ; }};"); 13570 verifyFormat("namespace bar {\n" 13571 "auto foo{[]() -> foo<false> { ; }};\n" 13572 "} // namespace bar"); 13573 verifyFormat("auto aaaaaaaa = [](int i, // break for some reason\n" 13574 " int j) -> int {\n" 13575 " return ffffffffffffffffffffffffffffffffffffffffffff(i * j);\n" 13576 "};"); 13577 verifyFormat( 13578 "aaaaaaaaaaaaaaaaaaaaaa(\n" 13579 " [](aaaaaaaaaaaaaaaaaaaaaaaaaaa &aaa) -> aaaaaaaaaaaaaaaa {\n" 13580 " return aaaaaaaaaaaaaaaaa;\n" 13581 " });", 13582 getLLVMStyleWithColumns(70)); 13583 verifyFormat("[]() //\n" 13584 " -> int {\n" 13585 " return 1; //\n" 13586 "};"); 13587 13588 // Lambdas with explicit template argument lists. 13589 verifyFormat( 13590 "auto L = []<template <typename> class T, class U>(T<U> &&a) {};\n"); 13591 13592 // Multiple lambdas in the same parentheses change indentation rules. These 13593 // lambdas are forced to start on new lines. 13594 verifyFormat("SomeFunction(\n" 13595 " []() {\n" 13596 " //\n" 13597 " },\n" 13598 " []() {\n" 13599 " //\n" 13600 " });"); 13601 13602 // A lambda passed as arg0 is always pushed to the next line. 13603 verifyFormat("SomeFunction(\n" 13604 " [this] {\n" 13605 " //\n" 13606 " },\n" 13607 " 1);\n"); 13608 13609 // A multi-line lambda passed as arg1 forces arg0 to be pushed out, just like 13610 // the arg0 case above. 13611 auto Style = getGoogleStyle(); 13612 Style.BinPackArguments = false; 13613 verifyFormat("SomeFunction(\n" 13614 " a,\n" 13615 " [this] {\n" 13616 " //\n" 13617 " },\n" 13618 " b);\n", 13619 Style); 13620 verifyFormat("SomeFunction(\n" 13621 " a,\n" 13622 " [this] {\n" 13623 " //\n" 13624 " },\n" 13625 " b);\n"); 13626 13627 // A lambda with a very long line forces arg0 to be pushed out irrespective of 13628 // the BinPackArguments value (as long as the code is wide enough). 13629 verifyFormat( 13630 "something->SomeFunction(\n" 13631 " a,\n" 13632 " [this] {\n" 13633 " " 13634 "D0000000000000000000000000000000000000000000000000000000000001();\n" 13635 " },\n" 13636 " b);\n"); 13637 13638 // A multi-line lambda is pulled up as long as the introducer fits on the 13639 // previous line and there are no further args. 13640 verifyFormat("function(1, [this, that] {\n" 13641 " //\n" 13642 "});\n"); 13643 verifyFormat("function([this, that] {\n" 13644 " //\n" 13645 "});\n"); 13646 // FIXME: this format is not ideal and we should consider forcing the first 13647 // arg onto its own line. 13648 verifyFormat("function(a, b, c, //\n" 13649 " d, [this, that] {\n" 13650 " //\n" 13651 " });\n"); 13652 13653 // Multiple lambdas are treated correctly even when there is a short arg0. 13654 verifyFormat("SomeFunction(\n" 13655 " 1,\n" 13656 " [this] {\n" 13657 " //\n" 13658 " },\n" 13659 " [this] {\n" 13660 " //\n" 13661 " },\n" 13662 " 1);\n"); 13663 13664 // More complex introducers. 13665 verifyFormat("return [i, args...] {};"); 13666 13667 // Not lambdas. 13668 verifyFormat("constexpr char hello[]{\"hello\"};"); 13669 verifyFormat("double &operator[](int i) { return 0; }\n" 13670 "int i;"); 13671 verifyFormat("std::unique_ptr<int[]> foo() {}"); 13672 verifyFormat("int i = a[a][a]->f();"); 13673 verifyFormat("int i = (*b)[a]->f();"); 13674 13675 // Other corner cases. 13676 verifyFormat("void f() {\n" 13677 " bar([]() {} // Did not respect SpacesBeforeTrailingComments\n" 13678 " );\n" 13679 "}"); 13680 13681 // Lambdas created through weird macros. 13682 verifyFormat("void f() {\n" 13683 " MACRO((const AA &a) { return 1; });\n" 13684 " MACRO((AA &a) { return 1; });\n" 13685 "}"); 13686 13687 verifyFormat("if (blah_blah(whatever, whatever, [] {\n" 13688 " doo_dah();\n" 13689 " doo_dah();\n" 13690 " })) {\n" 13691 "}"); 13692 verifyFormat("if constexpr (blah_blah(whatever, whatever, [] {\n" 13693 " doo_dah();\n" 13694 " doo_dah();\n" 13695 " })) {\n" 13696 "}"); 13697 verifyFormat("if CONSTEXPR (blah_blah(whatever, whatever, [] {\n" 13698 " doo_dah();\n" 13699 " doo_dah();\n" 13700 " })) {\n" 13701 "}"); 13702 verifyFormat("auto lambda = []() {\n" 13703 " int a = 2\n" 13704 "#if A\n" 13705 " + 2\n" 13706 "#endif\n" 13707 " ;\n" 13708 "};"); 13709 13710 // Lambdas with complex multiline introducers. 13711 verifyFormat( 13712 "aaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 13713 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]()\n" 13714 " -> ::std::unordered_set<\n" 13715 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> {\n" 13716 " //\n" 13717 " });"); 13718 13719 FormatStyle DoNotMerge = getLLVMStyle(); 13720 DoNotMerge.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None; 13721 verifyFormat("auto c = []() {\n" 13722 " return b;\n" 13723 "};", 13724 "auto c = []() { return b; };", DoNotMerge); 13725 verifyFormat("auto c = []() {\n" 13726 "};", 13727 " auto c = []() {};", DoNotMerge); 13728 13729 FormatStyle MergeEmptyOnly = getLLVMStyle(); 13730 MergeEmptyOnly.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Empty; 13731 verifyFormat("auto c = []() {\n" 13732 " return b;\n" 13733 "};", 13734 "auto c = []() {\n" 13735 " return b;\n" 13736 " };", 13737 MergeEmptyOnly); 13738 verifyFormat("auto c = []() {};", 13739 "auto c = []() {\n" 13740 "};", 13741 MergeEmptyOnly); 13742 13743 FormatStyle MergeInline = getLLVMStyle(); 13744 MergeInline.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Inline; 13745 verifyFormat("auto c = []() {\n" 13746 " return b;\n" 13747 "};", 13748 "auto c = []() { return b; };", MergeInline); 13749 verifyFormat("function([]() { return b; })", "function([]() { return b; })", 13750 MergeInline); 13751 verifyFormat("function([]() { return b; }, a)", 13752 "function([]() { return b; }, a)", MergeInline); 13753 verifyFormat("function(a, []() { return b; })", 13754 "function(a, []() { return b; })", MergeInline); 13755 } 13756 13757 TEST_F(FormatTest, EmptyLinesInLambdas) { 13758 verifyFormat("auto lambda = []() {\n" 13759 " x(); //\n" 13760 "};", 13761 "auto lambda = []() {\n" 13762 "\n" 13763 " x(); //\n" 13764 "\n" 13765 "};"); 13766 } 13767 13768 TEST_F(FormatTest, FormatsBlocks) { 13769 FormatStyle ShortBlocks = getLLVMStyle(); 13770 ShortBlocks.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always; 13771 verifyFormat("int (^Block)(int, int);", ShortBlocks); 13772 verifyFormat("int (^Block1)(int, int) = ^(int i, int j)", ShortBlocks); 13773 verifyFormat("void (^block)(int) = ^(id test) { int i; };", ShortBlocks); 13774 verifyFormat("void (^block)(int) = ^(int test) { int i; };", ShortBlocks); 13775 verifyFormat("void (^block)(int) = ^id(int test) { int i; };", ShortBlocks); 13776 verifyFormat("void (^block)(int) = ^int(int test) { int i; };", ShortBlocks); 13777 13778 verifyFormat("foo(^{ bar(); });", ShortBlocks); 13779 verifyFormat("foo(a, ^{ bar(); });", ShortBlocks); 13780 verifyFormat("{ void (^block)(Object *x); }", ShortBlocks); 13781 13782 verifyFormat("[operation setCompletionBlock:^{\n" 13783 " [self onOperationDone];\n" 13784 "}];"); 13785 verifyFormat("int i = {[operation setCompletionBlock:^{\n" 13786 " [self onOperationDone];\n" 13787 "}]};"); 13788 verifyFormat("[operation setCompletionBlock:^(int *i) {\n" 13789 " f();\n" 13790 "}];"); 13791 verifyFormat("int a = [operation block:^int(int *i) {\n" 13792 " return 1;\n" 13793 "}];"); 13794 verifyFormat("[myObject doSomethingWith:arg1\n" 13795 " aaa:^int(int *a) {\n" 13796 " return 1;\n" 13797 " }\n" 13798 " bbb:f(a * bbbbbbbb)];"); 13799 13800 verifyFormat("[operation setCompletionBlock:^{\n" 13801 " [self.delegate newDataAvailable];\n" 13802 "}];", 13803 getLLVMStyleWithColumns(60)); 13804 verifyFormat("dispatch_async(_fileIOQueue, ^{\n" 13805 " NSString *path = [self sessionFilePath];\n" 13806 " if (path) {\n" 13807 " // ...\n" 13808 " }\n" 13809 "});"); 13810 verifyFormat("[[SessionService sharedService]\n" 13811 " loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 13812 " if (window) {\n" 13813 " [self windowDidLoad:window];\n" 13814 " } else {\n" 13815 " [self errorLoadingWindow];\n" 13816 " }\n" 13817 " }];"); 13818 verifyFormat("void (^largeBlock)(void) = ^{\n" 13819 " // ...\n" 13820 "};\n", 13821 getLLVMStyleWithColumns(40)); 13822 verifyFormat("[[SessionService sharedService]\n" 13823 " loadWindowWithCompletionBlock: //\n" 13824 " ^(SessionWindow *window) {\n" 13825 " if (window) {\n" 13826 " [self windowDidLoad:window];\n" 13827 " } else {\n" 13828 " [self errorLoadingWindow];\n" 13829 " }\n" 13830 " }];", 13831 getLLVMStyleWithColumns(60)); 13832 verifyFormat("[myObject doSomethingWith:arg1\n" 13833 " firstBlock:^(Foo *a) {\n" 13834 " // ...\n" 13835 " int i;\n" 13836 " }\n" 13837 " secondBlock:^(Bar *b) {\n" 13838 " // ...\n" 13839 " int i;\n" 13840 " }\n" 13841 " thirdBlock:^Foo(Bar *b) {\n" 13842 " // ...\n" 13843 " int i;\n" 13844 " }];"); 13845 verifyFormat("[myObject doSomethingWith:arg1\n" 13846 " firstBlock:-1\n" 13847 " secondBlock:^(Bar *b) {\n" 13848 " // ...\n" 13849 " int i;\n" 13850 " }];"); 13851 13852 verifyFormat("f(^{\n" 13853 " @autoreleasepool {\n" 13854 " if (a) {\n" 13855 " g();\n" 13856 " }\n" 13857 " }\n" 13858 "});"); 13859 verifyFormat("Block b = ^int *(A *a, B *b) {}"); 13860 verifyFormat("BOOL (^aaa)(void) = ^BOOL {\n" 13861 "};"); 13862 13863 FormatStyle FourIndent = getLLVMStyle(); 13864 FourIndent.ObjCBlockIndentWidth = 4; 13865 verifyFormat("[operation setCompletionBlock:^{\n" 13866 " [self onOperationDone];\n" 13867 "}];", 13868 FourIndent); 13869 } 13870 13871 TEST_F(FormatTest, FormatsBlocksWithZeroColumnWidth) { 13872 FormatStyle ZeroColumn = getLLVMStyle(); 13873 ZeroColumn.ColumnLimit = 0; 13874 13875 verifyFormat("[[SessionService sharedService] " 13876 "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 13877 " if (window) {\n" 13878 " [self windowDidLoad:window];\n" 13879 " } else {\n" 13880 " [self errorLoadingWindow];\n" 13881 " }\n" 13882 "}];", 13883 ZeroColumn); 13884 EXPECT_EQ("[[SessionService sharedService]\n" 13885 " loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 13886 " if (window) {\n" 13887 " [self windowDidLoad:window];\n" 13888 " } else {\n" 13889 " [self errorLoadingWindow];\n" 13890 " }\n" 13891 " }];", 13892 format("[[SessionService sharedService]\n" 13893 "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 13894 " if (window) {\n" 13895 " [self windowDidLoad:window];\n" 13896 " } else {\n" 13897 " [self errorLoadingWindow];\n" 13898 " }\n" 13899 "}];", 13900 ZeroColumn)); 13901 verifyFormat("[myObject doSomethingWith:arg1\n" 13902 " firstBlock:^(Foo *a) {\n" 13903 " // ...\n" 13904 " int i;\n" 13905 " }\n" 13906 " secondBlock:^(Bar *b) {\n" 13907 " // ...\n" 13908 " int i;\n" 13909 " }\n" 13910 " thirdBlock:^Foo(Bar *b) {\n" 13911 " // ...\n" 13912 " int i;\n" 13913 " }];", 13914 ZeroColumn); 13915 verifyFormat("f(^{\n" 13916 " @autoreleasepool {\n" 13917 " if (a) {\n" 13918 " g();\n" 13919 " }\n" 13920 " }\n" 13921 "});", 13922 ZeroColumn); 13923 verifyFormat("void (^largeBlock)(void) = ^{\n" 13924 " // ...\n" 13925 "};", 13926 ZeroColumn); 13927 13928 ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always; 13929 EXPECT_EQ("void (^largeBlock)(void) = ^{ int i; };", 13930 format("void (^largeBlock)(void) = ^{ int i; };", ZeroColumn)); 13931 ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Never; 13932 EXPECT_EQ("void (^largeBlock)(void) = ^{\n" 13933 " int i;\n" 13934 "};", 13935 format("void (^largeBlock)(void) = ^{ int i; };", ZeroColumn)); 13936 } 13937 13938 TEST_F(FormatTest, SupportsCRLF) { 13939 EXPECT_EQ("int a;\r\n" 13940 "int b;\r\n" 13941 "int c;\r\n", 13942 format("int a;\r\n" 13943 " int b;\r\n" 13944 " int c;\r\n", 13945 getLLVMStyle())); 13946 EXPECT_EQ("int a;\r\n" 13947 "int b;\r\n" 13948 "int c;\r\n", 13949 format("int a;\r\n" 13950 " int b;\n" 13951 " int c;\r\n", 13952 getLLVMStyle())); 13953 EXPECT_EQ("int a;\n" 13954 "int b;\n" 13955 "int c;\n", 13956 format("int a;\r\n" 13957 " int b;\n" 13958 " int c;\n", 13959 getLLVMStyle())); 13960 EXPECT_EQ("\"aaaaaaa \"\r\n" 13961 "\"bbbbbbb\";\r\n", 13962 format("\"aaaaaaa bbbbbbb\";\r\n", getLLVMStyleWithColumns(10))); 13963 EXPECT_EQ("#define A \\\r\n" 13964 " b; \\\r\n" 13965 " c; \\\r\n" 13966 " d;\r\n", 13967 format("#define A \\\r\n" 13968 " b; \\\r\n" 13969 " c; d; \r\n", 13970 getGoogleStyle())); 13971 13972 EXPECT_EQ("/*\r\n" 13973 "multi line block comments\r\n" 13974 "should not introduce\r\n" 13975 "an extra carriage return\r\n" 13976 "*/\r\n", 13977 format("/*\r\n" 13978 "multi line block comments\r\n" 13979 "should not introduce\r\n" 13980 "an extra carriage return\r\n" 13981 "*/\r\n")); 13982 EXPECT_EQ("/*\r\n" 13983 "\r\n" 13984 "*/", 13985 format("/*\r\n" 13986 " \r\r\r\n" 13987 "*/")); 13988 } 13989 13990 TEST_F(FormatTest, MunchSemicolonAfterBlocks) { 13991 verifyFormat("MY_CLASS(C) {\n" 13992 " int i;\n" 13993 " int j;\n" 13994 "};"); 13995 } 13996 13997 TEST_F(FormatTest, ConfigurableContinuationIndentWidth) { 13998 FormatStyle TwoIndent = getLLVMStyleWithColumns(15); 13999 TwoIndent.ContinuationIndentWidth = 2; 14000 14001 EXPECT_EQ("int i =\n" 14002 " longFunction(\n" 14003 " arg);", 14004 format("int i = longFunction(arg);", TwoIndent)); 14005 14006 FormatStyle SixIndent = getLLVMStyleWithColumns(20); 14007 SixIndent.ContinuationIndentWidth = 6; 14008 14009 EXPECT_EQ("int i =\n" 14010 " longFunction(\n" 14011 " arg);", 14012 format("int i = longFunction(arg);", SixIndent)); 14013 } 14014 14015 TEST_F(FormatTest, WrappedClosingParenthesisIndent) { 14016 FormatStyle Style = getLLVMStyle(); 14017 verifyFormat("int Foo::getter(\n" 14018 " //\n" 14019 ") const {\n" 14020 " return foo;\n" 14021 "}", 14022 Style); 14023 verifyFormat("void Foo::setter(\n" 14024 " //\n" 14025 ") {\n" 14026 " foo = 1;\n" 14027 "}", 14028 Style); 14029 } 14030 14031 TEST_F(FormatTest, SpacesInAngles) { 14032 FormatStyle Spaces = getLLVMStyle(); 14033 Spaces.SpacesInAngles = true; 14034 14035 verifyFormat("static_cast< int >(arg);", Spaces); 14036 verifyFormat("template < typename T0, typename T1 > void f() {}", Spaces); 14037 verifyFormat("f< int, float >();", Spaces); 14038 verifyFormat("template <> g() {}", Spaces); 14039 verifyFormat("template < std::vector< int > > f() {}", Spaces); 14040 verifyFormat("std::function< void(int, int) > fct;", Spaces); 14041 verifyFormat("void inFunction() { std::function< void(int, int) > fct; }", 14042 Spaces); 14043 14044 Spaces.Standard = FormatStyle::LS_Cpp03; 14045 Spaces.SpacesInAngles = true; 14046 verifyFormat("A< A< int > >();", Spaces); 14047 14048 Spaces.SpacesInAngles = false; 14049 verifyFormat("A<A<int> >();", Spaces); 14050 14051 Spaces.Standard = FormatStyle::LS_Cpp11; 14052 Spaces.SpacesInAngles = true; 14053 verifyFormat("A< A< int > >();", Spaces); 14054 14055 Spaces.SpacesInAngles = false; 14056 verifyFormat("A<A<int>>();", Spaces); 14057 } 14058 14059 TEST_F(FormatTest, SpaceAfterTemplateKeyword) { 14060 FormatStyle Style = getLLVMStyle(); 14061 Style.SpaceAfterTemplateKeyword = false; 14062 verifyFormat("template<int> void foo();", Style); 14063 } 14064 14065 TEST_F(FormatTest, TripleAngleBrackets) { 14066 verifyFormat("f<<<1, 1>>>();"); 14067 verifyFormat("f<<<1, 1, 1, s>>>();"); 14068 verifyFormat("f<<<a, b, c, d>>>();"); 14069 EXPECT_EQ("f<<<1, 1>>>();", format("f <<< 1, 1 >>> ();")); 14070 verifyFormat("f<param><<<1, 1>>>();"); 14071 verifyFormat("f<1><<<1, 1>>>();"); 14072 EXPECT_EQ("f<param><<<1, 1>>>();", format("f< param > <<< 1, 1 >>> ();")); 14073 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 14074 "aaaaaaaaaaa<<<\n 1, 1>>>();"); 14075 verifyFormat("aaaaaaaaaaaaaaa<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaa>\n" 14076 " <<<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaaaaaa>>>();"); 14077 } 14078 14079 TEST_F(FormatTest, MergeLessLessAtEnd) { 14080 verifyFormat("<<"); 14081 EXPECT_EQ("< < <", format("\\\n<<<")); 14082 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 14083 "aaallvm::outs() <<"); 14084 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 14085 "aaaallvm::outs()\n <<"); 14086 } 14087 14088 TEST_F(FormatTest, HandleUnbalancedImplicitBracesAcrossPPBranches) { 14089 std::string code = "#if A\n" 14090 "#if B\n" 14091 "a.\n" 14092 "#endif\n" 14093 " a = 1;\n" 14094 "#else\n" 14095 "#endif\n" 14096 "#if C\n" 14097 "#else\n" 14098 "#endif\n"; 14099 EXPECT_EQ(code, format(code)); 14100 } 14101 14102 TEST_F(FormatTest, HandleConflictMarkers) { 14103 // Git/SVN conflict markers. 14104 EXPECT_EQ("int a;\n" 14105 "void f() {\n" 14106 " callme(some(parameter1,\n" 14107 "<<<<<<< text by the vcs\n" 14108 " parameter2),\n" 14109 "||||||| text by the vcs\n" 14110 " parameter2),\n" 14111 " parameter3,\n" 14112 "======= text by the vcs\n" 14113 " parameter2, parameter3),\n" 14114 ">>>>>>> text by the vcs\n" 14115 " otherparameter);\n", 14116 format("int a;\n" 14117 "void f() {\n" 14118 " callme(some(parameter1,\n" 14119 "<<<<<<< text by the vcs\n" 14120 " parameter2),\n" 14121 "||||||| text by the vcs\n" 14122 " parameter2),\n" 14123 " parameter3,\n" 14124 "======= text by the vcs\n" 14125 " parameter2,\n" 14126 " parameter3),\n" 14127 ">>>>>>> text by the vcs\n" 14128 " otherparameter);\n")); 14129 14130 // Perforce markers. 14131 EXPECT_EQ("void f() {\n" 14132 " function(\n" 14133 ">>>> text by the vcs\n" 14134 " parameter,\n" 14135 "==== text by the vcs\n" 14136 " parameter,\n" 14137 "==== text by the vcs\n" 14138 " parameter,\n" 14139 "<<<< text by the vcs\n" 14140 " parameter);\n", 14141 format("void f() {\n" 14142 " function(\n" 14143 ">>>> text by the vcs\n" 14144 " parameter,\n" 14145 "==== text by the vcs\n" 14146 " parameter,\n" 14147 "==== text by the vcs\n" 14148 " parameter,\n" 14149 "<<<< text by the vcs\n" 14150 " parameter);\n")); 14151 14152 EXPECT_EQ("<<<<<<<\n" 14153 "|||||||\n" 14154 "=======\n" 14155 ">>>>>>>", 14156 format("<<<<<<<\n" 14157 "|||||||\n" 14158 "=======\n" 14159 ">>>>>>>")); 14160 14161 EXPECT_EQ("<<<<<<<\n" 14162 "|||||||\n" 14163 "int i;\n" 14164 "=======\n" 14165 ">>>>>>>", 14166 format("<<<<<<<\n" 14167 "|||||||\n" 14168 "int i;\n" 14169 "=======\n" 14170 ">>>>>>>")); 14171 14172 // FIXME: Handle parsing of macros around conflict markers correctly: 14173 EXPECT_EQ("#define Macro \\\n" 14174 "<<<<<<<\n" 14175 "Something \\\n" 14176 "|||||||\n" 14177 "Else \\\n" 14178 "=======\n" 14179 "Other \\\n" 14180 ">>>>>>>\n" 14181 " End int i;\n", 14182 format("#define Macro \\\n" 14183 "<<<<<<<\n" 14184 " Something \\\n" 14185 "|||||||\n" 14186 " Else \\\n" 14187 "=======\n" 14188 " Other \\\n" 14189 ">>>>>>>\n" 14190 " End\n" 14191 "int i;\n")); 14192 } 14193 14194 TEST_F(FormatTest, DisableRegions) { 14195 EXPECT_EQ("int i;\n" 14196 "// clang-format off\n" 14197 " int j;\n" 14198 "// clang-format on\n" 14199 "int k;", 14200 format(" int i;\n" 14201 " // clang-format off\n" 14202 " int j;\n" 14203 " // clang-format on\n" 14204 " int k;")); 14205 EXPECT_EQ("int i;\n" 14206 "/* clang-format off */\n" 14207 " int j;\n" 14208 "/* clang-format on */\n" 14209 "int k;", 14210 format(" int i;\n" 14211 " /* clang-format off */\n" 14212 " int j;\n" 14213 " /* clang-format on */\n" 14214 " int k;")); 14215 14216 // Don't reflow comments within disabled regions. 14217 EXPECT_EQ("// clang-format off\n" 14218 "// long long long long long long line\n" 14219 "/* clang-format on */\n" 14220 "/* long long long\n" 14221 " * long long long\n" 14222 " * line */\n" 14223 "int i;\n" 14224 "/* clang-format off */\n" 14225 "/* long long long long long long line */\n", 14226 format("// clang-format off\n" 14227 "// long long long long long long line\n" 14228 "/* clang-format on */\n" 14229 "/* long long long long long long line */\n" 14230 "int i;\n" 14231 "/* clang-format off */\n" 14232 "/* long long long long long long line */\n", 14233 getLLVMStyleWithColumns(20))); 14234 } 14235 14236 TEST_F(FormatTest, DoNotCrashOnInvalidInput) { 14237 format("? ) ="); 14238 verifyNoCrash("#define a\\\n /**/}"); 14239 } 14240 14241 TEST_F(FormatTest, FormatsTableGenCode) { 14242 FormatStyle Style = getLLVMStyle(); 14243 Style.Language = FormatStyle::LK_TableGen; 14244 verifyFormat("include \"a.td\"\ninclude \"b.td\"", Style); 14245 } 14246 14247 TEST_F(FormatTest, ArrayOfTemplates) { 14248 EXPECT_EQ("auto a = new unique_ptr<int>[10];", 14249 format("auto a = new unique_ptr<int > [ 10];")); 14250 14251 FormatStyle Spaces = getLLVMStyle(); 14252 Spaces.SpacesInSquareBrackets = true; 14253 EXPECT_EQ("auto a = new unique_ptr<int>[ 10 ];", 14254 format("auto a = new unique_ptr<int > [10];", Spaces)); 14255 } 14256 14257 TEST_F(FormatTest, ArrayAsTemplateType) { 14258 EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[10]>;", 14259 format("auto a = unique_ptr < Foo < Bar>[ 10]> ;")); 14260 14261 FormatStyle Spaces = getLLVMStyle(); 14262 Spaces.SpacesInSquareBrackets = true; 14263 EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[ 10 ]>;", 14264 format("auto a = unique_ptr < Foo < Bar>[10]> ;", Spaces)); 14265 } 14266 14267 TEST_F(FormatTest, NoSpaceAfterSuper) { verifyFormat("__super::FooBar();"); } 14268 14269 TEST(FormatStyle, GetStyleWithEmptyFileName) { 14270 llvm::vfs::InMemoryFileSystem FS; 14271 auto Style1 = getStyle("file", "", "Google", "", &FS); 14272 ASSERT_TRUE((bool)Style1); 14273 ASSERT_EQ(*Style1, getGoogleStyle()); 14274 } 14275 14276 TEST(FormatStyle, GetStyleOfFile) { 14277 llvm::vfs::InMemoryFileSystem FS; 14278 // Test 1: format file in the same directory. 14279 ASSERT_TRUE( 14280 FS.addFile("/a/.clang-format", 0, 14281 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM"))); 14282 ASSERT_TRUE( 14283 FS.addFile("/a/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;"))); 14284 auto Style1 = getStyle("file", "/a/.clang-format", "Google", "", &FS); 14285 ASSERT_TRUE((bool)Style1); 14286 ASSERT_EQ(*Style1, getLLVMStyle()); 14287 14288 // Test 2.1: fallback to default. 14289 ASSERT_TRUE( 14290 FS.addFile("/b/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;"))); 14291 auto Style2 = getStyle("file", "/b/test.cpp", "Mozilla", "", &FS); 14292 ASSERT_TRUE((bool)Style2); 14293 ASSERT_EQ(*Style2, getMozillaStyle()); 14294 14295 // Test 2.2: no format on 'none' fallback style. 14296 Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS); 14297 ASSERT_TRUE((bool)Style2); 14298 ASSERT_EQ(*Style2, getNoStyle()); 14299 14300 // Test 2.3: format if config is found with no based style while fallback is 14301 // 'none'. 14302 ASSERT_TRUE(FS.addFile("/b/.clang-format", 0, 14303 llvm::MemoryBuffer::getMemBuffer("IndentWidth: 2"))); 14304 Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS); 14305 ASSERT_TRUE((bool)Style2); 14306 ASSERT_EQ(*Style2, getLLVMStyle()); 14307 14308 // Test 2.4: format if yaml with no based style, while fallback is 'none'. 14309 Style2 = getStyle("{}", "a.h", "none", "", &FS); 14310 ASSERT_TRUE((bool)Style2); 14311 ASSERT_EQ(*Style2, getLLVMStyle()); 14312 14313 // Test 3: format file in parent directory. 14314 ASSERT_TRUE( 14315 FS.addFile("/c/.clang-format", 0, 14316 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: Google"))); 14317 ASSERT_TRUE(FS.addFile("/c/sub/sub/sub/test.cpp", 0, 14318 llvm::MemoryBuffer::getMemBuffer("int i;"))); 14319 auto Style3 = getStyle("file", "/c/sub/sub/sub/test.cpp", "LLVM", "", &FS); 14320 ASSERT_TRUE((bool)Style3); 14321 ASSERT_EQ(*Style3, getGoogleStyle()); 14322 14323 // Test 4: error on invalid fallback style 14324 auto Style4 = getStyle("file", "a.h", "KungFu", "", &FS); 14325 ASSERT_FALSE((bool)Style4); 14326 llvm::consumeError(Style4.takeError()); 14327 14328 // Test 5: error on invalid yaml on command line 14329 auto Style5 = getStyle("{invalid_key=invalid_value}", "a.h", "LLVM", "", &FS); 14330 ASSERT_FALSE((bool)Style5); 14331 llvm::consumeError(Style5.takeError()); 14332 14333 // Test 6: error on invalid style 14334 auto Style6 = getStyle("KungFu", "a.h", "LLVM", "", &FS); 14335 ASSERT_FALSE((bool)Style6); 14336 llvm::consumeError(Style6.takeError()); 14337 14338 // Test 7: found config file, error on parsing it 14339 ASSERT_TRUE( 14340 FS.addFile("/d/.clang-format", 0, 14341 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM\n" 14342 "InvalidKey: InvalidValue"))); 14343 ASSERT_TRUE( 14344 FS.addFile("/d/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;"))); 14345 auto Style7 = getStyle("file", "/d/.clang-format", "LLVM", "", &FS); 14346 ASSERT_FALSE((bool)Style7); 14347 llvm::consumeError(Style7.takeError()); 14348 14349 // Test 8: inferred per-language defaults apply. 14350 auto StyleTd = getStyle("file", "x.td", "llvm", "", &FS); 14351 ASSERT_TRUE((bool)StyleTd); 14352 ASSERT_EQ(*StyleTd, getLLVMStyle(FormatStyle::LK_TableGen)); 14353 } 14354 14355 TEST_F(ReplacementTest, FormatCodeAfterReplacements) { 14356 // Column limit is 20. 14357 std::string Code = "Type *a =\n" 14358 " new Type();\n" 14359 "g(iiiii, 0, jjjjj,\n" 14360 " 0, kkkkk, 0, mm);\n" 14361 "int bad = format ;"; 14362 std::string Expected = "auto a = new Type();\n" 14363 "g(iiiii, nullptr,\n" 14364 " jjjjj, nullptr,\n" 14365 " kkkkk, nullptr,\n" 14366 " mm);\n" 14367 "int bad = format ;"; 14368 FileID ID = Context.createInMemoryFile("format.cpp", Code); 14369 tooling::Replacements Replaces = toReplacements( 14370 {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 6, 14371 "auto "), 14372 tooling::Replacement(Context.Sources, Context.getLocation(ID, 3, 10), 1, 14373 "nullptr"), 14374 tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 3), 1, 14375 "nullptr"), 14376 tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 13), 1, 14377 "nullptr")}); 14378 14379 format::FormatStyle Style = format::getLLVMStyle(); 14380 Style.ColumnLimit = 20; // Set column limit to 20 to increase readibility. 14381 auto FormattedReplaces = formatReplacements(Code, Replaces, Style); 14382 EXPECT_TRUE(static_cast<bool>(FormattedReplaces)) 14383 << llvm::toString(FormattedReplaces.takeError()) << "\n"; 14384 auto Result = applyAllReplacements(Code, *FormattedReplaces); 14385 EXPECT_TRUE(static_cast<bool>(Result)); 14386 EXPECT_EQ(Expected, *Result); 14387 } 14388 14389 TEST_F(ReplacementTest, SortIncludesAfterReplacement) { 14390 std::string Code = "#include \"a.h\"\n" 14391 "#include \"c.h\"\n" 14392 "\n" 14393 "int main() {\n" 14394 " return 0;\n" 14395 "}"; 14396 std::string Expected = "#include \"a.h\"\n" 14397 "#include \"b.h\"\n" 14398 "#include \"c.h\"\n" 14399 "\n" 14400 "int main() {\n" 14401 " return 0;\n" 14402 "}"; 14403 FileID ID = Context.createInMemoryFile("fix.cpp", Code); 14404 tooling::Replacements Replaces = toReplacements( 14405 {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 0, 14406 "#include \"b.h\"\n")}); 14407 14408 format::FormatStyle Style = format::getLLVMStyle(); 14409 Style.SortIncludes = true; 14410 auto FormattedReplaces = formatReplacements(Code, Replaces, Style); 14411 EXPECT_TRUE(static_cast<bool>(FormattedReplaces)) 14412 << llvm::toString(FormattedReplaces.takeError()) << "\n"; 14413 auto Result = applyAllReplacements(Code, *FormattedReplaces); 14414 EXPECT_TRUE(static_cast<bool>(Result)); 14415 EXPECT_EQ(Expected, *Result); 14416 } 14417 14418 TEST_F(FormatTest, FormatSortsUsingDeclarations) { 14419 EXPECT_EQ("using std::cin;\n" 14420 "using std::cout;", 14421 format("using std::cout;\n" 14422 "using std::cin;", 14423 getGoogleStyle())); 14424 } 14425 14426 TEST_F(FormatTest, UTF8CharacterLiteralCpp03) { 14427 format::FormatStyle Style = format::getLLVMStyle(); 14428 Style.Standard = FormatStyle::LS_Cpp03; 14429 // cpp03 recognize this string as identifier u8 and literal character 'a' 14430 EXPECT_EQ("auto c = u8 'a';", format("auto c = u8'a';", Style)); 14431 } 14432 14433 TEST_F(FormatTest, UTF8CharacterLiteralCpp11) { 14434 // u8'a' is a C++17 feature, utf8 literal character, LS_Cpp11 covers 14435 // all modes, including C++11, C++14 and C++17 14436 EXPECT_EQ("auto c = u8'a';", format("auto c = u8'a';")); 14437 } 14438 14439 TEST_F(FormatTest, DoNotFormatLikelyXml) { 14440 EXPECT_EQ("<!-- ;> -->", format("<!-- ;> -->", getGoogleStyle())); 14441 EXPECT_EQ(" <!-- >; -->", format(" <!-- >; -->", getGoogleStyle())); 14442 } 14443 14444 TEST_F(FormatTest, StructuredBindings) { 14445 // Structured bindings is a C++17 feature. 14446 // all modes, including C++11, C++14 and C++17 14447 verifyFormat("auto [a, b] = f();"); 14448 EXPECT_EQ("auto [a, b] = f();", format("auto[a, b] = f();")); 14449 EXPECT_EQ("const auto [a, b] = f();", format("const auto[a, b] = f();")); 14450 EXPECT_EQ("auto const [a, b] = f();", format("auto const[a, b] = f();")); 14451 EXPECT_EQ("auto const volatile [a, b] = f();", 14452 format("auto const volatile[a, b] = f();")); 14453 EXPECT_EQ("auto [a, b, c] = f();", format("auto [ a , b,c ] = f();")); 14454 EXPECT_EQ("auto &[a, b, c] = f();", 14455 format("auto &[ a , b,c ] = f();")); 14456 EXPECT_EQ("auto &&[a, b, c] = f();", 14457 format("auto &&[ a , b,c ] = f();")); 14458 EXPECT_EQ("auto const &[a, b] = f();", format("auto const&[a, b] = f();")); 14459 EXPECT_EQ("auto const volatile &&[a, b] = f();", 14460 format("auto const volatile &&[a, b] = f();")); 14461 EXPECT_EQ("auto const &&[a, b] = f();", 14462 format("auto const && [a, b] = f();")); 14463 EXPECT_EQ("const auto &[a, b] = f();", 14464 format("const auto & [a, b] = f();")); 14465 EXPECT_EQ("const auto volatile &&[a, b] = f();", 14466 format("const auto volatile &&[a, b] = f();")); 14467 EXPECT_EQ("volatile const auto &&[a, b] = f();", 14468 format("volatile const auto &&[a, b] = f();")); 14469 EXPECT_EQ("const auto &&[a, b] = f();", 14470 format("const auto && [a, b] = f();")); 14471 14472 // Make sure we don't mistake structured bindings for lambdas. 14473 FormatStyle PointerMiddle = getLLVMStyle(); 14474 PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle; 14475 verifyFormat("auto [a1, b]{A * i};", getGoogleStyle()); 14476 verifyFormat("auto [a2, b]{A * i};", getLLVMStyle()); 14477 verifyFormat("auto [a3, b]{A * i};", PointerMiddle); 14478 verifyFormat("auto const [a1, b]{A * i};", getGoogleStyle()); 14479 verifyFormat("auto const [a2, b]{A * i};", getLLVMStyle()); 14480 verifyFormat("auto const [a3, b]{A * i};", PointerMiddle); 14481 verifyFormat("auto const& [a1, b]{A * i};", getGoogleStyle()); 14482 verifyFormat("auto const &[a2, b]{A * i};", getLLVMStyle()); 14483 verifyFormat("auto const & [a3, b]{A * i};", PointerMiddle); 14484 verifyFormat("auto const&& [a1, b]{A * i};", getGoogleStyle()); 14485 verifyFormat("auto const &&[a2, b]{A * i};", getLLVMStyle()); 14486 verifyFormat("auto const && [a3, b]{A * i};", PointerMiddle); 14487 14488 EXPECT_EQ("for (const auto &&[a, b] : some_range) {\n}", 14489 format("for (const auto && [a, b] : some_range) {\n}")); 14490 EXPECT_EQ("for (const auto &[a, b] : some_range) {\n}", 14491 format("for (const auto & [a, b] : some_range) {\n}")); 14492 EXPECT_EQ("for (const auto [a, b] : some_range) {\n}", 14493 format("for (const auto[a, b] : some_range) {\n}")); 14494 EXPECT_EQ("auto [x, y](expr);", format("auto[x,y] (expr);")); 14495 EXPECT_EQ("auto &[x, y](expr);", format("auto & [x,y] (expr);")); 14496 EXPECT_EQ("auto &&[x, y](expr);", format("auto && [x,y] (expr);")); 14497 EXPECT_EQ("auto const &[x, y](expr);", 14498 format("auto const & [x,y] (expr);")); 14499 EXPECT_EQ("auto const &&[x, y](expr);", 14500 format("auto const && [x,y] (expr);")); 14501 EXPECT_EQ("auto [x, y]{expr};", format("auto[x,y] {expr};")); 14502 EXPECT_EQ("auto const &[x, y]{expr};", 14503 format("auto const & [x,y] {expr};")); 14504 EXPECT_EQ("auto const &&[x, y]{expr};", 14505 format("auto const && [x,y] {expr};")); 14506 14507 format::FormatStyle Spaces = format::getLLVMStyle(); 14508 Spaces.SpacesInSquareBrackets = true; 14509 verifyFormat("auto [ a, b ] = f();", Spaces); 14510 verifyFormat("auto &&[ a, b ] = f();", Spaces); 14511 verifyFormat("auto &[ a, b ] = f();", Spaces); 14512 verifyFormat("auto const &&[ a, b ] = f();", Spaces); 14513 verifyFormat("auto const &[ a, b ] = f();", Spaces); 14514 } 14515 14516 TEST_F(FormatTest, FileAndCode) { 14517 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.cc", "")); 14518 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.m", "")); 14519 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.mm", "")); 14520 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "")); 14521 EXPECT_EQ(FormatStyle::LK_ObjC, 14522 guessLanguage("foo.h", "@interface Foo\n@end\n")); 14523 EXPECT_EQ( 14524 FormatStyle::LK_ObjC, 14525 guessLanguage("foo.h", "#define TRY(x, y) @try { x; } @finally { y; }")); 14526 EXPECT_EQ(FormatStyle::LK_ObjC, 14527 guessLanguage("foo.h", "#define AVAIL(x) @available(x, *))")); 14528 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.h", "@class Foo;")); 14529 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo", "")); 14530 EXPECT_EQ(FormatStyle::LK_ObjC, 14531 guessLanguage("foo", "@interface Foo\n@end\n")); 14532 EXPECT_EQ(FormatStyle::LK_ObjC, 14533 guessLanguage("foo.h", "int DoStuff(CGRect rect);\n")); 14534 EXPECT_EQ( 14535 FormatStyle::LK_ObjC, 14536 guessLanguage("foo.h", 14537 "#define MY_POINT_MAKE(x, y) CGPointMake((x), (y));\n")); 14538 EXPECT_EQ( 14539 FormatStyle::LK_Cpp, 14540 guessLanguage("foo.h", "#define FOO(...) auto bar = [] __VA_ARGS__;")); 14541 } 14542 14543 TEST_F(FormatTest, GuessLanguageWithCpp11AttributeSpecifiers) { 14544 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[noreturn]];")); 14545 EXPECT_EQ(FormatStyle::LK_ObjC, 14546 guessLanguage("foo.h", "array[[calculator getIndex]];")); 14547 EXPECT_EQ(FormatStyle::LK_Cpp, 14548 guessLanguage("foo.h", "[[noreturn, deprecated(\"so sorry\")]];")); 14549 EXPECT_EQ( 14550 FormatStyle::LK_Cpp, 14551 guessLanguage("foo.h", "[[noreturn, deprecated(\"gone, sorry\")]];")); 14552 EXPECT_EQ(FormatStyle::LK_ObjC, 14553 guessLanguage("foo.h", "[[noreturn foo] bar];")); 14554 EXPECT_EQ(FormatStyle::LK_Cpp, 14555 guessLanguage("foo.h", "[[clang::fallthrough]];")); 14556 EXPECT_EQ(FormatStyle::LK_ObjC, 14557 guessLanguage("foo.h", "[[clang:fallthrough] foo];")); 14558 EXPECT_EQ(FormatStyle::LK_Cpp, 14559 guessLanguage("foo.h", "[[gsl::suppress(\"type\")]];")); 14560 EXPECT_EQ(FormatStyle::LK_Cpp, 14561 guessLanguage("foo.h", "[[using clang: fallthrough]];")); 14562 EXPECT_EQ(FormatStyle::LK_ObjC, 14563 guessLanguage("foo.h", "[[abusing clang:fallthrough] bar];")); 14564 EXPECT_EQ(FormatStyle::LK_Cpp, 14565 guessLanguage("foo.h", "[[using gsl: suppress(\"type\")]];")); 14566 EXPECT_EQ( 14567 FormatStyle::LK_Cpp, 14568 guessLanguage("foo.h", "for (auto &&[endpoint, stream] : streams_)")); 14569 EXPECT_EQ( 14570 FormatStyle::LK_Cpp, 14571 guessLanguage("foo.h", 14572 "[[clang::callable_when(\"unconsumed\", \"unknown\")]]")); 14573 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[foo::bar, ...]]")); 14574 } 14575 14576 TEST_F(FormatTest, GuessLanguageWithCaret) { 14577 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^);")); 14578 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^, Bar);")); 14579 EXPECT_EQ(FormatStyle::LK_ObjC, 14580 guessLanguage("foo.h", "int(^)(char, float);")); 14581 EXPECT_EQ(FormatStyle::LK_ObjC, 14582 guessLanguage("foo.h", "int(^foo)(char, float);")); 14583 EXPECT_EQ(FormatStyle::LK_ObjC, 14584 guessLanguage("foo.h", "int(^foo[10])(char, float);")); 14585 EXPECT_EQ(FormatStyle::LK_ObjC, 14586 guessLanguage("foo.h", "int(^foo[kNumEntries])(char, float);")); 14587 EXPECT_EQ( 14588 FormatStyle::LK_ObjC, 14589 guessLanguage("foo.h", "int(^foo[(kNumEntries + 10)])(char, float);")); 14590 } 14591 14592 TEST_F(FormatTest, GuessedLanguageWithInlineAsmClobbers) { 14593 EXPECT_EQ(FormatStyle::LK_Cpp, 14594 guessLanguage("foo.h", "void f() {\n" 14595 " asm (\"mov %[e], %[d]\"\n" 14596 " : [d] \"=rm\" (d)\n" 14597 " [e] \"rm\" (*e));\n" 14598 "}")); 14599 EXPECT_EQ(FormatStyle::LK_Cpp, 14600 guessLanguage("foo.h", "void f() {\n" 14601 " _asm (\"mov %[e], %[d]\"\n" 14602 " : [d] \"=rm\" (d)\n" 14603 " [e] \"rm\" (*e));\n" 14604 "}")); 14605 EXPECT_EQ(FormatStyle::LK_Cpp, 14606 guessLanguage("foo.h", "void f() {\n" 14607 " __asm (\"mov %[e], %[d]\"\n" 14608 " : [d] \"=rm\" (d)\n" 14609 " [e] \"rm\" (*e));\n" 14610 "}")); 14611 EXPECT_EQ(FormatStyle::LK_Cpp, 14612 guessLanguage("foo.h", "void f() {\n" 14613 " __asm__ (\"mov %[e], %[d]\"\n" 14614 " : [d] \"=rm\" (d)\n" 14615 " [e] \"rm\" (*e));\n" 14616 "}")); 14617 EXPECT_EQ(FormatStyle::LK_Cpp, 14618 guessLanguage("foo.h", "void f() {\n" 14619 " asm (\"mov %[e], %[d]\"\n" 14620 " : [d] \"=rm\" (d),\n" 14621 " [e] \"rm\" (*e));\n" 14622 "}")); 14623 EXPECT_EQ(FormatStyle::LK_Cpp, 14624 guessLanguage("foo.h", "void f() {\n" 14625 " asm volatile (\"mov %[e], %[d]\"\n" 14626 " : [d] \"=rm\" (d)\n" 14627 " [e] \"rm\" (*e));\n" 14628 "}")); 14629 } 14630 14631 TEST_F(FormatTest, GuessLanguageWithChildLines) { 14632 EXPECT_EQ(FormatStyle::LK_Cpp, 14633 guessLanguage("foo.h", "#define FOO ({ std::string s; })")); 14634 EXPECT_EQ(FormatStyle::LK_ObjC, 14635 guessLanguage("foo.h", "#define FOO ({ NSString *s; })")); 14636 EXPECT_EQ( 14637 FormatStyle::LK_Cpp, 14638 guessLanguage("foo.h", "#define FOO ({ foo(); ({ std::string s; }) })")); 14639 EXPECT_EQ( 14640 FormatStyle::LK_ObjC, 14641 guessLanguage("foo.h", "#define FOO ({ foo(); ({ NSString *s; }) })")); 14642 } 14643 14644 TEST_F(FormatTest, TypenameMacros) { 14645 std::vector<std::string> TypenameMacros = {"STACK_OF", "LIST", "TAILQ_ENTRY"}; 14646 14647 // Test case reported in https://bugs.llvm.org/show_bug.cgi?id=30353 14648 FormatStyle Google = getGoogleStyleWithColumns(0); 14649 Google.TypenameMacros = TypenameMacros; 14650 verifyFormat("struct foo {\n" 14651 " int bar;\n" 14652 " TAILQ_ENTRY(a) bleh;\n" 14653 "};", 14654 Google); 14655 14656 FormatStyle Macros = getLLVMStyle(); 14657 Macros.TypenameMacros = TypenameMacros; 14658 14659 verifyFormat("STACK_OF(int) a;", Macros); 14660 verifyFormat("STACK_OF(int) *a;", Macros); 14661 verifyFormat("STACK_OF(int const *) *a;", Macros); 14662 verifyFormat("STACK_OF(int *const) *a;", Macros); 14663 verifyFormat("STACK_OF(int, string) a;", Macros); 14664 verifyFormat("STACK_OF(LIST(int)) a;", Macros); 14665 verifyFormat("STACK_OF(LIST(int)) a, b;", Macros); 14666 verifyFormat("for (LIST(int) *a = NULL; a;) {\n}", Macros); 14667 verifyFormat("STACK_OF(int) f(LIST(int) *arg);", Macros); 14668 14669 Macros.PointerAlignment = FormatStyle::PAS_Left; 14670 verifyFormat("STACK_OF(int)* a;", Macros); 14671 verifyFormat("STACK_OF(int*)* a;", Macros); 14672 } 14673 14674 TEST_F(FormatTest, AmbersandInLamda) { 14675 // Test case reported in https://bugs.llvm.org/show_bug.cgi?id=41899 14676 FormatStyle AlignStyle = getLLVMStyle(); 14677 AlignStyle.PointerAlignment = FormatStyle::PAS_Left; 14678 verifyFormat("auto lambda = [&a = a]() { a = 2; };", AlignStyle); 14679 AlignStyle.PointerAlignment = FormatStyle::PAS_Right; 14680 verifyFormat("auto lambda = [&a = a]() { a = 2; };", AlignStyle); 14681 } 14682 14683 TEST_F(FormatTest, AlternativeOperators) { 14684 // Test case for ensuring alternate operators are not 14685 // combined with their right most neighbour. 14686 verifyFormat("int a and b;"); 14687 verifyFormat("int a and_eq b;"); 14688 verifyFormat("int a bitand b;"); 14689 verifyFormat("int a bitor b;"); 14690 verifyFormat("int a compl b;"); 14691 verifyFormat("int a not b;"); 14692 verifyFormat("int a not_eq b;"); 14693 verifyFormat("int a or b;"); 14694 verifyFormat("int a xor b;"); 14695 verifyFormat("int a xor_eq b;"); 14696 verifyFormat("return this not_eq bitand other;"); 14697 verifyFormat("bool operator not_eq(const X bitand other)"); 14698 14699 verifyFormat("int a and 5;"); 14700 verifyFormat("int a and_eq 5;"); 14701 verifyFormat("int a bitand 5;"); 14702 verifyFormat("int a bitor 5;"); 14703 verifyFormat("int a compl 5;"); 14704 verifyFormat("int a not 5;"); 14705 verifyFormat("int a not_eq 5;"); 14706 verifyFormat("int a or 5;"); 14707 verifyFormat("int a xor 5;"); 14708 verifyFormat("int a xor_eq 5;"); 14709 14710 verifyFormat("int a compl(5);"); 14711 verifyFormat("int a not(5);"); 14712 14713 /* FIXME handle alternate tokens 14714 * https://en.cppreference.com/w/cpp/language/operator_alternative 14715 // alternative tokens 14716 verifyFormat("compl foo();"); // ~foo(); 14717 verifyFormat("foo() <%%>;"); // foo(); 14718 verifyFormat("void foo() <%%>;"); // void foo(){} 14719 verifyFormat("int a <:1:>;"); // int a[1];[ 14720 verifyFormat("%:define ABC abc"); // #define ABC abc 14721 verifyFormat("%:%:"); // ## 14722 */ 14723 } 14724 14725 TEST_F(FormatTest, STLWhileNotDefineChed) { 14726 verifyFormat("#if defined(while)\n" 14727 "#define while EMIT WARNING C4005\n" 14728 "#endif // while"); 14729 } 14730 14731 } // namespace 14732 } // namespace format 14733 } // namespace clang 14734