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 verifyFormat("do a++;\n" 560 "while (true);", 561 AllowsMergedLoops); 562 verifyFormat("do /* Don't merge */\n" 563 " a++;\n" 564 "while (true);", 565 AllowsMergedLoops); 566 verifyFormat("do // Don't merge\n" 567 " a++;\n" 568 "while (true);", 569 AllowsMergedLoops); 570 verifyFormat("do\n" 571 " // Don't merge\n" 572 " a++;\n" 573 "while (true);", 574 AllowsMergedLoops); 575 // Without braces labels are interpreted differently. 576 verifyFormat("{\n" 577 " do\n" 578 " label:\n" 579 " a++;\n" 580 " while (true);\n" 581 "}", 582 AllowsMergedLoops); 583 } 584 585 TEST_F(FormatTest, FormatShortBracedStatements) { 586 FormatStyle AllowSimpleBracedStatements = getLLVMStyle(); 587 AllowSimpleBracedStatements.ColumnLimit = 40; 588 AllowSimpleBracedStatements.AllowShortBlocksOnASingleLine = 589 FormatStyle::SBS_Always; 590 591 AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = 592 FormatStyle::SIS_WithoutElse; 593 AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = true; 594 595 AllowSimpleBracedStatements.BreakBeforeBraces = FormatStyle::BS_Custom; 596 AllowSimpleBracedStatements.BraceWrapping.AfterFunction = true; 597 AllowSimpleBracedStatements.BraceWrapping.SplitEmptyRecord = false; 598 599 verifyFormat("if (true) {}", AllowSimpleBracedStatements); 600 verifyFormat("if constexpr (true) {}", AllowSimpleBracedStatements); 601 verifyFormat("if CONSTEXPR (true) {}", AllowSimpleBracedStatements); 602 verifyFormat("while (true) {}", AllowSimpleBracedStatements); 603 verifyFormat("for (;;) {}", AllowSimpleBracedStatements); 604 verifyFormat("if (true) { f(); }", AllowSimpleBracedStatements); 605 verifyFormat("if constexpr (true) { f(); }", AllowSimpleBracedStatements); 606 verifyFormat("if CONSTEXPR (true) { f(); }", AllowSimpleBracedStatements); 607 verifyFormat("while (true) { f(); }", AllowSimpleBracedStatements); 608 verifyFormat("for (;;) { f(); }", AllowSimpleBracedStatements); 609 verifyFormat("if (true) {\n" 610 " ffffffffffffffffffffffffffffffffffffffffffffffffffffff();\n" 611 "}", 612 AllowSimpleBracedStatements); 613 verifyFormat("if (true) { //\n" 614 " f();\n" 615 "}", 616 AllowSimpleBracedStatements); 617 verifyFormat("if (true) {\n" 618 " f();\n" 619 " f();\n" 620 "}", 621 AllowSimpleBracedStatements); 622 verifyFormat("if (true) {\n" 623 " f();\n" 624 "} else {\n" 625 " f();\n" 626 "}", 627 AllowSimpleBracedStatements); 628 629 verifyFormat("struct A2 {\n" 630 " int X;\n" 631 "};", 632 AllowSimpleBracedStatements); 633 verifyFormat("typedef struct A2 {\n" 634 " int X;\n" 635 "} A2_t;", 636 AllowSimpleBracedStatements); 637 verifyFormat("template <int> struct A2 {\n" 638 " struct B {};\n" 639 "};", 640 AllowSimpleBracedStatements); 641 642 AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = 643 FormatStyle::SIS_Never; 644 verifyFormat("if (true) {}", AllowSimpleBracedStatements); 645 verifyFormat("if (true) {\n" 646 " f();\n" 647 "}", 648 AllowSimpleBracedStatements); 649 verifyFormat("if (true) {\n" 650 " f();\n" 651 "} else {\n" 652 " f();\n" 653 "}", 654 AllowSimpleBracedStatements); 655 656 AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = false; 657 verifyFormat("while (true) {}", AllowSimpleBracedStatements); 658 verifyFormat("while (true) {\n" 659 " f();\n" 660 "}", 661 AllowSimpleBracedStatements); 662 verifyFormat("for (;;) {}", AllowSimpleBracedStatements); 663 verifyFormat("for (;;) {\n" 664 " f();\n" 665 "}", 666 AllowSimpleBracedStatements); 667 668 AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = 669 FormatStyle::SIS_WithoutElse; 670 AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = true; 671 AllowSimpleBracedStatements.BraceWrapping.AfterControlStatement = 672 FormatStyle::BWACS_Always; 673 674 verifyFormat("if (true) {}", AllowSimpleBracedStatements); 675 verifyFormat("if constexpr (true) {}", AllowSimpleBracedStatements); 676 verifyFormat("if CONSTEXPR (true) {}", AllowSimpleBracedStatements); 677 verifyFormat("while (true) {}", AllowSimpleBracedStatements); 678 verifyFormat("for (;;) {}", AllowSimpleBracedStatements); 679 verifyFormat("if (true) { f(); }", AllowSimpleBracedStatements); 680 verifyFormat("if constexpr (true) { f(); }", AllowSimpleBracedStatements); 681 verifyFormat("if CONSTEXPR (true) { f(); }", AllowSimpleBracedStatements); 682 verifyFormat("while (true) { f(); }", AllowSimpleBracedStatements); 683 verifyFormat("for (;;) { f(); }", AllowSimpleBracedStatements); 684 verifyFormat("if (true)\n" 685 "{\n" 686 " ffffffffffffffffffffffffffffffffffffffffffffffffffffff();\n" 687 "}", 688 AllowSimpleBracedStatements); 689 verifyFormat("if (true)\n" 690 "{ //\n" 691 " f();\n" 692 "}", 693 AllowSimpleBracedStatements); 694 verifyFormat("if (true)\n" 695 "{\n" 696 " f();\n" 697 " f();\n" 698 "}", 699 AllowSimpleBracedStatements); 700 verifyFormat("if (true)\n" 701 "{\n" 702 " f();\n" 703 "} else\n" 704 "{\n" 705 " f();\n" 706 "}", 707 AllowSimpleBracedStatements); 708 709 AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = 710 FormatStyle::SIS_Never; 711 verifyFormat("if (true) {}", AllowSimpleBracedStatements); 712 verifyFormat("if (true)\n" 713 "{\n" 714 " f();\n" 715 "}", 716 AllowSimpleBracedStatements); 717 verifyFormat("if (true)\n" 718 "{\n" 719 " f();\n" 720 "} else\n" 721 "{\n" 722 " f();\n" 723 "}", 724 AllowSimpleBracedStatements); 725 726 AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = false; 727 verifyFormat("while (true) {}", AllowSimpleBracedStatements); 728 verifyFormat("while (true)\n" 729 "{\n" 730 " f();\n" 731 "}", 732 AllowSimpleBracedStatements); 733 verifyFormat("for (;;) {}", AllowSimpleBracedStatements); 734 verifyFormat("for (;;)\n" 735 "{\n" 736 " f();\n" 737 "}", 738 AllowSimpleBracedStatements); 739 } 740 741 TEST_F(FormatTest, ShortBlocksInMacrosDontMergeWithCodeAfterMacro) { 742 FormatStyle Style = getLLVMStyleWithColumns(60); 743 Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always; 744 Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_WithoutElse; 745 Style.BreakBeforeBraces = FormatStyle::BS_Allman; 746 EXPECT_EQ("#define A \\\n" 747 " if (HANDLEwernufrnuLwrmviferuvnierv) \\\n" 748 " { RET_ERR1_ANUIREUINERUIFNIOAerwfwrvnuier; }\n" 749 "X;", 750 format("#define A \\\n" 751 " if (HANDLEwernufrnuLwrmviferuvnierv) { \\\n" 752 " RET_ERR1_ANUIREUINERUIFNIOAerwfwrvnuier; \\\n" 753 " }\n" 754 "X;", 755 Style)); 756 } 757 758 TEST_F(FormatTest, ParseIfElse) { 759 verifyFormat("if (true)\n" 760 " if (true)\n" 761 " if (true)\n" 762 " f();\n" 763 " else\n" 764 " g();\n" 765 " else\n" 766 " h();\n" 767 "else\n" 768 " i();"); 769 verifyFormat("if (true)\n" 770 " if (true)\n" 771 " if (true) {\n" 772 " if (true)\n" 773 " f();\n" 774 " } else {\n" 775 " g();\n" 776 " }\n" 777 " else\n" 778 " h();\n" 779 "else {\n" 780 " i();\n" 781 "}"); 782 verifyFormat("if (true)\n" 783 " if constexpr (true)\n" 784 " if (true) {\n" 785 " if constexpr (true)\n" 786 " f();\n" 787 " } else {\n" 788 " g();\n" 789 " }\n" 790 " else\n" 791 " h();\n" 792 "else {\n" 793 " i();\n" 794 "}"); 795 verifyFormat("if (true)\n" 796 " if CONSTEXPR (true)\n" 797 " if (true) {\n" 798 " if CONSTEXPR (true)\n" 799 " f();\n" 800 " } else {\n" 801 " g();\n" 802 " }\n" 803 " else\n" 804 " h();\n" 805 "else {\n" 806 " i();\n" 807 "}"); 808 verifyFormat("void f() {\n" 809 " if (a) {\n" 810 " } else {\n" 811 " }\n" 812 "}"); 813 } 814 815 TEST_F(FormatTest, ElseIf) { 816 verifyFormat("if (a) {\n} else if (b) {\n}"); 817 verifyFormat("if (a)\n" 818 " f();\n" 819 "else if (b)\n" 820 " g();\n" 821 "else\n" 822 " h();"); 823 verifyFormat("if constexpr (a)\n" 824 " f();\n" 825 "else if constexpr (b)\n" 826 " g();\n" 827 "else\n" 828 " h();"); 829 verifyFormat("if CONSTEXPR (a)\n" 830 " f();\n" 831 "else if CONSTEXPR (b)\n" 832 " g();\n" 833 "else\n" 834 " h();"); 835 verifyFormat("if (a) {\n" 836 " f();\n" 837 "}\n" 838 "// or else ..\n" 839 "else {\n" 840 " g()\n" 841 "}"); 842 843 verifyFormat("if (a) {\n" 844 "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 845 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n" 846 "}"); 847 verifyFormat("if (a) {\n" 848 "} else if constexpr (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 849 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n" 850 "}"); 851 verifyFormat("if (a) {\n" 852 "} else if CONSTEXPR (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 853 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n" 854 "}"); 855 verifyFormat("if (a) {\n" 856 "} else if (\n" 857 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 858 "}", 859 getLLVMStyleWithColumns(62)); 860 verifyFormat("if (a) {\n" 861 "} else if constexpr (\n" 862 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 863 "}", 864 getLLVMStyleWithColumns(62)); 865 verifyFormat("if (a) {\n" 866 "} else if CONSTEXPR (\n" 867 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 868 "}", 869 getLLVMStyleWithColumns(62)); 870 } 871 872 TEST_F(FormatTest, FormatsForLoop) { 873 verifyFormat( 874 "for (int VeryVeryLongLoopVariable = 0; VeryVeryLongLoopVariable < 10;\n" 875 " ++VeryVeryLongLoopVariable)\n" 876 " ;"); 877 verifyFormat("for (;;)\n" 878 " f();"); 879 verifyFormat("for (;;) {\n}"); 880 verifyFormat("for (;;) {\n" 881 " f();\n" 882 "}"); 883 verifyFormat("for (int i = 0; (i < 10); ++i) {\n}"); 884 885 verifyFormat( 886 "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n" 887 " E = UnwrappedLines.end();\n" 888 " I != E; ++I) {\n}"); 889 890 verifyFormat( 891 "for (MachineFun::iterator IIII = PrevIt, EEEE = F.end(); IIII != EEEE;\n" 892 " ++IIIII) {\n}"); 893 verifyFormat("for (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaa =\n" 894 " aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa;\n" 895 " aaaaaaaaaaa != aaaaaaaaaaaaaaaaaaa; ++aaaaaaaaaaa) {\n}"); 896 verifyFormat("for (llvm::ArrayRef<NamedDecl *>::iterator\n" 897 " I = FD->getDeclsInPrototypeScope().begin(),\n" 898 " E = FD->getDeclsInPrototypeScope().end();\n" 899 " I != E; ++I) {\n}"); 900 verifyFormat("for (SmallVectorImpl<TemplateIdAnnotationn *>::iterator\n" 901 " I = Container.begin(),\n" 902 " E = Container.end();\n" 903 " I != E; ++I) {\n}", 904 getLLVMStyleWithColumns(76)); 905 906 verifyFormat( 907 "for (aaaaaaaaaaaaaaaaa aaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n" 908 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa !=\n" 909 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 910 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 911 " ++aaaaaaaaaaa) {\n}"); 912 verifyFormat("for (int i = 0; i < aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 913 " bbbbbbbbbbbbbbbbbbbb < ccccccccccccccc;\n" 914 " ++i) {\n}"); 915 verifyFormat("for (int aaaaaaaaaaa = 1; aaaaaaaaaaa <= bbbbbbbbbbbbbbb;\n" 916 " aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n" 917 "}"); 918 verifyFormat("for (some_namespace::SomeIterator iter( // force break\n" 919 " aaaaaaaaaa);\n" 920 " iter; ++iter) {\n" 921 "}"); 922 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 923 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 924 " aaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbbbbbbb;\n" 925 " ++aaaaaaaaaaaaaaaaaaaaaaaaaaa) {"); 926 927 // These should not be formatted as Objective-C for-in loops. 928 verifyFormat("for (Foo *x = 0; x != in; x++) {\n}"); 929 verifyFormat("Foo *x;\nfor (x = 0; x != in; x++) {\n}"); 930 verifyFormat("Foo *x;\nfor (x in y) {\n}"); 931 verifyFormat( 932 "for (const Foo<Bar> &baz = in.value(); !baz.at_end(); ++baz) {\n}"); 933 934 FormatStyle NoBinPacking = getLLVMStyle(); 935 NoBinPacking.BinPackParameters = false; 936 verifyFormat("for (int aaaaaaaaaaa = 1;\n" 937 " aaaaaaaaaaa <= aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa,\n" 938 " aaaaaaaaaaaaaaaa,\n" 939 " aaaaaaaaaaaaaaaa,\n" 940 " aaaaaaaaaaaaaaaa);\n" 941 " aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n" 942 "}", 943 NoBinPacking); 944 verifyFormat( 945 "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n" 946 " E = UnwrappedLines.end();\n" 947 " I != E;\n" 948 " ++I) {\n}", 949 NoBinPacking); 950 951 FormatStyle AlignLeft = getLLVMStyle(); 952 AlignLeft.PointerAlignment = FormatStyle::PAS_Left; 953 verifyFormat("for (A* a = start; a < end; ++a, ++value) {\n}", AlignLeft); 954 } 955 956 TEST_F(FormatTest, RangeBasedForLoops) { 957 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 958 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 959 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaa :\n" 960 " aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa, aaaaaaaaaaaaa)) {\n}"); 961 verifyFormat("for (const aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaa :\n" 962 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 963 verifyFormat("for (aaaaaaaaa aaaaaaaaaaaaaaaaaaaaa :\n" 964 " aaaaaaaaaaaa.aaaaaaaaaaaa().aaaaaaaaa().a()) {\n}"); 965 } 966 967 TEST_F(FormatTest, ForEachLoops) { 968 verifyFormat("void f() {\n" 969 " foreach (Item *item, itemlist) {}\n" 970 " Q_FOREACH (Item *item, itemlist) {}\n" 971 " BOOST_FOREACH (Item *item, itemlist) {}\n" 972 " UNKNOWN_FORACH(Item * item, itemlist) {}\n" 973 "}"); 974 975 FormatStyle Style = getLLVMStyle(); 976 Style.SpaceBeforeParens = 977 FormatStyle::SBPO_ControlStatementsExceptForEachMacros; 978 verifyFormat("void f() {\n" 979 " foreach(Item *item, itemlist) {}\n" 980 " Q_FOREACH(Item *item, itemlist) {}\n" 981 " BOOST_FOREACH(Item *item, itemlist) {}\n" 982 " UNKNOWN_FORACH(Item * item, itemlist) {}\n" 983 "}", 984 Style); 985 986 // As function-like macros. 987 verifyFormat("#define foreach(x, y)\n" 988 "#define Q_FOREACH(x, y)\n" 989 "#define BOOST_FOREACH(x, y)\n" 990 "#define UNKNOWN_FOREACH(x, y)\n"); 991 992 // Not as function-like macros. 993 verifyFormat("#define foreach (x, y)\n" 994 "#define Q_FOREACH (x, y)\n" 995 "#define BOOST_FOREACH (x, y)\n" 996 "#define UNKNOWN_FOREACH (x, y)\n"); 997 } 998 999 TEST_F(FormatTest, FormatsWhileLoop) { 1000 verifyFormat("while (true) {\n}"); 1001 verifyFormat("while (true)\n" 1002 " f();"); 1003 verifyFormat("while () {\n}"); 1004 verifyFormat("while () {\n" 1005 " f();\n" 1006 "}"); 1007 } 1008 1009 TEST_F(FormatTest, FormatsDoWhile) { 1010 verifyFormat("do {\n" 1011 " do_something();\n" 1012 "} while (something());"); 1013 verifyFormat("do\n" 1014 " do_something();\n" 1015 "while (something());"); 1016 } 1017 1018 TEST_F(FormatTest, FormatsSwitchStatement) { 1019 verifyFormat("switch (x) {\n" 1020 "case 1:\n" 1021 " f();\n" 1022 " break;\n" 1023 "case kFoo:\n" 1024 "case ns::kBar:\n" 1025 "case kBaz:\n" 1026 " break;\n" 1027 "default:\n" 1028 " g();\n" 1029 " break;\n" 1030 "}"); 1031 verifyFormat("switch (x) {\n" 1032 "case 1: {\n" 1033 " f();\n" 1034 " break;\n" 1035 "}\n" 1036 "case 2: {\n" 1037 " break;\n" 1038 "}\n" 1039 "}"); 1040 verifyFormat("switch (x) {\n" 1041 "case 1: {\n" 1042 " f();\n" 1043 " {\n" 1044 " g();\n" 1045 " h();\n" 1046 " }\n" 1047 " break;\n" 1048 "}\n" 1049 "}"); 1050 verifyFormat("switch (x) {\n" 1051 "case 1: {\n" 1052 " f();\n" 1053 " if (foo) {\n" 1054 " g();\n" 1055 " h();\n" 1056 " }\n" 1057 " break;\n" 1058 "}\n" 1059 "}"); 1060 verifyFormat("switch (x) {\n" 1061 "case 1: {\n" 1062 " f();\n" 1063 " g();\n" 1064 "} break;\n" 1065 "}"); 1066 verifyFormat("switch (test)\n" 1067 " ;"); 1068 verifyFormat("switch (x) {\n" 1069 "default: {\n" 1070 " // Do nothing.\n" 1071 "}\n" 1072 "}"); 1073 verifyFormat("switch (x) {\n" 1074 "// comment\n" 1075 "// if 1, do f()\n" 1076 "case 1:\n" 1077 " f();\n" 1078 "}"); 1079 verifyFormat("switch (x) {\n" 1080 "case 1:\n" 1081 " // Do amazing stuff\n" 1082 " {\n" 1083 " f();\n" 1084 " g();\n" 1085 " }\n" 1086 " break;\n" 1087 "}"); 1088 verifyFormat("#define A \\\n" 1089 " switch (x) { \\\n" 1090 " case a: \\\n" 1091 " foo = b; \\\n" 1092 " }", 1093 getLLVMStyleWithColumns(20)); 1094 verifyFormat("#define OPERATION_CASE(name) \\\n" 1095 " case OP_name: \\\n" 1096 " return operations::Operation##name\n", 1097 getLLVMStyleWithColumns(40)); 1098 verifyFormat("switch (x) {\n" 1099 "case 1:;\n" 1100 "default:;\n" 1101 " int i;\n" 1102 "}"); 1103 1104 verifyGoogleFormat("switch (x) {\n" 1105 " case 1:\n" 1106 " f();\n" 1107 " break;\n" 1108 " case kFoo:\n" 1109 " case ns::kBar:\n" 1110 " case kBaz:\n" 1111 " break;\n" 1112 " default:\n" 1113 " g();\n" 1114 " break;\n" 1115 "}"); 1116 verifyGoogleFormat("switch (x) {\n" 1117 " case 1: {\n" 1118 " f();\n" 1119 " break;\n" 1120 " }\n" 1121 "}"); 1122 verifyGoogleFormat("switch (test)\n" 1123 " ;"); 1124 1125 verifyGoogleFormat("#define OPERATION_CASE(name) \\\n" 1126 " case OP_name: \\\n" 1127 " return operations::Operation##name\n"); 1128 verifyGoogleFormat("Operation codeToOperation(OperationCode OpCode) {\n" 1129 " // Get the correction operation class.\n" 1130 " switch (OpCode) {\n" 1131 " CASE(Add);\n" 1132 " CASE(Subtract);\n" 1133 " default:\n" 1134 " return operations::Unknown;\n" 1135 " }\n" 1136 "#undef OPERATION_CASE\n" 1137 "}"); 1138 verifyFormat("DEBUG({\n" 1139 " switch (x) {\n" 1140 " case A:\n" 1141 " f();\n" 1142 " break;\n" 1143 " // fallthrough\n" 1144 " case B:\n" 1145 " g();\n" 1146 " break;\n" 1147 " }\n" 1148 "});"); 1149 EXPECT_EQ("DEBUG({\n" 1150 " switch (x) {\n" 1151 " case A:\n" 1152 " f();\n" 1153 " break;\n" 1154 " // On B:\n" 1155 " case B:\n" 1156 " g();\n" 1157 " break;\n" 1158 " }\n" 1159 "});", 1160 format("DEBUG({\n" 1161 " switch (x) {\n" 1162 " case A:\n" 1163 " f();\n" 1164 " break;\n" 1165 " // On B:\n" 1166 " case B:\n" 1167 " g();\n" 1168 " break;\n" 1169 " }\n" 1170 "});", 1171 getLLVMStyle())); 1172 EXPECT_EQ("switch (n) {\n" 1173 "case 0: {\n" 1174 " return false;\n" 1175 "}\n" 1176 "default: {\n" 1177 " return true;\n" 1178 "}\n" 1179 "}", 1180 format("switch (n)\n" 1181 "{\n" 1182 "case 0: {\n" 1183 " return false;\n" 1184 "}\n" 1185 "default: {\n" 1186 " return true;\n" 1187 "}\n" 1188 "}", 1189 getLLVMStyle())); 1190 verifyFormat("switch (a) {\n" 1191 "case (b):\n" 1192 " return;\n" 1193 "}"); 1194 1195 verifyFormat("switch (a) {\n" 1196 "case some_namespace::\n" 1197 " some_constant:\n" 1198 " return;\n" 1199 "}", 1200 getLLVMStyleWithColumns(34)); 1201 1202 FormatStyle Style = getLLVMStyle(); 1203 Style.IndentCaseLabels = true; 1204 Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Never; 1205 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 1206 Style.BraceWrapping.AfterCaseLabel = true; 1207 Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always; 1208 EXPECT_EQ("switch (n)\n" 1209 "{\n" 1210 " case 0:\n" 1211 " {\n" 1212 " return false;\n" 1213 " }\n" 1214 " default:\n" 1215 " {\n" 1216 " return true;\n" 1217 " }\n" 1218 "}", 1219 format("switch (n) {\n" 1220 " case 0: {\n" 1221 " return false;\n" 1222 " }\n" 1223 " default: {\n" 1224 " return true;\n" 1225 " }\n" 1226 "}", 1227 Style)); 1228 Style.BraceWrapping.AfterCaseLabel = false; 1229 EXPECT_EQ("switch (n)\n" 1230 "{\n" 1231 " case 0: {\n" 1232 " return false;\n" 1233 " }\n" 1234 " default: {\n" 1235 " return true;\n" 1236 " }\n" 1237 "}", 1238 format("switch (n) {\n" 1239 " case 0:\n" 1240 " {\n" 1241 " return false;\n" 1242 " }\n" 1243 " default:\n" 1244 " {\n" 1245 " return true;\n" 1246 " }\n" 1247 "}", 1248 Style)); 1249 Style.IndentCaseLabels = false; 1250 Style.IndentCaseBlocks = true; 1251 EXPECT_EQ("switch (n)\n" 1252 "{\n" 1253 "case 0:\n" 1254 " {\n" 1255 " return false;\n" 1256 " }\n" 1257 "case 1:\n" 1258 " break;\n" 1259 "default:\n" 1260 " {\n" 1261 " return true;\n" 1262 " }\n" 1263 "}", 1264 format("switch (n) {\n" 1265 "case 0: {\n" 1266 " return false;\n" 1267 "}\n" 1268 "case 1:\n" 1269 " break;\n" 1270 "default: {\n" 1271 " return true;\n" 1272 "}\n" 1273 "}", 1274 Style)); 1275 Style.IndentCaseLabels = true; 1276 Style.IndentCaseBlocks = true; 1277 EXPECT_EQ("switch (n)\n" 1278 "{\n" 1279 " case 0:\n" 1280 " {\n" 1281 " return false;\n" 1282 " }\n" 1283 " case 1:\n" 1284 " break;\n" 1285 " default:\n" 1286 " {\n" 1287 " return true;\n" 1288 " }\n" 1289 "}", 1290 format("switch (n) {\n" 1291 "case 0: {\n" 1292 " return false;\n" 1293 "}\n" 1294 "case 1:\n" 1295 " break;\n" 1296 "default: {\n" 1297 " return true;\n" 1298 "}\n" 1299 "}", 1300 Style)); 1301 } 1302 1303 TEST_F(FormatTest, CaseRanges) { 1304 verifyFormat("switch (x) {\n" 1305 "case 'A' ... 'Z':\n" 1306 "case 1 ... 5:\n" 1307 "case a ... b:\n" 1308 " break;\n" 1309 "}"); 1310 } 1311 1312 TEST_F(FormatTest, ShortEnums) { 1313 FormatStyle Style = getLLVMStyle(); 1314 Style.AllowShortEnumsOnASingleLine = true; 1315 verifyFormat("enum { A, B, C } ShortEnum1, ShortEnum2;", Style); 1316 Style.AllowShortEnumsOnASingleLine = false; 1317 verifyFormat("enum\n" 1318 "{\n" 1319 " A,\n" 1320 " B,\n" 1321 " C\n" 1322 "} ShortEnum1, ShortEnum2;", 1323 Style); 1324 } 1325 1326 TEST_F(FormatTest, ShortCaseLabels) { 1327 FormatStyle Style = getLLVMStyle(); 1328 Style.AllowShortCaseLabelsOnASingleLine = true; 1329 verifyFormat("switch (a) {\n" 1330 "case 1: x = 1; break;\n" 1331 "case 2: return;\n" 1332 "case 3:\n" 1333 "case 4:\n" 1334 "case 5: return;\n" 1335 "case 6: // comment\n" 1336 " return;\n" 1337 "case 7:\n" 1338 " // comment\n" 1339 " return;\n" 1340 "case 8:\n" 1341 " x = 8; // comment\n" 1342 " break;\n" 1343 "default: y = 1; break;\n" 1344 "}", 1345 Style); 1346 verifyFormat("switch (a) {\n" 1347 "case 0: return; // comment\n" 1348 "case 1: break; // comment\n" 1349 "case 2: return;\n" 1350 "// comment\n" 1351 "case 3: return;\n" 1352 "// comment 1\n" 1353 "// comment 2\n" 1354 "// comment 3\n" 1355 "case 4: break; /* comment */\n" 1356 "case 5:\n" 1357 " // comment\n" 1358 " break;\n" 1359 "case 6: /* comment */ x = 1; break;\n" 1360 "case 7: x = /* comment */ 1; break;\n" 1361 "case 8:\n" 1362 " x = 1; /* comment */\n" 1363 " break;\n" 1364 "case 9:\n" 1365 " break; // comment line 1\n" 1366 " // comment line 2\n" 1367 "}", 1368 Style); 1369 EXPECT_EQ("switch (a) {\n" 1370 "case 1:\n" 1371 " x = 8;\n" 1372 " // fall through\n" 1373 "case 2: x = 8;\n" 1374 "// comment\n" 1375 "case 3:\n" 1376 " return; /* comment line 1\n" 1377 " * comment line 2 */\n" 1378 "case 4: i = 8;\n" 1379 "// something else\n" 1380 "#if FOO\n" 1381 "case 5: break;\n" 1382 "#endif\n" 1383 "}", 1384 format("switch (a) {\n" 1385 "case 1: x = 8;\n" 1386 " // fall through\n" 1387 "case 2:\n" 1388 " x = 8;\n" 1389 "// comment\n" 1390 "case 3:\n" 1391 " return; /* comment line 1\n" 1392 " * comment line 2 */\n" 1393 "case 4:\n" 1394 " i = 8;\n" 1395 "// something else\n" 1396 "#if FOO\n" 1397 "case 5: break;\n" 1398 "#endif\n" 1399 "}", 1400 Style)); 1401 EXPECT_EQ("switch (a) {\n" 1402 "case 0:\n" 1403 " return; // long long long long long long long long long long " 1404 "long long comment\n" 1405 " // line\n" 1406 "}", 1407 format("switch (a) {\n" 1408 "case 0: return; // long long long long long long long long " 1409 "long long long long comment line\n" 1410 "}", 1411 Style)); 1412 EXPECT_EQ("switch (a) {\n" 1413 "case 0:\n" 1414 " return; /* long long long long long long long long long long " 1415 "long long comment\n" 1416 " line */\n" 1417 "}", 1418 format("switch (a) {\n" 1419 "case 0: return; /* long long long long long long long long " 1420 "long long long long comment line */\n" 1421 "}", 1422 Style)); 1423 verifyFormat("switch (a) {\n" 1424 "#if FOO\n" 1425 "case 0: return 0;\n" 1426 "#endif\n" 1427 "}", 1428 Style); 1429 verifyFormat("switch (a) {\n" 1430 "case 1: {\n" 1431 "}\n" 1432 "case 2: {\n" 1433 " return;\n" 1434 "}\n" 1435 "case 3: {\n" 1436 " x = 1;\n" 1437 " return;\n" 1438 "}\n" 1439 "case 4:\n" 1440 " if (x)\n" 1441 " return;\n" 1442 "}", 1443 Style); 1444 Style.ColumnLimit = 21; 1445 verifyFormat("switch (a) {\n" 1446 "case 1: x = 1; break;\n" 1447 "case 2: return;\n" 1448 "case 3:\n" 1449 "case 4:\n" 1450 "case 5: return;\n" 1451 "default:\n" 1452 " y = 1;\n" 1453 " break;\n" 1454 "}", 1455 Style); 1456 Style.ColumnLimit = 80; 1457 Style.AllowShortCaseLabelsOnASingleLine = false; 1458 Style.IndentCaseLabels = true; 1459 EXPECT_EQ("switch (n) {\n" 1460 " default /*comments*/:\n" 1461 " return true;\n" 1462 " case 0:\n" 1463 " return false;\n" 1464 "}", 1465 format("switch (n) {\n" 1466 "default/*comments*/:\n" 1467 " return true;\n" 1468 "case 0:\n" 1469 " return false;\n" 1470 "}", 1471 Style)); 1472 Style.AllowShortCaseLabelsOnASingleLine = true; 1473 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 1474 Style.BraceWrapping.AfterCaseLabel = true; 1475 Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always; 1476 EXPECT_EQ("switch (n)\n" 1477 "{\n" 1478 " case 0:\n" 1479 " {\n" 1480 " return false;\n" 1481 " }\n" 1482 " default:\n" 1483 " {\n" 1484 " return true;\n" 1485 " }\n" 1486 "}", 1487 format("switch (n) {\n" 1488 " case 0: {\n" 1489 " return false;\n" 1490 " }\n" 1491 " default:\n" 1492 " {\n" 1493 " return true;\n" 1494 " }\n" 1495 "}", 1496 Style)); 1497 } 1498 1499 TEST_F(FormatTest, FormatsLabels) { 1500 verifyFormat("void f() {\n" 1501 " some_code();\n" 1502 "test_label:\n" 1503 " some_other_code();\n" 1504 " {\n" 1505 " some_more_code();\n" 1506 " another_label:\n" 1507 " some_more_code();\n" 1508 " }\n" 1509 "}"); 1510 verifyFormat("{\n" 1511 " some_code();\n" 1512 "test_label:\n" 1513 " some_other_code();\n" 1514 "}"); 1515 verifyFormat("{\n" 1516 " some_code();\n" 1517 "test_label:;\n" 1518 " int i = 0;\n" 1519 "}"); 1520 FormatStyle Style = getLLVMStyle(); 1521 Style.IndentGotoLabels = false; 1522 verifyFormat("void f() {\n" 1523 " some_code();\n" 1524 "test_label:\n" 1525 " some_other_code();\n" 1526 " {\n" 1527 " some_more_code();\n" 1528 "another_label:\n" 1529 " some_more_code();\n" 1530 " }\n" 1531 "}", 1532 Style); 1533 verifyFormat("{\n" 1534 " some_code();\n" 1535 "test_label:\n" 1536 " some_other_code();\n" 1537 "}", 1538 Style); 1539 verifyFormat("{\n" 1540 " some_code();\n" 1541 "test_label:;\n" 1542 " int i = 0;\n" 1543 "}"); 1544 } 1545 1546 TEST_F(FormatTest, MultiLineControlStatements) { 1547 FormatStyle Style = getLLVMStyle(); 1548 Style.BreakBeforeBraces = FormatStyle::BraceBreakingStyle::BS_Custom; 1549 Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_MultiLine; 1550 Style.ColumnLimit = 20; 1551 // Short lines should keep opening brace on same line. 1552 EXPECT_EQ("if (foo) {\n" 1553 " bar();\n" 1554 "}", 1555 format("if(foo){bar();}", Style)); 1556 EXPECT_EQ("if (foo) {\n" 1557 " bar();\n" 1558 "} else {\n" 1559 " baz();\n" 1560 "}", 1561 format("if(foo){bar();}else{baz();}", Style)); 1562 EXPECT_EQ("if (foo && bar) {\n" 1563 " baz();\n" 1564 "}", 1565 format("if(foo&&bar){baz();}", Style)); 1566 EXPECT_EQ("if (foo) {\n" 1567 " bar();\n" 1568 "} else if (baz) {\n" 1569 " quux();\n" 1570 "}", 1571 format("if(foo){bar();}else if(baz){quux();}", Style)); 1572 EXPECT_EQ( 1573 "if (foo) {\n" 1574 " bar();\n" 1575 "} else if (baz) {\n" 1576 " quux();\n" 1577 "} else {\n" 1578 " foobar();\n" 1579 "}", 1580 format("if(foo){bar();}else if(baz){quux();}else{foobar();}", Style)); 1581 EXPECT_EQ("for (;;) {\n" 1582 " foo();\n" 1583 "}", 1584 format("for(;;){foo();}")); 1585 EXPECT_EQ("while (1) {\n" 1586 " foo();\n" 1587 "}", 1588 format("while(1){foo();}", Style)); 1589 EXPECT_EQ("switch (foo) {\n" 1590 "case bar:\n" 1591 " return;\n" 1592 "}", 1593 format("switch(foo){case bar:return;}", Style)); 1594 EXPECT_EQ("try {\n" 1595 " foo();\n" 1596 "} catch (...) {\n" 1597 " bar();\n" 1598 "}", 1599 format("try{foo();}catch(...){bar();}", Style)); 1600 EXPECT_EQ("do {\n" 1601 " foo();\n" 1602 "} while (bar &&\n" 1603 " baz);", 1604 format("do{foo();}while(bar&&baz);", Style)); 1605 // Long lines should put opening brace on new line. 1606 EXPECT_EQ("if (foo && bar &&\n" 1607 " baz)\n" 1608 "{\n" 1609 " quux();\n" 1610 "}", 1611 format("if(foo&&bar&&baz){quux();}", Style)); 1612 EXPECT_EQ("if (foo && bar &&\n" 1613 " baz)\n" 1614 "{\n" 1615 " quux();\n" 1616 "}", 1617 format("if (foo && bar &&\n" 1618 " baz) {\n" 1619 " quux();\n" 1620 "}", 1621 Style)); 1622 EXPECT_EQ("if (foo) {\n" 1623 " bar();\n" 1624 "} else if (baz ||\n" 1625 " quux)\n" 1626 "{\n" 1627 " foobar();\n" 1628 "}", 1629 format("if(foo){bar();}else if(baz||quux){foobar();}", Style)); 1630 EXPECT_EQ( 1631 "if (foo) {\n" 1632 " bar();\n" 1633 "} else if (baz ||\n" 1634 " quux)\n" 1635 "{\n" 1636 " foobar();\n" 1637 "} else {\n" 1638 " barbaz();\n" 1639 "}", 1640 format("if(foo){bar();}else if(baz||quux){foobar();}else{barbaz();}", 1641 Style)); 1642 EXPECT_EQ("for (int i = 0;\n" 1643 " i < 10; ++i)\n" 1644 "{\n" 1645 " foo();\n" 1646 "}", 1647 format("for(int i=0;i<10;++i){foo();}", Style)); 1648 EXPECT_EQ("while (foo || bar ||\n" 1649 " baz)\n" 1650 "{\n" 1651 " quux();\n" 1652 "}", 1653 format("while(foo||bar||baz){quux();}", Style)); 1654 EXPECT_EQ("switch (\n" 1655 " foo = barbaz)\n" 1656 "{\n" 1657 "case quux:\n" 1658 " return;\n" 1659 "}", 1660 format("switch(foo=barbaz){case quux:return;}", Style)); 1661 EXPECT_EQ("try {\n" 1662 " foo();\n" 1663 "} catch (\n" 1664 " Exception &bar)\n" 1665 "{\n" 1666 " baz();\n" 1667 "}", 1668 format("try{foo();}catch(Exception&bar){baz();}", Style)); 1669 Style.ColumnLimit = 1670 40; // to concentrate at brace wrapping, not line wrap due to column limit 1671 EXPECT_EQ("try {\n" 1672 " foo();\n" 1673 "} catch (Exception &bar) {\n" 1674 " baz();\n" 1675 "}", 1676 format("try{foo();}catch(Exception&bar){baz();}", Style)); 1677 Style.ColumnLimit = 1678 20; // to concentrate at brace wrapping, not line wrap due to column limit 1679 1680 Style.BraceWrapping.BeforeElse = true; 1681 EXPECT_EQ( 1682 "if (foo) {\n" 1683 " bar();\n" 1684 "}\n" 1685 "else if (baz ||\n" 1686 " quux)\n" 1687 "{\n" 1688 " foobar();\n" 1689 "}\n" 1690 "else {\n" 1691 " barbaz();\n" 1692 "}", 1693 format("if(foo){bar();}else if(baz||quux){foobar();}else{barbaz();}", 1694 Style)); 1695 1696 Style.BraceWrapping.BeforeCatch = true; 1697 EXPECT_EQ("try {\n" 1698 " foo();\n" 1699 "}\n" 1700 "catch (...) {\n" 1701 " baz();\n" 1702 "}", 1703 format("try{foo();}catch(...){baz();}", Style)); 1704 } 1705 1706 //===----------------------------------------------------------------------===// 1707 // Tests for classes, namespaces, etc. 1708 //===----------------------------------------------------------------------===// 1709 1710 TEST_F(FormatTest, DoesNotBreakSemiAfterClassDecl) { 1711 verifyFormat("class A {};"); 1712 } 1713 1714 TEST_F(FormatTest, UnderstandsAccessSpecifiers) { 1715 verifyFormat("class A {\n" 1716 "public:\n" 1717 "public: // comment\n" 1718 "protected:\n" 1719 "private:\n" 1720 " void f() {}\n" 1721 "};"); 1722 verifyFormat("export class A {\n" 1723 "public:\n" 1724 "public: // comment\n" 1725 "protected:\n" 1726 "private:\n" 1727 " void f() {}\n" 1728 "};"); 1729 verifyGoogleFormat("class A {\n" 1730 " public:\n" 1731 " protected:\n" 1732 " private:\n" 1733 " void f() {}\n" 1734 "};"); 1735 verifyGoogleFormat("export class A {\n" 1736 " public:\n" 1737 " protected:\n" 1738 " private:\n" 1739 " void f() {}\n" 1740 "};"); 1741 verifyFormat("class A {\n" 1742 "public slots:\n" 1743 " void f1() {}\n" 1744 "public Q_SLOTS:\n" 1745 " void f2() {}\n" 1746 "protected slots:\n" 1747 " void f3() {}\n" 1748 "protected Q_SLOTS:\n" 1749 " void f4() {}\n" 1750 "private slots:\n" 1751 " void f5() {}\n" 1752 "private Q_SLOTS:\n" 1753 " void f6() {}\n" 1754 "signals:\n" 1755 " void g1();\n" 1756 "Q_SIGNALS:\n" 1757 " void g2();\n" 1758 "};"); 1759 1760 // Don't interpret 'signals' the wrong way. 1761 verifyFormat("signals.set();"); 1762 verifyFormat("for (Signals signals : f()) {\n}"); 1763 verifyFormat("{\n" 1764 " signals.set(); // This needs indentation.\n" 1765 "}"); 1766 verifyFormat("void f() {\n" 1767 "label:\n" 1768 " signals.baz();\n" 1769 "}"); 1770 } 1771 1772 TEST_F(FormatTest, SeparatesLogicalBlocks) { 1773 EXPECT_EQ("class A {\n" 1774 "public:\n" 1775 " void f();\n" 1776 "\n" 1777 "private:\n" 1778 " void g() {}\n" 1779 " // test\n" 1780 "protected:\n" 1781 " int h;\n" 1782 "};", 1783 format("class A {\n" 1784 "public:\n" 1785 "void f();\n" 1786 "private:\n" 1787 "void g() {}\n" 1788 "// test\n" 1789 "protected:\n" 1790 "int h;\n" 1791 "};")); 1792 EXPECT_EQ("class A {\n" 1793 "protected:\n" 1794 "public:\n" 1795 " void f();\n" 1796 "};", 1797 format("class A {\n" 1798 "protected:\n" 1799 "\n" 1800 "public:\n" 1801 "\n" 1802 " void f();\n" 1803 "};")); 1804 1805 // Even ensure proper spacing inside macros. 1806 EXPECT_EQ("#define B \\\n" 1807 " class A { \\\n" 1808 " protected: \\\n" 1809 " public: \\\n" 1810 " void f(); \\\n" 1811 " };", 1812 format("#define B \\\n" 1813 " class A { \\\n" 1814 " protected: \\\n" 1815 " \\\n" 1816 " public: \\\n" 1817 " \\\n" 1818 " void f(); \\\n" 1819 " };", 1820 getGoogleStyle())); 1821 // But don't remove empty lines after macros ending in access specifiers. 1822 EXPECT_EQ("#define A private:\n" 1823 "\n" 1824 "int i;", 1825 format("#define A private:\n" 1826 "\n" 1827 "int i;")); 1828 } 1829 1830 TEST_F(FormatTest, FormatsClasses) { 1831 verifyFormat("class A : public B {};"); 1832 verifyFormat("class A : public ::B {};"); 1833 1834 verifyFormat( 1835 "class AAAAAAAAAAAAAAAAAAAA : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n" 1836 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};"); 1837 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n" 1838 " : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n" 1839 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};"); 1840 verifyFormat( 1841 "class A : public B, public C, public D, public E, public F {};"); 1842 verifyFormat("class AAAAAAAAAAAA : public B,\n" 1843 " public C,\n" 1844 " public D,\n" 1845 " public E,\n" 1846 " public F,\n" 1847 " public G {};"); 1848 1849 verifyFormat("class\n" 1850 " ReallyReallyLongClassName {\n" 1851 " int i;\n" 1852 "};", 1853 getLLVMStyleWithColumns(32)); 1854 verifyFormat("struct aaaaaaaaaaaaa : public aaaaaaaaaaaaaaaaaaa< // break\n" 1855 " aaaaaaaaaaaaaaaa> {};"); 1856 verifyFormat("struct aaaaaaaaaaaaaaaaaaaa\n" 1857 " : public aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaa,\n" 1858 " aaaaaaaaaaaaaaaaaaaaaa> {};"); 1859 verifyFormat("template <class R, class C>\n" 1860 "struct Aaaaaaaaaaaaaaaaa<R (C::*)(int) const>\n" 1861 " : Aaaaaaaaaaaaaaaaa<R (C::*)(int)> {};"); 1862 verifyFormat("class ::A::B {};"); 1863 } 1864 1865 TEST_F(FormatTest, BreakInheritanceStyle) { 1866 FormatStyle StyleWithInheritanceBreakBeforeComma = getLLVMStyle(); 1867 StyleWithInheritanceBreakBeforeComma.BreakInheritanceList = 1868 FormatStyle::BILS_BeforeComma; 1869 verifyFormat("class MyClass : public X {};", 1870 StyleWithInheritanceBreakBeforeComma); 1871 verifyFormat("class MyClass\n" 1872 " : public X\n" 1873 " , public Y {};", 1874 StyleWithInheritanceBreakBeforeComma); 1875 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAA\n" 1876 " : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n" 1877 " , public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};", 1878 StyleWithInheritanceBreakBeforeComma); 1879 verifyFormat("struct aaaaaaaaaaaaa\n" 1880 " : public aaaaaaaaaaaaaaaaaaa< // break\n" 1881 " aaaaaaaaaaaaaaaa> {};", 1882 StyleWithInheritanceBreakBeforeComma); 1883 1884 FormatStyle StyleWithInheritanceBreakAfterColon = getLLVMStyle(); 1885 StyleWithInheritanceBreakAfterColon.BreakInheritanceList = 1886 FormatStyle::BILS_AfterColon; 1887 verifyFormat("class MyClass : public X {};", 1888 StyleWithInheritanceBreakAfterColon); 1889 verifyFormat("class MyClass : public X, public Y {};", 1890 StyleWithInheritanceBreakAfterColon); 1891 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAA :\n" 1892 " public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n" 1893 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};", 1894 StyleWithInheritanceBreakAfterColon); 1895 verifyFormat("struct aaaaaaaaaaaaa :\n" 1896 " public aaaaaaaaaaaaaaaaaaa< // break\n" 1897 " aaaaaaaaaaaaaaaa> {};", 1898 StyleWithInheritanceBreakAfterColon); 1899 } 1900 1901 TEST_F(FormatTest, FormatsVariableDeclarationsAfterStructOrClass) { 1902 verifyFormat("class A {\n} a, b;"); 1903 verifyFormat("struct A {\n} a, b;"); 1904 verifyFormat("union A {\n} a;"); 1905 } 1906 1907 TEST_F(FormatTest, FormatsEnum) { 1908 verifyFormat("enum {\n" 1909 " Zero,\n" 1910 " One = 1,\n" 1911 " Two = One + 1,\n" 1912 " Three = (One + Two),\n" 1913 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1914 " Five = (One, Two, Three, Four, 5)\n" 1915 "};"); 1916 verifyGoogleFormat("enum {\n" 1917 " Zero,\n" 1918 " One = 1,\n" 1919 " Two = One + 1,\n" 1920 " Three = (One + Two),\n" 1921 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1922 " Five = (One, Two, Three, Four, 5)\n" 1923 "};"); 1924 verifyFormat("enum Enum {};"); 1925 verifyFormat("enum {};"); 1926 verifyFormat("enum X E {} d;"); 1927 verifyFormat("enum __attribute__((...)) E {} d;"); 1928 verifyFormat("enum __declspec__((...)) E {} d;"); 1929 verifyFormat("enum {\n" 1930 " Bar = Foo<int, int>::value\n" 1931 "};", 1932 getLLVMStyleWithColumns(30)); 1933 1934 verifyFormat("enum ShortEnum { A, B, C };"); 1935 verifyGoogleFormat("enum ShortEnum { A, B, C };"); 1936 1937 EXPECT_EQ("enum KeepEmptyLines {\n" 1938 " ONE,\n" 1939 "\n" 1940 " TWO,\n" 1941 "\n" 1942 " THREE\n" 1943 "}", 1944 format("enum KeepEmptyLines {\n" 1945 " ONE,\n" 1946 "\n" 1947 " TWO,\n" 1948 "\n" 1949 "\n" 1950 " THREE\n" 1951 "}")); 1952 verifyFormat("enum E { // comment\n" 1953 " ONE,\n" 1954 " TWO\n" 1955 "};\n" 1956 "int i;"); 1957 1958 FormatStyle EightIndent = getLLVMStyle(); 1959 EightIndent.IndentWidth = 8; 1960 verifyFormat("enum {\n" 1961 " VOID,\n" 1962 " CHAR,\n" 1963 " SHORT,\n" 1964 " INT,\n" 1965 " LONG,\n" 1966 " SIGNED,\n" 1967 " UNSIGNED,\n" 1968 " BOOL,\n" 1969 " FLOAT,\n" 1970 " DOUBLE,\n" 1971 " COMPLEX\n" 1972 "};", 1973 EightIndent); 1974 1975 // Not enums. 1976 verifyFormat("enum X f() {\n" 1977 " a();\n" 1978 " return 42;\n" 1979 "}"); 1980 verifyFormat("enum X Type::f() {\n" 1981 " a();\n" 1982 " return 42;\n" 1983 "}"); 1984 verifyFormat("enum ::X f() {\n" 1985 " a();\n" 1986 " return 42;\n" 1987 "}"); 1988 verifyFormat("enum ns::X f() {\n" 1989 " a();\n" 1990 " return 42;\n" 1991 "}"); 1992 } 1993 1994 TEST_F(FormatTest, FormatsEnumsWithErrors) { 1995 verifyFormat("enum Type {\n" 1996 " One = 0; // These semicolons should be commas.\n" 1997 " Two = 1;\n" 1998 "};"); 1999 verifyFormat("namespace n {\n" 2000 "enum Type {\n" 2001 " One,\n" 2002 " Two, // missing };\n" 2003 " int i;\n" 2004 "}\n" 2005 "void g() {}"); 2006 } 2007 2008 TEST_F(FormatTest, FormatsEnumStruct) { 2009 verifyFormat("enum struct {\n" 2010 " Zero,\n" 2011 " One = 1,\n" 2012 " Two = One + 1,\n" 2013 " Three = (One + Two),\n" 2014 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 2015 " Five = (One, Two, Three, Four, 5)\n" 2016 "};"); 2017 verifyFormat("enum struct Enum {};"); 2018 verifyFormat("enum struct {};"); 2019 verifyFormat("enum struct X E {} d;"); 2020 verifyFormat("enum struct __attribute__((...)) E {} d;"); 2021 verifyFormat("enum struct __declspec__((...)) E {} d;"); 2022 verifyFormat("enum struct X f() {\n a();\n return 42;\n}"); 2023 } 2024 2025 TEST_F(FormatTest, FormatsEnumClass) { 2026 verifyFormat("enum class {\n" 2027 " Zero,\n" 2028 " One = 1,\n" 2029 " Two = One + 1,\n" 2030 " Three = (One + Two),\n" 2031 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 2032 " Five = (One, Two, Three, Four, 5)\n" 2033 "};"); 2034 verifyFormat("enum class Enum {};"); 2035 verifyFormat("enum class {};"); 2036 verifyFormat("enum class X E {} d;"); 2037 verifyFormat("enum class __attribute__((...)) E {} d;"); 2038 verifyFormat("enum class __declspec__((...)) E {} d;"); 2039 verifyFormat("enum class X f() {\n a();\n return 42;\n}"); 2040 } 2041 2042 TEST_F(FormatTest, FormatsEnumTypes) { 2043 verifyFormat("enum X : int {\n" 2044 " A, // Force multiple lines.\n" 2045 " B\n" 2046 "};"); 2047 verifyFormat("enum X : int { A, B };"); 2048 verifyFormat("enum X : std::uint32_t { A, B };"); 2049 } 2050 2051 TEST_F(FormatTest, FormatsTypedefEnum) { 2052 FormatStyle Style = getLLVMStyle(); 2053 Style.ColumnLimit = 40; 2054 verifyFormat("typedef enum {} EmptyEnum;"); 2055 verifyFormat("typedef enum { A, B, C } ShortEnum;"); 2056 verifyFormat("typedef enum {\n" 2057 " ZERO = 0,\n" 2058 " ONE = 1,\n" 2059 " TWO = 2,\n" 2060 " THREE = 3\n" 2061 "} LongEnum;", 2062 Style); 2063 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 2064 Style.BraceWrapping.AfterEnum = true; 2065 verifyFormat("typedef enum {} EmptyEnum;"); 2066 verifyFormat("typedef enum { A, B, C } ShortEnum;"); 2067 verifyFormat("typedef enum\n" 2068 "{\n" 2069 " ZERO = 0,\n" 2070 " ONE = 1,\n" 2071 " TWO = 2,\n" 2072 " THREE = 3\n" 2073 "} LongEnum;", 2074 Style); 2075 } 2076 2077 TEST_F(FormatTest, FormatsNSEnums) { 2078 verifyGoogleFormat("typedef NS_ENUM(NSInteger, SomeName) { AAA, BBB }"); 2079 verifyGoogleFormat( 2080 "typedef NS_CLOSED_ENUM(NSInteger, SomeName) { AAA, BBB }"); 2081 verifyGoogleFormat("typedef NS_ENUM(NSInteger, MyType) {\n" 2082 " // Information about someDecentlyLongValue.\n" 2083 " someDecentlyLongValue,\n" 2084 " // Information about anotherDecentlyLongValue.\n" 2085 " anotherDecentlyLongValue,\n" 2086 " // Information about aThirdDecentlyLongValue.\n" 2087 " aThirdDecentlyLongValue\n" 2088 "};"); 2089 verifyGoogleFormat("typedef NS_CLOSED_ENUM(NSInteger, MyType) {\n" 2090 " // Information about someDecentlyLongValue.\n" 2091 " someDecentlyLongValue,\n" 2092 " // Information about anotherDecentlyLongValue.\n" 2093 " anotherDecentlyLongValue,\n" 2094 " // Information about aThirdDecentlyLongValue.\n" 2095 " aThirdDecentlyLongValue\n" 2096 "};"); 2097 verifyGoogleFormat("typedef NS_OPTIONS(NSInteger, MyType) {\n" 2098 " a = 1,\n" 2099 " b = 2,\n" 2100 " c = 3,\n" 2101 "};"); 2102 verifyGoogleFormat("typedef CF_ENUM(NSInteger, MyType) {\n" 2103 " a = 1,\n" 2104 " b = 2,\n" 2105 " c = 3,\n" 2106 "};"); 2107 verifyGoogleFormat("typedef CF_CLOSED_ENUM(NSInteger, MyType) {\n" 2108 " a = 1,\n" 2109 " b = 2,\n" 2110 " c = 3,\n" 2111 "};"); 2112 verifyGoogleFormat("typedef CF_OPTIONS(NSInteger, MyType) {\n" 2113 " a = 1,\n" 2114 " b = 2,\n" 2115 " c = 3,\n" 2116 "};"); 2117 } 2118 2119 TEST_F(FormatTest, FormatsBitfields) { 2120 verifyFormat("struct Bitfields {\n" 2121 " unsigned sClass : 8;\n" 2122 " unsigned ValueKind : 2;\n" 2123 "};"); 2124 verifyFormat("struct A {\n" 2125 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa : 1,\n" 2126 " bbbbbbbbbbbbbbbbbbbbbbbbb;\n" 2127 "};"); 2128 verifyFormat("struct MyStruct {\n" 2129 " uchar data;\n" 2130 " uchar : 8;\n" 2131 " uchar : 8;\n" 2132 " uchar other;\n" 2133 "};"); 2134 } 2135 2136 TEST_F(FormatTest, FormatsNamespaces) { 2137 FormatStyle LLVMWithNoNamespaceFix = getLLVMStyle(); 2138 LLVMWithNoNamespaceFix.FixNamespaceComments = false; 2139 2140 verifyFormat("namespace some_namespace {\n" 2141 "class A {};\n" 2142 "void f() { f(); }\n" 2143 "}", 2144 LLVMWithNoNamespaceFix); 2145 verifyFormat("namespace N::inline D {\n" 2146 "class A {};\n" 2147 "void f() { f(); }\n" 2148 "}", 2149 LLVMWithNoNamespaceFix); 2150 verifyFormat("namespace N::inline D::E {\n" 2151 "class A {};\n" 2152 "void f() { f(); }\n" 2153 "}", 2154 LLVMWithNoNamespaceFix); 2155 verifyFormat("namespace [[deprecated(\"foo[bar\")]] some_namespace {\n" 2156 "class A {};\n" 2157 "void f() { f(); }\n" 2158 "}", 2159 LLVMWithNoNamespaceFix); 2160 verifyFormat("/* something */ namespace some_namespace {\n" 2161 "class A {};\n" 2162 "void f() { f(); }\n" 2163 "}", 2164 LLVMWithNoNamespaceFix); 2165 verifyFormat("namespace {\n" 2166 "class A {};\n" 2167 "void f() { f(); }\n" 2168 "}", 2169 LLVMWithNoNamespaceFix); 2170 verifyFormat("/* something */ namespace {\n" 2171 "class A {};\n" 2172 "void f() { f(); }\n" 2173 "}", 2174 LLVMWithNoNamespaceFix); 2175 verifyFormat("inline namespace X {\n" 2176 "class A {};\n" 2177 "void f() { f(); }\n" 2178 "}", 2179 LLVMWithNoNamespaceFix); 2180 verifyFormat("/* something */ inline namespace X {\n" 2181 "class A {};\n" 2182 "void f() { f(); }\n" 2183 "}", 2184 LLVMWithNoNamespaceFix); 2185 verifyFormat("export namespace X {\n" 2186 "class A {};\n" 2187 "void f() { f(); }\n" 2188 "}", 2189 LLVMWithNoNamespaceFix); 2190 verifyFormat("using namespace some_namespace;\n" 2191 "class A {};\n" 2192 "void f() { f(); }", 2193 LLVMWithNoNamespaceFix); 2194 2195 // This code is more common than we thought; if we 2196 // layout this correctly the semicolon will go into 2197 // its own line, which is undesirable. 2198 verifyFormat("namespace {};", LLVMWithNoNamespaceFix); 2199 verifyFormat("namespace {\n" 2200 "class A {};\n" 2201 "};", 2202 LLVMWithNoNamespaceFix); 2203 2204 verifyFormat("namespace {\n" 2205 "int SomeVariable = 0; // comment\n" 2206 "} // namespace", 2207 LLVMWithNoNamespaceFix); 2208 EXPECT_EQ("#ifndef HEADER_GUARD\n" 2209 "#define HEADER_GUARD\n" 2210 "namespace my_namespace {\n" 2211 "int i;\n" 2212 "} // my_namespace\n" 2213 "#endif // HEADER_GUARD", 2214 format("#ifndef HEADER_GUARD\n" 2215 " #define HEADER_GUARD\n" 2216 " namespace my_namespace {\n" 2217 "int i;\n" 2218 "} // my_namespace\n" 2219 "#endif // HEADER_GUARD", 2220 LLVMWithNoNamespaceFix)); 2221 2222 EXPECT_EQ("namespace A::B {\n" 2223 "class C {};\n" 2224 "}", 2225 format("namespace A::B {\n" 2226 "class C {};\n" 2227 "}", 2228 LLVMWithNoNamespaceFix)); 2229 2230 FormatStyle Style = getLLVMStyle(); 2231 Style.NamespaceIndentation = FormatStyle::NI_All; 2232 EXPECT_EQ("namespace out {\n" 2233 " int i;\n" 2234 " namespace in {\n" 2235 " int i;\n" 2236 " } // namespace in\n" 2237 "} // namespace out", 2238 format("namespace out {\n" 2239 "int i;\n" 2240 "namespace in {\n" 2241 "int i;\n" 2242 "} // namespace in\n" 2243 "} // namespace out", 2244 Style)); 2245 2246 Style.NamespaceIndentation = FormatStyle::NI_Inner; 2247 EXPECT_EQ("namespace out {\n" 2248 "int i;\n" 2249 "namespace in {\n" 2250 " int i;\n" 2251 "} // namespace in\n" 2252 "} // namespace out", 2253 format("namespace out {\n" 2254 "int i;\n" 2255 "namespace in {\n" 2256 "int i;\n" 2257 "} // namespace in\n" 2258 "} // namespace out", 2259 Style)); 2260 } 2261 2262 TEST_F(FormatTest, NamespaceMacros) { 2263 FormatStyle Style = getLLVMStyle(); 2264 Style.NamespaceMacros.push_back("TESTSUITE"); 2265 2266 verifyFormat("TESTSUITE(A) {\n" 2267 "int foo();\n" 2268 "} // TESTSUITE(A)", 2269 Style); 2270 2271 verifyFormat("TESTSUITE(A, B) {\n" 2272 "int foo();\n" 2273 "} // TESTSUITE(A)", 2274 Style); 2275 2276 // Properly indent according to NamespaceIndentation style 2277 Style.NamespaceIndentation = FormatStyle::NI_All; 2278 verifyFormat("TESTSUITE(A) {\n" 2279 " int foo();\n" 2280 "} // TESTSUITE(A)", 2281 Style); 2282 verifyFormat("TESTSUITE(A) {\n" 2283 " namespace B {\n" 2284 " int foo();\n" 2285 " } // namespace B\n" 2286 "} // TESTSUITE(A)", 2287 Style); 2288 verifyFormat("namespace A {\n" 2289 " TESTSUITE(B) {\n" 2290 " int foo();\n" 2291 " } // TESTSUITE(B)\n" 2292 "} // namespace A", 2293 Style); 2294 2295 Style.NamespaceIndentation = FormatStyle::NI_Inner; 2296 verifyFormat("TESTSUITE(A) {\n" 2297 "TESTSUITE(B) {\n" 2298 " int foo();\n" 2299 "} // TESTSUITE(B)\n" 2300 "} // TESTSUITE(A)", 2301 Style); 2302 verifyFormat("TESTSUITE(A) {\n" 2303 "namespace B {\n" 2304 " int foo();\n" 2305 "} // namespace B\n" 2306 "} // TESTSUITE(A)", 2307 Style); 2308 verifyFormat("namespace A {\n" 2309 "TESTSUITE(B) {\n" 2310 " int foo();\n" 2311 "} // TESTSUITE(B)\n" 2312 "} // namespace A", 2313 Style); 2314 2315 // Properly merge namespace-macros blocks in CompactNamespaces mode 2316 Style.NamespaceIndentation = FormatStyle::NI_None; 2317 Style.CompactNamespaces = true; 2318 verifyFormat("TESTSUITE(A) { TESTSUITE(B) {\n" 2319 "}} // TESTSUITE(A::B)", 2320 Style); 2321 2322 EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n" 2323 "}} // TESTSUITE(out::in)", 2324 format("TESTSUITE(out) {\n" 2325 "TESTSUITE(in) {\n" 2326 "} // TESTSUITE(in)\n" 2327 "} // TESTSUITE(out)", 2328 Style)); 2329 2330 EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n" 2331 "}} // TESTSUITE(out::in)", 2332 format("TESTSUITE(out) {\n" 2333 "TESTSUITE(in) {\n" 2334 "} // TESTSUITE(in)\n" 2335 "} // TESTSUITE(out)", 2336 Style)); 2337 2338 // Do not merge different namespaces/macros 2339 EXPECT_EQ("namespace out {\n" 2340 "TESTSUITE(in) {\n" 2341 "} // TESTSUITE(in)\n" 2342 "} // namespace out", 2343 format("namespace out {\n" 2344 "TESTSUITE(in) {\n" 2345 "} // TESTSUITE(in)\n" 2346 "} // namespace out", 2347 Style)); 2348 EXPECT_EQ("TESTSUITE(out) {\n" 2349 "namespace in {\n" 2350 "} // namespace in\n" 2351 "} // TESTSUITE(out)", 2352 format("TESTSUITE(out) {\n" 2353 "namespace in {\n" 2354 "} // namespace in\n" 2355 "} // TESTSUITE(out)", 2356 Style)); 2357 Style.NamespaceMacros.push_back("FOOBAR"); 2358 EXPECT_EQ("TESTSUITE(out) {\n" 2359 "FOOBAR(in) {\n" 2360 "} // FOOBAR(in)\n" 2361 "} // TESTSUITE(out)", 2362 format("TESTSUITE(out) {\n" 2363 "FOOBAR(in) {\n" 2364 "} // FOOBAR(in)\n" 2365 "} // TESTSUITE(out)", 2366 Style)); 2367 } 2368 2369 TEST_F(FormatTest, FormatsCompactNamespaces) { 2370 FormatStyle Style = getLLVMStyle(); 2371 Style.CompactNamespaces = true; 2372 Style.NamespaceMacros.push_back("TESTSUITE"); 2373 2374 verifyFormat("namespace A { namespace B {\n" 2375 "}} // namespace A::B", 2376 Style); 2377 2378 EXPECT_EQ("namespace out { namespace in {\n" 2379 "}} // namespace out::in", 2380 format("namespace out {\n" 2381 "namespace in {\n" 2382 "} // namespace in\n" 2383 "} // namespace out", 2384 Style)); 2385 2386 // Only namespaces which have both consecutive opening and end get compacted 2387 EXPECT_EQ("namespace out {\n" 2388 "namespace in1 {\n" 2389 "} // namespace in1\n" 2390 "namespace in2 {\n" 2391 "} // namespace in2\n" 2392 "} // namespace out", 2393 format("namespace out {\n" 2394 "namespace in1 {\n" 2395 "} // namespace in1\n" 2396 "namespace in2 {\n" 2397 "} // namespace in2\n" 2398 "} // namespace out", 2399 Style)); 2400 2401 EXPECT_EQ("namespace out {\n" 2402 "int i;\n" 2403 "namespace in {\n" 2404 "int j;\n" 2405 "} // namespace in\n" 2406 "int k;\n" 2407 "} // namespace out", 2408 format("namespace out { int i;\n" 2409 "namespace in { int j; } // namespace in\n" 2410 "int k; } // namespace out", 2411 Style)); 2412 2413 EXPECT_EQ("namespace A { namespace B { namespace C {\n" 2414 "}}} // namespace A::B::C\n", 2415 format("namespace A { namespace B {\n" 2416 "namespace C {\n" 2417 "}} // namespace B::C\n" 2418 "} // namespace A\n", 2419 Style)); 2420 2421 Style.ColumnLimit = 40; 2422 EXPECT_EQ("namespace aaaaaaaaaa {\n" 2423 "namespace bbbbbbbbbb {\n" 2424 "}} // namespace aaaaaaaaaa::bbbbbbbbbb", 2425 format("namespace aaaaaaaaaa {\n" 2426 "namespace bbbbbbbbbb {\n" 2427 "} // namespace bbbbbbbbbb\n" 2428 "} // namespace aaaaaaaaaa", 2429 Style)); 2430 2431 EXPECT_EQ("namespace aaaaaa { namespace bbbbbb {\n" 2432 "namespace cccccc {\n" 2433 "}}} // namespace aaaaaa::bbbbbb::cccccc", 2434 format("namespace aaaaaa {\n" 2435 "namespace bbbbbb {\n" 2436 "namespace cccccc {\n" 2437 "} // namespace cccccc\n" 2438 "} // namespace bbbbbb\n" 2439 "} // namespace aaaaaa", 2440 Style)); 2441 Style.ColumnLimit = 80; 2442 2443 // Extra semicolon after 'inner' closing brace prevents merging 2444 EXPECT_EQ("namespace out { namespace in {\n" 2445 "}; } // namespace out::in", 2446 format("namespace out {\n" 2447 "namespace in {\n" 2448 "}; // namespace in\n" 2449 "} // namespace out", 2450 Style)); 2451 2452 // Extra semicolon after 'outer' closing brace is conserved 2453 EXPECT_EQ("namespace out { namespace in {\n" 2454 "}}; // namespace out::in", 2455 format("namespace out {\n" 2456 "namespace in {\n" 2457 "} // namespace in\n" 2458 "}; // namespace out", 2459 Style)); 2460 2461 Style.NamespaceIndentation = FormatStyle::NI_All; 2462 EXPECT_EQ("namespace out { namespace in {\n" 2463 " int i;\n" 2464 "}} // namespace out::in", 2465 format("namespace out {\n" 2466 "namespace in {\n" 2467 "int i;\n" 2468 "} // namespace in\n" 2469 "} // namespace out", 2470 Style)); 2471 EXPECT_EQ("namespace out { namespace mid {\n" 2472 " namespace in {\n" 2473 " int j;\n" 2474 " } // namespace in\n" 2475 " int k;\n" 2476 "}} // namespace out::mid", 2477 format("namespace out { namespace mid {\n" 2478 "namespace in { int j; } // namespace in\n" 2479 "int k; }} // namespace out::mid", 2480 Style)); 2481 2482 Style.NamespaceIndentation = FormatStyle::NI_Inner; 2483 EXPECT_EQ("namespace out { namespace in {\n" 2484 " int i;\n" 2485 "}} // namespace out::in", 2486 format("namespace out {\n" 2487 "namespace in {\n" 2488 "int i;\n" 2489 "} // namespace in\n" 2490 "} // namespace out", 2491 Style)); 2492 EXPECT_EQ("namespace out { namespace mid { namespace in {\n" 2493 " int i;\n" 2494 "}}} // namespace out::mid::in", 2495 format("namespace out {\n" 2496 "namespace mid {\n" 2497 "namespace in {\n" 2498 "int i;\n" 2499 "} // namespace in\n" 2500 "} // namespace mid\n" 2501 "} // namespace out", 2502 Style)); 2503 } 2504 2505 TEST_F(FormatTest, FormatsExternC) { 2506 verifyFormat("extern \"C\" {\nint a;"); 2507 verifyFormat("extern \"C\" {}"); 2508 verifyFormat("extern \"C\" {\n" 2509 "int foo();\n" 2510 "}"); 2511 verifyFormat("extern \"C\" int foo() {}"); 2512 verifyFormat("extern \"C\" int foo();"); 2513 verifyFormat("extern \"C\" int foo() {\n" 2514 " int i = 42;\n" 2515 " return i;\n" 2516 "}"); 2517 2518 FormatStyle Style = getLLVMStyle(); 2519 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 2520 Style.BraceWrapping.AfterFunction = true; 2521 verifyFormat("extern \"C\" int foo() {}", Style); 2522 verifyFormat("extern \"C\" int foo();", Style); 2523 verifyFormat("extern \"C\" int foo()\n" 2524 "{\n" 2525 " int i = 42;\n" 2526 " return i;\n" 2527 "}", 2528 Style); 2529 2530 Style.BraceWrapping.AfterExternBlock = true; 2531 Style.BraceWrapping.SplitEmptyRecord = false; 2532 verifyFormat("extern \"C\"\n" 2533 "{}", 2534 Style); 2535 verifyFormat("extern \"C\"\n" 2536 "{\n" 2537 " int foo();\n" 2538 "}", 2539 Style); 2540 } 2541 2542 TEST_F(FormatTest, FormatsInlineASM) { 2543 verifyFormat("asm(\"xyz\" : \"=a\"(a), \"=d\"(b) : \"a\"(data));"); 2544 verifyFormat("asm(\"nop\" ::: \"memory\");"); 2545 verifyFormat( 2546 "asm(\"movq\\t%%rbx, %%rsi\\n\\t\"\n" 2547 " \"cpuid\\n\\t\"\n" 2548 " \"xchgq\\t%%rbx, %%rsi\\n\\t\"\n" 2549 " : \"=a\"(*rEAX), \"=S\"(*rEBX), \"=c\"(*rECX), \"=d\"(*rEDX)\n" 2550 " : \"a\"(value));"); 2551 EXPECT_EQ( 2552 "void NS_InvokeByIndex(void *that, unsigned int methodIndex) {\n" 2553 " __asm {\n" 2554 " mov edx,[that] // vtable in edx\n" 2555 " mov eax,methodIndex\n" 2556 " call [edx][eax*4] // stdcall\n" 2557 " }\n" 2558 "}", 2559 format("void NS_InvokeByIndex(void *that, unsigned int methodIndex) {\n" 2560 " __asm {\n" 2561 " mov edx,[that] // vtable in edx\n" 2562 " mov eax,methodIndex\n" 2563 " call [edx][eax*4] // stdcall\n" 2564 " }\n" 2565 "}")); 2566 EXPECT_EQ("_asm {\n" 2567 " xor eax, eax;\n" 2568 " cpuid;\n" 2569 "}", 2570 format("_asm {\n" 2571 " xor eax, eax;\n" 2572 " cpuid;\n" 2573 "}")); 2574 verifyFormat("void function() {\n" 2575 " // comment\n" 2576 " asm(\"\");\n" 2577 "}"); 2578 EXPECT_EQ("__asm {\n" 2579 "}\n" 2580 "int i;", 2581 format("__asm {\n" 2582 "}\n" 2583 "int i;")); 2584 } 2585 2586 TEST_F(FormatTest, FormatTryCatch) { 2587 verifyFormat("try {\n" 2588 " throw a * b;\n" 2589 "} catch (int a) {\n" 2590 " // Do nothing.\n" 2591 "} catch (...) {\n" 2592 " exit(42);\n" 2593 "}"); 2594 2595 // Function-level try statements. 2596 verifyFormat("int f() try { return 4; } catch (...) {\n" 2597 " return 5;\n" 2598 "}"); 2599 verifyFormat("class A {\n" 2600 " int a;\n" 2601 " A() try : a(0) {\n" 2602 " } catch (...) {\n" 2603 " throw;\n" 2604 " }\n" 2605 "};\n"); 2606 2607 // Incomplete try-catch blocks. 2608 verifyIncompleteFormat("try {} catch ("); 2609 } 2610 2611 TEST_F(FormatTest, FormatSEHTryCatch) { 2612 verifyFormat("__try {\n" 2613 " int a = b * c;\n" 2614 "} __except (EXCEPTION_EXECUTE_HANDLER) {\n" 2615 " // Do nothing.\n" 2616 "}"); 2617 2618 verifyFormat("__try {\n" 2619 " int a = b * c;\n" 2620 "} __finally {\n" 2621 " // Do nothing.\n" 2622 "}"); 2623 2624 verifyFormat("DEBUG({\n" 2625 " __try {\n" 2626 " } __finally {\n" 2627 " }\n" 2628 "});\n"); 2629 } 2630 2631 TEST_F(FormatTest, IncompleteTryCatchBlocks) { 2632 verifyFormat("try {\n" 2633 " f();\n" 2634 "} catch {\n" 2635 " g();\n" 2636 "}"); 2637 verifyFormat("try {\n" 2638 " f();\n" 2639 "} catch (A a) MACRO(x) {\n" 2640 " g();\n" 2641 "} catch (B b) MACRO(x) {\n" 2642 " g();\n" 2643 "}"); 2644 } 2645 2646 TEST_F(FormatTest, FormatTryCatchBraceStyles) { 2647 FormatStyle Style = getLLVMStyle(); 2648 for (auto BraceStyle : {FormatStyle::BS_Attach, FormatStyle::BS_Mozilla, 2649 FormatStyle::BS_WebKit}) { 2650 Style.BreakBeforeBraces = BraceStyle; 2651 verifyFormat("try {\n" 2652 " // something\n" 2653 "} catch (...) {\n" 2654 " // something\n" 2655 "}", 2656 Style); 2657 } 2658 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 2659 verifyFormat("try {\n" 2660 " // something\n" 2661 "}\n" 2662 "catch (...) {\n" 2663 " // something\n" 2664 "}", 2665 Style); 2666 verifyFormat("__try {\n" 2667 " // something\n" 2668 "}\n" 2669 "__finally {\n" 2670 " // something\n" 2671 "}", 2672 Style); 2673 verifyFormat("@try {\n" 2674 " // something\n" 2675 "}\n" 2676 "@finally {\n" 2677 " // something\n" 2678 "}", 2679 Style); 2680 Style.BreakBeforeBraces = FormatStyle::BS_Allman; 2681 verifyFormat("try\n" 2682 "{\n" 2683 " // something\n" 2684 "}\n" 2685 "catch (...)\n" 2686 "{\n" 2687 " // something\n" 2688 "}", 2689 Style); 2690 Style.BreakBeforeBraces = FormatStyle::BS_Whitesmiths; 2691 verifyFormat("try\n" 2692 " {\n" 2693 " // something white\n" 2694 " }\n" 2695 "catch (...)\n" 2696 " {\n" 2697 " // something white\n" 2698 " }", 2699 Style); 2700 Style.BreakBeforeBraces = FormatStyle::BS_GNU; 2701 verifyFormat("try\n" 2702 " {\n" 2703 " // something\n" 2704 " }\n" 2705 "catch (...)\n" 2706 " {\n" 2707 " // something\n" 2708 " }", 2709 Style); 2710 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 2711 Style.BraceWrapping.BeforeCatch = true; 2712 verifyFormat("try {\n" 2713 " // something\n" 2714 "}\n" 2715 "catch (...) {\n" 2716 " // something\n" 2717 "}", 2718 Style); 2719 } 2720 2721 TEST_F(FormatTest, StaticInitializers) { 2722 verifyFormat("static SomeClass SC = {1, 'a'};"); 2723 2724 verifyFormat("static SomeClass WithALoooooooooooooooooooongName = {\n" 2725 " 100000000, " 2726 "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"};"); 2727 2728 // Here, everything other than the "}" would fit on a line. 2729 verifyFormat("static int LooooooooooooooooooooooooongVariable[1] = {\n" 2730 " 10000000000000000000000000};"); 2731 EXPECT_EQ("S s = {a,\n" 2732 "\n" 2733 " b};", 2734 format("S s = {\n" 2735 " a,\n" 2736 "\n" 2737 " b\n" 2738 "};")); 2739 2740 // FIXME: This would fit into the column limit if we'd fit "{ {" on the first 2741 // line. However, the formatting looks a bit off and this probably doesn't 2742 // happen often in practice. 2743 verifyFormat("static int Variable[1] = {\n" 2744 " {1000000000000000000000000000000000000}};", 2745 getLLVMStyleWithColumns(40)); 2746 } 2747 2748 TEST_F(FormatTest, DesignatedInitializers) { 2749 verifyFormat("const struct A a = {.a = 1, .b = 2};"); 2750 verifyFormat("const struct A a = {.aaaaaaaaaa = 1,\n" 2751 " .bbbbbbbbbb = 2,\n" 2752 " .cccccccccc = 3,\n" 2753 " .dddddddddd = 4,\n" 2754 " .eeeeeeeeee = 5};"); 2755 verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n" 2756 " .aaaaaaaaaaaaaaaaaaaaaaaaaaa = 1,\n" 2757 " .bbbbbbbbbbbbbbbbbbbbbbbbbbb = 2,\n" 2758 " .ccccccccccccccccccccccccccc = 3,\n" 2759 " .ddddddddddddddddddddddddddd = 4,\n" 2760 " .eeeeeeeeeeeeeeeeeeeeeeeeeee = 5};"); 2761 2762 verifyGoogleFormat("const struct A a = {.a = 1, .b = 2};"); 2763 2764 verifyFormat("const struct A a = {[0] = 1, [1] = 2};"); 2765 verifyFormat("const struct A a = {[1] = aaaaaaaaaa,\n" 2766 " [2] = bbbbbbbbbb,\n" 2767 " [3] = cccccccccc,\n" 2768 " [4] = dddddddddd,\n" 2769 " [5] = eeeeeeeeee};"); 2770 verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n" 2771 " [1] = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 2772 " [2] = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" 2773 " [3] = cccccccccccccccccccccccccccccccccccccc,\n" 2774 " [4] = dddddddddddddddddddddddddddddddddddddd,\n" 2775 " [5] = eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee};"); 2776 } 2777 2778 TEST_F(FormatTest, NestedStaticInitializers) { 2779 verifyFormat("static A x = {{{}}};\n"); 2780 verifyFormat("static A x = {{{init1, init2, init3, init4},\n" 2781 " {init1, init2, init3, init4}}};", 2782 getLLVMStyleWithColumns(50)); 2783 2784 verifyFormat("somes Status::global_reps[3] = {\n" 2785 " {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n" 2786 " {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n" 2787 " {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};", 2788 getLLVMStyleWithColumns(60)); 2789 verifyGoogleFormat("SomeType Status::global_reps[3] = {\n" 2790 " {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n" 2791 " {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n" 2792 " {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};"); 2793 verifyFormat("CGRect cg_rect = {{rect.fLeft, rect.fTop},\n" 2794 " {rect.fRight - rect.fLeft, rect.fBottom - " 2795 "rect.fTop}};"); 2796 2797 verifyFormat( 2798 "SomeArrayOfSomeType a = {\n" 2799 " {{1, 2, 3},\n" 2800 " {1, 2, 3},\n" 2801 " {111111111111111111111111111111, 222222222222222222222222222222,\n" 2802 " 333333333333333333333333333333},\n" 2803 " {1, 2, 3},\n" 2804 " {1, 2, 3}}};"); 2805 verifyFormat( 2806 "SomeArrayOfSomeType a = {\n" 2807 " {{1, 2, 3}},\n" 2808 " {{1, 2, 3}},\n" 2809 " {{111111111111111111111111111111, 222222222222222222222222222222,\n" 2810 " 333333333333333333333333333333}},\n" 2811 " {{1, 2, 3}},\n" 2812 " {{1, 2, 3}}};"); 2813 2814 verifyFormat("struct {\n" 2815 " unsigned bit;\n" 2816 " const char *const name;\n" 2817 "} kBitsToOs[] = {{kOsMac, \"Mac\"},\n" 2818 " {kOsWin, \"Windows\"},\n" 2819 " {kOsLinux, \"Linux\"},\n" 2820 " {kOsCrOS, \"Chrome OS\"}};"); 2821 verifyFormat("struct {\n" 2822 " unsigned bit;\n" 2823 " const char *const name;\n" 2824 "} kBitsToOs[] = {\n" 2825 " {kOsMac, \"Mac\"},\n" 2826 " {kOsWin, \"Windows\"},\n" 2827 " {kOsLinux, \"Linux\"},\n" 2828 " {kOsCrOS, \"Chrome OS\"},\n" 2829 "};"); 2830 } 2831 2832 TEST_F(FormatTest, FormatsSmallMacroDefinitionsInSingleLine) { 2833 verifyFormat("#define ALooooooooooooooooooooooooooooooooooooooongMacro(" 2834 " \\\n" 2835 " aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)"); 2836 } 2837 2838 TEST_F(FormatTest, DoesNotBreakPureVirtualFunctionDefinition) { 2839 verifyFormat("virtual void write(ELFWriter *writerrr,\n" 2840 " OwningPtr<FileOutputBuffer> &buffer) = 0;"); 2841 2842 // Do break defaulted and deleted functions. 2843 verifyFormat("virtual void ~Deeeeeeeestructor() =\n" 2844 " default;", 2845 getLLVMStyleWithColumns(40)); 2846 verifyFormat("virtual void ~Deeeeeeeestructor() =\n" 2847 " delete;", 2848 getLLVMStyleWithColumns(40)); 2849 } 2850 2851 TEST_F(FormatTest, BreaksStringLiteralsOnlyInDefine) { 2852 verifyFormat("# 1111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\" 2 3", 2853 getLLVMStyleWithColumns(40)); 2854 verifyFormat("#line 11111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"", 2855 getLLVMStyleWithColumns(40)); 2856 EXPECT_EQ("#define Q \\\n" 2857 " \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/\" \\\n" 2858 " \"aaaaaaaa.cpp\"", 2859 format("#define Q \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"", 2860 getLLVMStyleWithColumns(40))); 2861 } 2862 2863 TEST_F(FormatTest, UnderstandsLinePPDirective) { 2864 EXPECT_EQ("# 123 \"A string literal\"", 2865 format(" # 123 \"A string literal\"")); 2866 } 2867 2868 TEST_F(FormatTest, LayoutUnknownPPDirective) { 2869 EXPECT_EQ("#;", format("#;")); 2870 verifyFormat("#\n;\n;\n;"); 2871 } 2872 2873 TEST_F(FormatTest, UnescapedEndOfLineEndsPPDirective) { 2874 EXPECT_EQ("#line 42 \"test\"\n", 2875 format("# \\\n line \\\n 42 \\\n \"test\"\n")); 2876 EXPECT_EQ("#define A B\n", format("# \\\n define \\\n A \\\n B\n", 2877 getLLVMStyleWithColumns(12))); 2878 } 2879 2880 TEST_F(FormatTest, EndOfFileEndsPPDirective) { 2881 EXPECT_EQ("#line 42 \"test\"", 2882 format("# \\\n line \\\n 42 \\\n \"test\"")); 2883 EXPECT_EQ("#define A B", format("# \\\n define \\\n A \\\n B")); 2884 } 2885 2886 TEST_F(FormatTest, DoesntRemoveUnknownTokens) { 2887 verifyFormat("#define A \\x20"); 2888 verifyFormat("#define A \\ x20"); 2889 EXPECT_EQ("#define A \\ x20", format("#define A \\ x20")); 2890 verifyFormat("#define A ''"); 2891 verifyFormat("#define A ''qqq"); 2892 verifyFormat("#define A `qqq"); 2893 verifyFormat("f(\"aaaa, bbbb, \"\\\"ccccc\\\"\");"); 2894 EXPECT_EQ("const char *c = STRINGIFY(\n" 2895 "\\na : b);", 2896 format("const char * c = STRINGIFY(\n" 2897 "\\na : b);")); 2898 2899 verifyFormat("a\r\\"); 2900 verifyFormat("a\v\\"); 2901 verifyFormat("a\f\\"); 2902 } 2903 2904 TEST_F(FormatTest, IndentsPPDirectiveInReducedSpace) { 2905 verifyFormat("#define A(BB)", getLLVMStyleWithColumns(13)); 2906 verifyFormat("#define A( \\\n BB)", getLLVMStyleWithColumns(12)); 2907 verifyFormat("#define A( \\\n A, B)", getLLVMStyleWithColumns(12)); 2908 // FIXME: We never break before the macro name. 2909 verifyFormat("#define AA( \\\n B)", getLLVMStyleWithColumns(12)); 2910 2911 verifyFormat("#define A A\n#define A A"); 2912 verifyFormat("#define A(X) A\n#define A A"); 2913 2914 verifyFormat("#define Something Other", getLLVMStyleWithColumns(23)); 2915 verifyFormat("#define Something \\\n Other", getLLVMStyleWithColumns(22)); 2916 } 2917 2918 TEST_F(FormatTest, HandlePreprocessorDirectiveContext) { 2919 EXPECT_EQ("// somecomment\n" 2920 "#include \"a.h\"\n" 2921 "#define A( \\\n" 2922 " A, B)\n" 2923 "#include \"b.h\"\n" 2924 "// somecomment\n", 2925 format(" // somecomment\n" 2926 " #include \"a.h\"\n" 2927 "#define A(A,\\\n" 2928 " B)\n" 2929 " #include \"b.h\"\n" 2930 " // somecomment\n", 2931 getLLVMStyleWithColumns(13))); 2932 } 2933 2934 TEST_F(FormatTest, LayoutSingleHash) { EXPECT_EQ("#\na;", format("#\na;")); } 2935 2936 TEST_F(FormatTest, LayoutCodeInMacroDefinitions) { 2937 EXPECT_EQ("#define A \\\n" 2938 " c; \\\n" 2939 " e;\n" 2940 "f;", 2941 format("#define A c; e;\n" 2942 "f;", 2943 getLLVMStyleWithColumns(14))); 2944 } 2945 2946 TEST_F(FormatTest, LayoutRemainingTokens) { EXPECT_EQ("{}", format("{}")); } 2947 2948 TEST_F(FormatTest, MacroDefinitionInsideStatement) { 2949 EXPECT_EQ("int x,\n" 2950 "#define A\n" 2951 " y;", 2952 format("int x,\n#define A\ny;")); 2953 } 2954 2955 TEST_F(FormatTest, HashInMacroDefinition) { 2956 EXPECT_EQ("#define A(c) L#c", format("#define A(c) L#c", getLLVMStyle())); 2957 verifyFormat("#define A \\\n b #c;", getLLVMStyleWithColumns(11)); 2958 verifyFormat("#define A \\\n" 2959 " { \\\n" 2960 " f(#c); \\\n" 2961 " }", 2962 getLLVMStyleWithColumns(11)); 2963 2964 verifyFormat("#define A(X) \\\n" 2965 " void function##X()", 2966 getLLVMStyleWithColumns(22)); 2967 2968 verifyFormat("#define A(a, b, c) \\\n" 2969 " void a##b##c()", 2970 getLLVMStyleWithColumns(22)); 2971 2972 verifyFormat("#define A void # ## #", getLLVMStyleWithColumns(22)); 2973 } 2974 2975 TEST_F(FormatTest, RespectWhitespaceInMacroDefinitions) { 2976 EXPECT_EQ("#define A (x)", format("#define A (x)")); 2977 EXPECT_EQ("#define A(x)", format("#define A(x)")); 2978 2979 FormatStyle Style = getLLVMStyle(); 2980 Style.SpaceBeforeParens = FormatStyle::SBPO_Never; 2981 verifyFormat("#define true ((foo)1)", Style); 2982 Style.SpaceBeforeParens = FormatStyle::SBPO_Always; 2983 verifyFormat("#define false((foo)0)", Style); 2984 } 2985 2986 TEST_F(FormatTest, EmptyLinesInMacroDefinitions) { 2987 EXPECT_EQ("#define A b;", format("#define A \\\n" 2988 " \\\n" 2989 " b;", 2990 getLLVMStyleWithColumns(25))); 2991 EXPECT_EQ("#define A \\\n" 2992 " \\\n" 2993 " a; \\\n" 2994 " b;", 2995 format("#define A \\\n" 2996 " \\\n" 2997 " a; \\\n" 2998 " b;", 2999 getLLVMStyleWithColumns(11))); 3000 EXPECT_EQ("#define A \\\n" 3001 " a; \\\n" 3002 " \\\n" 3003 " b;", 3004 format("#define A \\\n" 3005 " a; \\\n" 3006 " \\\n" 3007 " b;", 3008 getLLVMStyleWithColumns(11))); 3009 } 3010 3011 TEST_F(FormatTest, MacroDefinitionsWithIncompleteCode) { 3012 verifyIncompleteFormat("#define A :"); 3013 verifyFormat("#define SOMECASES \\\n" 3014 " case 1: \\\n" 3015 " case 2\n", 3016 getLLVMStyleWithColumns(20)); 3017 verifyFormat("#define MACRO(a) \\\n" 3018 " if (a) \\\n" 3019 " f(); \\\n" 3020 " else \\\n" 3021 " g()", 3022 getLLVMStyleWithColumns(18)); 3023 verifyFormat("#define A template <typename T>"); 3024 verifyIncompleteFormat("#define STR(x) #x\n" 3025 "f(STR(this_is_a_string_literal{));"); 3026 verifyFormat("#pragma omp threadprivate( \\\n" 3027 " y)), // expected-warning", 3028 getLLVMStyleWithColumns(28)); 3029 verifyFormat("#d, = };"); 3030 verifyFormat("#if \"a"); 3031 verifyIncompleteFormat("({\n" 3032 "#define b \\\n" 3033 " } \\\n" 3034 " a\n" 3035 "a", 3036 getLLVMStyleWithColumns(15)); 3037 verifyFormat("#define A \\\n" 3038 " { \\\n" 3039 " {\n" 3040 "#define B \\\n" 3041 " } \\\n" 3042 " }", 3043 getLLVMStyleWithColumns(15)); 3044 verifyNoCrash("#if a\na(\n#else\n#endif\n{a"); 3045 verifyNoCrash("a={0,1\n#if a\n#else\n;\n#endif\n}"); 3046 verifyNoCrash("#if a\na(\n#else\n#endif\n) a {a,b,c,d,f,g};"); 3047 verifyNoCrash("#ifdef A\n a(\n #else\n #endif\n) = []() { \n)}"); 3048 } 3049 3050 TEST_F(FormatTest, MacrosWithoutTrailingSemicolon) { 3051 verifyFormat("SOME_TYPE_NAME abc;"); // Gated on the newline. 3052 EXPECT_EQ("class A : public QObject {\n" 3053 " Q_OBJECT\n" 3054 "\n" 3055 " A() {}\n" 3056 "};", 3057 format("class A : public QObject {\n" 3058 " Q_OBJECT\n" 3059 "\n" 3060 " A() {\n}\n" 3061 "} ;")); 3062 EXPECT_EQ("MACRO\n" 3063 "/*static*/ int i;", 3064 format("MACRO\n" 3065 " /*static*/ int i;")); 3066 EXPECT_EQ("SOME_MACRO\n" 3067 "namespace {\n" 3068 "void f();\n" 3069 "} // namespace", 3070 format("SOME_MACRO\n" 3071 " namespace {\n" 3072 "void f( );\n" 3073 "} // namespace")); 3074 // Only if the identifier contains at least 5 characters. 3075 EXPECT_EQ("HTTP f();", format("HTTP\nf();")); 3076 EXPECT_EQ("MACRO\nf();", format("MACRO\nf();")); 3077 // Only if everything is upper case. 3078 EXPECT_EQ("class A : public QObject {\n" 3079 " Q_Object A() {}\n" 3080 "};", 3081 format("class A : public QObject {\n" 3082 " Q_Object\n" 3083 " A() {\n}\n" 3084 "} ;")); 3085 3086 // Only if the next line can actually start an unwrapped line. 3087 EXPECT_EQ("SOME_WEIRD_LOG_MACRO << SomeThing;", 3088 format("SOME_WEIRD_LOG_MACRO\n" 3089 "<< SomeThing;")); 3090 3091 verifyFormat("VISIT_GL_CALL(GenBuffers, void, (GLsizei n, GLuint* buffers), " 3092 "(n, buffers))\n", 3093 getChromiumStyle(FormatStyle::LK_Cpp)); 3094 3095 // See PR41483 3096 EXPECT_EQ("/**/ FOO(a)\n" 3097 "FOO(b)", 3098 format("/**/ FOO(a)\n" 3099 "FOO(b)")); 3100 } 3101 3102 TEST_F(FormatTest, MacroCallsWithoutTrailingSemicolon) { 3103 EXPECT_EQ("INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n" 3104 "INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n" 3105 "INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n" 3106 "class X {};\n" 3107 "INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n" 3108 "int *createScopDetectionPass() { return 0; }", 3109 format(" INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n" 3110 " INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n" 3111 " INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n" 3112 " class X {};\n" 3113 " INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n" 3114 " int *createScopDetectionPass() { return 0; }")); 3115 // FIXME: We could probably treat IPC_BEGIN_MESSAGE_MAP/IPC_END_MESSAGE_MAP as 3116 // braces, so that inner block is indented one level more. 3117 EXPECT_EQ("int q() {\n" 3118 " IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n" 3119 " IPC_MESSAGE_HANDLER(xxx, qqq)\n" 3120 " IPC_END_MESSAGE_MAP()\n" 3121 "}", 3122 format("int q() {\n" 3123 " IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n" 3124 " IPC_MESSAGE_HANDLER(xxx, qqq)\n" 3125 " IPC_END_MESSAGE_MAP()\n" 3126 "}")); 3127 3128 // Same inside macros. 3129 EXPECT_EQ("#define LIST(L) \\\n" 3130 " L(A) \\\n" 3131 " L(B) \\\n" 3132 " L(C)", 3133 format("#define LIST(L) \\\n" 3134 " L(A) \\\n" 3135 " L(B) \\\n" 3136 " L(C)", 3137 getGoogleStyle())); 3138 3139 // These must not be recognized as macros. 3140 EXPECT_EQ("int q() {\n" 3141 " f(x);\n" 3142 " f(x) {}\n" 3143 " f(x)->g();\n" 3144 " f(x)->*g();\n" 3145 " f(x).g();\n" 3146 " f(x) = x;\n" 3147 " f(x) += x;\n" 3148 " f(x) -= x;\n" 3149 " f(x) *= x;\n" 3150 " f(x) /= x;\n" 3151 " f(x) %= x;\n" 3152 " f(x) &= x;\n" 3153 " f(x) |= x;\n" 3154 " f(x) ^= x;\n" 3155 " f(x) >>= x;\n" 3156 " f(x) <<= x;\n" 3157 " f(x)[y].z();\n" 3158 " LOG(INFO) << x;\n" 3159 " ifstream(x) >> x;\n" 3160 "}\n", 3161 format("int q() {\n" 3162 " f(x)\n;\n" 3163 " f(x)\n {}\n" 3164 " f(x)\n->g();\n" 3165 " f(x)\n->*g();\n" 3166 " f(x)\n.g();\n" 3167 " f(x)\n = x;\n" 3168 " f(x)\n += x;\n" 3169 " f(x)\n -= x;\n" 3170 " f(x)\n *= x;\n" 3171 " f(x)\n /= x;\n" 3172 " f(x)\n %= x;\n" 3173 " f(x)\n &= x;\n" 3174 " f(x)\n |= x;\n" 3175 " f(x)\n ^= x;\n" 3176 " f(x)\n >>= x;\n" 3177 " f(x)\n <<= x;\n" 3178 " f(x)\n[y].z();\n" 3179 " LOG(INFO)\n << x;\n" 3180 " ifstream(x)\n >> x;\n" 3181 "}\n")); 3182 EXPECT_EQ("int q() {\n" 3183 " F(x)\n" 3184 " if (1) {\n" 3185 " }\n" 3186 " F(x)\n" 3187 " while (1) {\n" 3188 " }\n" 3189 " F(x)\n" 3190 " G(x);\n" 3191 " F(x)\n" 3192 " try {\n" 3193 " Q();\n" 3194 " } catch (...) {\n" 3195 " }\n" 3196 "}\n", 3197 format("int q() {\n" 3198 "F(x)\n" 3199 "if (1) {}\n" 3200 "F(x)\n" 3201 "while (1) {}\n" 3202 "F(x)\n" 3203 "G(x);\n" 3204 "F(x)\n" 3205 "try { Q(); } catch (...) {}\n" 3206 "}\n")); 3207 EXPECT_EQ("class A {\n" 3208 " A() : t(0) {}\n" 3209 " A(int i) noexcept() : {}\n" 3210 " A(X x)\n" // FIXME: function-level try blocks are broken. 3211 " try : t(0) {\n" 3212 " } catch (...) {\n" 3213 " }\n" 3214 "};", 3215 format("class A {\n" 3216 " A()\n : t(0) {}\n" 3217 " A(int i)\n noexcept() : {}\n" 3218 " A(X x)\n" 3219 " try : t(0) {} catch (...) {}\n" 3220 "};")); 3221 FormatStyle Style = getLLVMStyle(); 3222 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 3223 Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always; 3224 Style.BraceWrapping.AfterFunction = true; 3225 EXPECT_EQ("void f()\n" 3226 "try\n" 3227 "{\n" 3228 "}", 3229 format("void f() try {\n" 3230 "}", 3231 Style)); 3232 EXPECT_EQ("class SomeClass {\n" 3233 "public:\n" 3234 " SomeClass() EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 3235 "};", 3236 format("class SomeClass {\n" 3237 "public:\n" 3238 " SomeClass()\n" 3239 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 3240 "};")); 3241 EXPECT_EQ("class SomeClass {\n" 3242 "public:\n" 3243 " SomeClass()\n" 3244 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 3245 "};", 3246 format("class SomeClass {\n" 3247 "public:\n" 3248 " SomeClass()\n" 3249 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 3250 "};", 3251 getLLVMStyleWithColumns(40))); 3252 3253 verifyFormat("MACRO(>)"); 3254 3255 // Some macros contain an implicit semicolon. 3256 Style = getLLVMStyle(); 3257 Style.StatementMacros.push_back("FOO"); 3258 verifyFormat("FOO(a) int b = 0;"); 3259 verifyFormat("FOO(a)\n" 3260 "int b = 0;", 3261 Style); 3262 verifyFormat("FOO(a);\n" 3263 "int b = 0;", 3264 Style); 3265 verifyFormat("FOO(argc, argv, \"4.0.2\")\n" 3266 "int b = 0;", 3267 Style); 3268 verifyFormat("FOO()\n" 3269 "int b = 0;", 3270 Style); 3271 verifyFormat("FOO\n" 3272 "int b = 0;", 3273 Style); 3274 verifyFormat("void f() {\n" 3275 " FOO(a)\n" 3276 " return a;\n" 3277 "}", 3278 Style); 3279 verifyFormat("FOO(a)\n" 3280 "FOO(b)", 3281 Style); 3282 verifyFormat("int a = 0;\n" 3283 "FOO(b)\n" 3284 "int c = 0;", 3285 Style); 3286 verifyFormat("int a = 0;\n" 3287 "int x = FOO(a)\n" 3288 "int b = 0;", 3289 Style); 3290 verifyFormat("void foo(int a) { FOO(a) }\n" 3291 "uint32_t bar() {}", 3292 Style); 3293 } 3294 3295 TEST_F(FormatTest, LayoutMacroDefinitionsStatementsSpanningBlocks) { 3296 verifyFormat("#define A \\\n" 3297 " f({ \\\n" 3298 " g(); \\\n" 3299 " });", 3300 getLLVMStyleWithColumns(11)); 3301 } 3302 3303 TEST_F(FormatTest, IndentPreprocessorDirectives) { 3304 FormatStyle Style = getLLVMStyle(); 3305 Style.IndentPPDirectives = FormatStyle::PPDIS_None; 3306 Style.ColumnLimit = 40; 3307 verifyFormat("#ifdef _WIN32\n" 3308 "#define A 0\n" 3309 "#ifdef VAR2\n" 3310 "#define B 1\n" 3311 "#include <someheader.h>\n" 3312 "#define MACRO \\\n" 3313 " some_very_long_func_aaaaaaaaaa();\n" 3314 "#endif\n" 3315 "#else\n" 3316 "#define A 1\n" 3317 "#endif", 3318 Style); 3319 Style.IndentPPDirectives = FormatStyle::PPDIS_AfterHash; 3320 verifyFormat("#ifdef _WIN32\n" 3321 "# define A 0\n" 3322 "# ifdef VAR2\n" 3323 "# define B 1\n" 3324 "# include <someheader.h>\n" 3325 "# define MACRO \\\n" 3326 " some_very_long_func_aaaaaaaaaa();\n" 3327 "# endif\n" 3328 "#else\n" 3329 "# define A 1\n" 3330 "#endif", 3331 Style); 3332 verifyFormat("#if A\n" 3333 "# define MACRO \\\n" 3334 " void a(int x) { \\\n" 3335 " b(); \\\n" 3336 " c(); \\\n" 3337 " d(); \\\n" 3338 " e(); \\\n" 3339 " f(); \\\n" 3340 " }\n" 3341 "#endif", 3342 Style); 3343 // Comments before include guard. 3344 verifyFormat("// file comment\n" 3345 "// file comment\n" 3346 "#ifndef HEADER_H\n" 3347 "#define HEADER_H\n" 3348 "code();\n" 3349 "#endif", 3350 Style); 3351 // Test with include guards. 3352 verifyFormat("#ifndef HEADER_H\n" 3353 "#define HEADER_H\n" 3354 "code();\n" 3355 "#endif", 3356 Style); 3357 // Include guards must have a #define with the same variable immediately 3358 // after #ifndef. 3359 verifyFormat("#ifndef NOT_GUARD\n" 3360 "# define FOO\n" 3361 "code();\n" 3362 "#endif", 3363 Style); 3364 3365 // Include guards must cover the entire file. 3366 verifyFormat("code();\n" 3367 "code();\n" 3368 "#ifndef NOT_GUARD\n" 3369 "# define NOT_GUARD\n" 3370 "code();\n" 3371 "#endif", 3372 Style); 3373 verifyFormat("#ifndef NOT_GUARD\n" 3374 "# define NOT_GUARD\n" 3375 "code();\n" 3376 "#endif\n" 3377 "code();", 3378 Style); 3379 // Test with trailing blank lines. 3380 verifyFormat("#ifndef HEADER_H\n" 3381 "#define HEADER_H\n" 3382 "code();\n" 3383 "#endif\n", 3384 Style); 3385 // Include guards don't have #else. 3386 verifyFormat("#ifndef NOT_GUARD\n" 3387 "# define NOT_GUARD\n" 3388 "code();\n" 3389 "#else\n" 3390 "#endif", 3391 Style); 3392 verifyFormat("#ifndef NOT_GUARD\n" 3393 "# define NOT_GUARD\n" 3394 "code();\n" 3395 "#elif FOO\n" 3396 "#endif", 3397 Style); 3398 // Non-identifier #define after potential include guard. 3399 verifyFormat("#ifndef FOO\n" 3400 "# define 1\n" 3401 "#endif\n", 3402 Style); 3403 // #if closes past last non-preprocessor line. 3404 verifyFormat("#ifndef FOO\n" 3405 "#define FOO\n" 3406 "#if 1\n" 3407 "int i;\n" 3408 "# define A 0\n" 3409 "#endif\n" 3410 "#endif\n", 3411 Style); 3412 // Don't crash if there is an #elif directive without a condition. 3413 verifyFormat("#if 1\n" 3414 "int x;\n" 3415 "#elif\n" 3416 "int y;\n" 3417 "#else\n" 3418 "int z;\n" 3419 "#endif", 3420 Style); 3421 // FIXME: This doesn't handle the case where there's code between the 3422 // #ifndef and #define but all other conditions hold. This is because when 3423 // the #define line is parsed, UnwrappedLineParser::Lines doesn't hold the 3424 // previous code line yet, so we can't detect it. 3425 EXPECT_EQ("#ifndef NOT_GUARD\n" 3426 "code();\n" 3427 "#define NOT_GUARD\n" 3428 "code();\n" 3429 "#endif", 3430 format("#ifndef NOT_GUARD\n" 3431 "code();\n" 3432 "# define NOT_GUARD\n" 3433 "code();\n" 3434 "#endif", 3435 Style)); 3436 // FIXME: This doesn't handle cases where legitimate preprocessor lines may 3437 // be outside an include guard. Examples are #pragma once and 3438 // #pragma GCC diagnostic, or anything else that does not change the meaning 3439 // of the file if it's included multiple times. 3440 EXPECT_EQ("#ifdef WIN32\n" 3441 "# pragma once\n" 3442 "#endif\n" 3443 "#ifndef HEADER_H\n" 3444 "# define HEADER_H\n" 3445 "code();\n" 3446 "#endif", 3447 format("#ifdef WIN32\n" 3448 "# pragma once\n" 3449 "#endif\n" 3450 "#ifndef HEADER_H\n" 3451 "#define HEADER_H\n" 3452 "code();\n" 3453 "#endif", 3454 Style)); 3455 // FIXME: This does not detect when there is a single non-preprocessor line 3456 // in front of an include-guard-like structure where other conditions hold 3457 // because ScopedLineState hides the line. 3458 EXPECT_EQ("code();\n" 3459 "#ifndef HEADER_H\n" 3460 "#define HEADER_H\n" 3461 "code();\n" 3462 "#endif", 3463 format("code();\n" 3464 "#ifndef HEADER_H\n" 3465 "# define HEADER_H\n" 3466 "code();\n" 3467 "#endif", 3468 Style)); 3469 // Keep comments aligned with #, otherwise indent comments normally. These 3470 // tests cannot use verifyFormat because messUp manipulates leading 3471 // whitespace. 3472 { 3473 const char *Expected = "" 3474 "void f() {\n" 3475 "#if 1\n" 3476 "// Preprocessor aligned.\n" 3477 "# define A 0\n" 3478 " // Code. Separated by blank line.\n" 3479 "\n" 3480 "# define B 0\n" 3481 " // Code. Not aligned with #\n" 3482 "# define C 0\n" 3483 "#endif"; 3484 const char *ToFormat = "" 3485 "void f() {\n" 3486 "#if 1\n" 3487 "// Preprocessor aligned.\n" 3488 "# define A 0\n" 3489 "// Code. Separated by blank line.\n" 3490 "\n" 3491 "# define B 0\n" 3492 " // Code. Not aligned with #\n" 3493 "# define C 0\n" 3494 "#endif"; 3495 EXPECT_EQ(Expected, format(ToFormat, Style)); 3496 EXPECT_EQ(Expected, format(Expected, Style)); 3497 } 3498 // Keep block quotes aligned. 3499 { 3500 const char *Expected = "" 3501 "void f() {\n" 3502 "#if 1\n" 3503 "/* Preprocessor aligned. */\n" 3504 "# define A 0\n" 3505 " /* Code. Separated by blank line. */\n" 3506 "\n" 3507 "# define B 0\n" 3508 " /* Code. Not aligned with # */\n" 3509 "# define C 0\n" 3510 "#endif"; 3511 const char *ToFormat = "" 3512 "void f() {\n" 3513 "#if 1\n" 3514 "/* Preprocessor aligned. */\n" 3515 "# define A 0\n" 3516 "/* Code. Separated by blank line. */\n" 3517 "\n" 3518 "# define B 0\n" 3519 " /* Code. Not aligned with # */\n" 3520 "# define C 0\n" 3521 "#endif"; 3522 EXPECT_EQ(Expected, format(ToFormat, Style)); 3523 EXPECT_EQ(Expected, format(Expected, Style)); 3524 } 3525 // Keep comments aligned with un-indented directives. 3526 { 3527 const char *Expected = "" 3528 "void f() {\n" 3529 "// Preprocessor aligned.\n" 3530 "#define A 0\n" 3531 " // Code. Separated by blank line.\n" 3532 "\n" 3533 "#define B 0\n" 3534 " // Code. Not aligned with #\n" 3535 "#define C 0\n"; 3536 const char *ToFormat = "" 3537 "void f() {\n" 3538 "// Preprocessor aligned.\n" 3539 "#define A 0\n" 3540 "// Code. Separated by blank line.\n" 3541 "\n" 3542 "#define B 0\n" 3543 " // Code. Not aligned with #\n" 3544 "#define C 0\n"; 3545 EXPECT_EQ(Expected, format(ToFormat, Style)); 3546 EXPECT_EQ(Expected, format(Expected, Style)); 3547 } 3548 // Test AfterHash with tabs. 3549 { 3550 FormatStyle Tabbed = Style; 3551 Tabbed.UseTab = FormatStyle::UT_Always; 3552 Tabbed.IndentWidth = 8; 3553 Tabbed.TabWidth = 8; 3554 verifyFormat("#ifdef _WIN32\n" 3555 "#\tdefine A 0\n" 3556 "#\tifdef VAR2\n" 3557 "#\t\tdefine B 1\n" 3558 "#\t\tinclude <someheader.h>\n" 3559 "#\t\tdefine MACRO \\\n" 3560 "\t\t\tsome_very_long_func_aaaaaaaaaa();\n" 3561 "#\tendif\n" 3562 "#else\n" 3563 "#\tdefine A 1\n" 3564 "#endif", 3565 Tabbed); 3566 } 3567 3568 // Regression test: Multiline-macro inside include guards. 3569 verifyFormat("#ifndef HEADER_H\n" 3570 "#define HEADER_H\n" 3571 "#define A() \\\n" 3572 " int i; \\\n" 3573 " int j;\n" 3574 "#endif // HEADER_H", 3575 getLLVMStyleWithColumns(20)); 3576 3577 Style.IndentPPDirectives = FormatStyle::PPDIS_BeforeHash; 3578 // Basic before hash indent tests 3579 verifyFormat("#ifdef _WIN32\n" 3580 " #define A 0\n" 3581 " #ifdef VAR2\n" 3582 " #define B 1\n" 3583 " #include <someheader.h>\n" 3584 " #define MACRO \\\n" 3585 " some_very_long_func_aaaaaaaaaa();\n" 3586 " #endif\n" 3587 "#else\n" 3588 " #define A 1\n" 3589 "#endif", 3590 Style); 3591 verifyFormat("#if A\n" 3592 " #define MACRO \\\n" 3593 " void a(int x) { \\\n" 3594 " b(); \\\n" 3595 " c(); \\\n" 3596 " d(); \\\n" 3597 " e(); \\\n" 3598 " f(); \\\n" 3599 " }\n" 3600 "#endif", 3601 Style); 3602 // Keep comments aligned with indented directives. These 3603 // tests cannot use verifyFormat because messUp manipulates leading 3604 // whitespace. 3605 { 3606 const char *Expected = "void f() {\n" 3607 "// Aligned to preprocessor.\n" 3608 "#if 1\n" 3609 " // Aligned to code.\n" 3610 " int a;\n" 3611 " #if 1\n" 3612 " // Aligned to preprocessor.\n" 3613 " #define A 0\n" 3614 " // Aligned to code.\n" 3615 " int b;\n" 3616 " #endif\n" 3617 "#endif\n" 3618 "}"; 3619 const char *ToFormat = "void f() {\n" 3620 "// Aligned to preprocessor.\n" 3621 "#if 1\n" 3622 "// Aligned to code.\n" 3623 "int a;\n" 3624 "#if 1\n" 3625 "// Aligned to preprocessor.\n" 3626 "#define A 0\n" 3627 "// Aligned to code.\n" 3628 "int b;\n" 3629 "#endif\n" 3630 "#endif\n" 3631 "}"; 3632 EXPECT_EQ(Expected, format(ToFormat, Style)); 3633 EXPECT_EQ(Expected, format(Expected, Style)); 3634 } 3635 { 3636 const char *Expected = "void f() {\n" 3637 "/* Aligned to preprocessor. */\n" 3638 "#if 1\n" 3639 " /* Aligned to code. */\n" 3640 " int a;\n" 3641 " #if 1\n" 3642 " /* Aligned to preprocessor. */\n" 3643 " #define A 0\n" 3644 " /* Aligned to code. */\n" 3645 " int b;\n" 3646 " #endif\n" 3647 "#endif\n" 3648 "}"; 3649 const char *ToFormat = "void f() {\n" 3650 "/* Aligned to preprocessor. */\n" 3651 "#if 1\n" 3652 "/* Aligned to code. */\n" 3653 "int a;\n" 3654 "#if 1\n" 3655 "/* Aligned to preprocessor. */\n" 3656 "#define A 0\n" 3657 "/* Aligned to code. */\n" 3658 "int b;\n" 3659 "#endif\n" 3660 "#endif\n" 3661 "}"; 3662 EXPECT_EQ(Expected, format(ToFormat, Style)); 3663 EXPECT_EQ(Expected, format(Expected, Style)); 3664 } 3665 3666 // Test single comment before preprocessor 3667 verifyFormat("// Comment\n" 3668 "\n" 3669 "#if 1\n" 3670 "#endif", 3671 Style); 3672 } 3673 3674 TEST_F(FormatTest, FormatHashIfNotAtStartOfLine) { 3675 verifyFormat("{\n { a #c; }\n}"); 3676 } 3677 3678 TEST_F(FormatTest, FormatUnbalancedStructuralElements) { 3679 EXPECT_EQ("#define A \\\n { \\\n {\nint i;", 3680 format("#define A { {\nint i;", getLLVMStyleWithColumns(11))); 3681 EXPECT_EQ("#define A \\\n } \\\n }\nint i;", 3682 format("#define A } }\nint i;", getLLVMStyleWithColumns(11))); 3683 } 3684 3685 TEST_F(FormatTest, EscapedNewlines) { 3686 FormatStyle Narrow = getLLVMStyleWithColumns(11); 3687 EXPECT_EQ("#define A \\\n int i; \\\n int j;", 3688 format("#define A \\\nint i;\\\n int j;", Narrow)); 3689 EXPECT_EQ("#define A\n\nint i;", format("#define A \\\n\n int i;")); 3690 EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();")); 3691 EXPECT_EQ("/* \\ \\ \\\n */", format("\\\n/* \\ \\ \\\n */")); 3692 EXPECT_EQ("<a\n\\\\\n>", format("<a\n\\\\\n>")); 3693 3694 FormatStyle AlignLeft = getLLVMStyle(); 3695 AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left; 3696 EXPECT_EQ("#define MACRO(x) \\\n" 3697 "private: \\\n" 3698 " int x(int a);\n", 3699 format("#define MACRO(x) \\\n" 3700 "private: \\\n" 3701 " int x(int a);\n", 3702 AlignLeft)); 3703 3704 // CRLF line endings 3705 EXPECT_EQ("#define A \\\r\n int i; \\\r\n int j;", 3706 format("#define A \\\r\nint i;\\\r\n int j;", Narrow)); 3707 EXPECT_EQ("#define A\r\n\r\nint i;", format("#define A \\\r\n\r\n int i;")); 3708 EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();")); 3709 EXPECT_EQ("/* \\ \\ \\\r\n */", format("\\\r\n/* \\ \\ \\\r\n */")); 3710 EXPECT_EQ("<a\r\n\\\\\r\n>", format("<a\r\n\\\\\r\n>")); 3711 EXPECT_EQ("#define MACRO(x) \\\r\n" 3712 "private: \\\r\n" 3713 " int x(int a);\r\n", 3714 format("#define MACRO(x) \\\r\n" 3715 "private: \\\r\n" 3716 " int x(int a);\r\n", 3717 AlignLeft)); 3718 3719 FormatStyle DontAlign = getLLVMStyle(); 3720 DontAlign.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign; 3721 DontAlign.MaxEmptyLinesToKeep = 3; 3722 // FIXME: can't use verifyFormat here because the newline before 3723 // "public:" is not inserted the first time it's reformatted 3724 EXPECT_EQ("#define A \\\n" 3725 " class Foo { \\\n" 3726 " void bar(); \\\n" 3727 "\\\n" 3728 "\\\n" 3729 "\\\n" 3730 " public: \\\n" 3731 " void baz(); \\\n" 3732 " };", 3733 format("#define A \\\n" 3734 " class Foo { \\\n" 3735 " void bar(); \\\n" 3736 "\\\n" 3737 "\\\n" 3738 "\\\n" 3739 " public: \\\n" 3740 " void baz(); \\\n" 3741 " };", 3742 DontAlign)); 3743 } 3744 3745 TEST_F(FormatTest, CalculateSpaceOnConsecutiveLinesInMacro) { 3746 verifyFormat("#define A \\\n" 3747 " int v( \\\n" 3748 " a); \\\n" 3749 " int i;", 3750 getLLVMStyleWithColumns(11)); 3751 } 3752 3753 TEST_F(FormatTest, MixingPreprocessorDirectivesAndNormalCode) { 3754 EXPECT_EQ( 3755 "#define ALooooooooooooooooooooooooooooooooooooooongMacro(" 3756 " \\\n" 3757 " aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n" 3758 "\n" 3759 "AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n" 3760 " aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n", 3761 format(" #define ALooooooooooooooooooooooooooooooooooooooongMacro(" 3762 "\\\n" 3763 "aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n" 3764 " \n" 3765 " AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n" 3766 " aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n")); 3767 } 3768 3769 TEST_F(FormatTest, LayoutStatementsAroundPreprocessorDirectives) { 3770 EXPECT_EQ("int\n" 3771 "#define A\n" 3772 " a;", 3773 format("int\n#define A\na;")); 3774 verifyFormat("functionCallTo(\n" 3775 " someOtherFunction(\n" 3776 " withSomeParameters, whichInSequence,\n" 3777 " areLongerThanALine(andAnotherCall,\n" 3778 "#define A B\n" 3779 " withMoreParamters,\n" 3780 " whichStronglyInfluenceTheLayout),\n" 3781 " andMoreParameters),\n" 3782 " trailing);", 3783 getLLVMStyleWithColumns(69)); 3784 verifyFormat("Foo::Foo()\n" 3785 "#ifdef BAR\n" 3786 " : baz(0)\n" 3787 "#endif\n" 3788 "{\n" 3789 "}"); 3790 verifyFormat("void f() {\n" 3791 " if (true)\n" 3792 "#ifdef A\n" 3793 " f(42);\n" 3794 " x();\n" 3795 "#else\n" 3796 " g();\n" 3797 " x();\n" 3798 "#endif\n" 3799 "}"); 3800 verifyFormat("void f(param1, param2,\n" 3801 " param3,\n" 3802 "#ifdef A\n" 3803 " param4(param5,\n" 3804 "#ifdef A1\n" 3805 " param6,\n" 3806 "#ifdef A2\n" 3807 " param7),\n" 3808 "#else\n" 3809 " param8),\n" 3810 " param9,\n" 3811 "#endif\n" 3812 " param10,\n" 3813 "#endif\n" 3814 " param11)\n" 3815 "#else\n" 3816 " param12)\n" 3817 "#endif\n" 3818 "{\n" 3819 " x();\n" 3820 "}", 3821 getLLVMStyleWithColumns(28)); 3822 verifyFormat("#if 1\n" 3823 "int i;"); 3824 verifyFormat("#if 1\n" 3825 "#endif\n" 3826 "#if 1\n" 3827 "#else\n" 3828 "#endif\n"); 3829 verifyFormat("DEBUG({\n" 3830 " return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3831 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n" 3832 "});\n" 3833 "#if a\n" 3834 "#else\n" 3835 "#endif"); 3836 3837 verifyIncompleteFormat("void f(\n" 3838 "#if A\n" 3839 ");\n" 3840 "#else\n" 3841 "#endif"); 3842 } 3843 3844 TEST_F(FormatTest, GraciouslyHandleIncorrectPreprocessorConditions) { 3845 verifyFormat("#endif\n" 3846 "#if B"); 3847 } 3848 3849 TEST_F(FormatTest, FormatsJoinedLinesOnSubsequentRuns) { 3850 FormatStyle SingleLine = getLLVMStyle(); 3851 SingleLine.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_WithoutElse; 3852 verifyFormat("#if 0\n" 3853 "#elif 1\n" 3854 "#endif\n" 3855 "void foo() {\n" 3856 " if (test) foo2();\n" 3857 "}", 3858 SingleLine); 3859 } 3860 3861 TEST_F(FormatTest, LayoutBlockInsideParens) { 3862 verifyFormat("functionCall({ int i; });"); 3863 verifyFormat("functionCall({\n" 3864 " int i;\n" 3865 " int j;\n" 3866 "});"); 3867 verifyFormat("functionCall(\n" 3868 " {\n" 3869 " int i;\n" 3870 " int j;\n" 3871 " },\n" 3872 " aaaa, bbbb, cccc);"); 3873 verifyFormat("functionA(functionB({\n" 3874 " int i;\n" 3875 " int j;\n" 3876 " }),\n" 3877 " aaaa, bbbb, cccc);"); 3878 verifyFormat("functionCall(\n" 3879 " {\n" 3880 " int i;\n" 3881 " int j;\n" 3882 " },\n" 3883 " aaaa, bbbb, // comment\n" 3884 " cccc);"); 3885 verifyFormat("functionA(functionB({\n" 3886 " int i;\n" 3887 " int j;\n" 3888 " }),\n" 3889 " aaaa, bbbb, // comment\n" 3890 " cccc);"); 3891 verifyFormat("functionCall(aaaa, bbbb, { int i; });"); 3892 verifyFormat("functionCall(aaaa, bbbb, {\n" 3893 " int i;\n" 3894 " int j;\n" 3895 "});"); 3896 verifyFormat( 3897 "Aaa(\n" // FIXME: There shouldn't be a linebreak here. 3898 " {\n" 3899 " int i; // break\n" 3900 " },\n" 3901 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" 3902 " ccccccccccccccccc));"); 3903 verifyFormat("DEBUG({\n" 3904 " if (a)\n" 3905 " f();\n" 3906 "});"); 3907 } 3908 3909 TEST_F(FormatTest, LayoutBlockInsideStatement) { 3910 EXPECT_EQ("SOME_MACRO { int i; }\n" 3911 "int i;", 3912 format(" SOME_MACRO {int i;} int i;")); 3913 } 3914 3915 TEST_F(FormatTest, LayoutNestedBlocks) { 3916 verifyFormat("void AddOsStrings(unsigned bitmask) {\n" 3917 " struct s {\n" 3918 " int i;\n" 3919 " };\n" 3920 " s kBitsToOs[] = {{10}};\n" 3921 " for (int i = 0; i < 10; ++i)\n" 3922 " return;\n" 3923 "}"); 3924 verifyFormat("call(parameter, {\n" 3925 " something();\n" 3926 " // Comment using all columns.\n" 3927 " somethingelse();\n" 3928 "});", 3929 getLLVMStyleWithColumns(40)); 3930 verifyFormat("DEBUG( //\n" 3931 " { f(); }, a);"); 3932 verifyFormat("DEBUG( //\n" 3933 " {\n" 3934 " f(); //\n" 3935 " },\n" 3936 " a);"); 3937 3938 EXPECT_EQ("call(parameter, {\n" 3939 " something();\n" 3940 " // Comment too\n" 3941 " // looooooooooong.\n" 3942 " somethingElse();\n" 3943 "});", 3944 format("call(parameter, {\n" 3945 " something();\n" 3946 " // Comment too looooooooooong.\n" 3947 " somethingElse();\n" 3948 "});", 3949 getLLVMStyleWithColumns(29))); 3950 EXPECT_EQ("DEBUG({ int i; });", format("DEBUG({ int i; });")); 3951 EXPECT_EQ("DEBUG({ // comment\n" 3952 " int i;\n" 3953 "});", 3954 format("DEBUG({ // comment\n" 3955 "int i;\n" 3956 "});")); 3957 EXPECT_EQ("DEBUG({\n" 3958 " int i;\n" 3959 "\n" 3960 " // comment\n" 3961 " int j;\n" 3962 "});", 3963 format("DEBUG({\n" 3964 " int i;\n" 3965 "\n" 3966 " // comment\n" 3967 " int j;\n" 3968 "});")); 3969 3970 verifyFormat("DEBUG({\n" 3971 " if (a)\n" 3972 " return;\n" 3973 "});"); 3974 verifyGoogleFormat("DEBUG({\n" 3975 " if (a) return;\n" 3976 "});"); 3977 FormatStyle Style = getGoogleStyle(); 3978 Style.ColumnLimit = 45; 3979 verifyFormat("Debug(\n" 3980 " aaaaa,\n" 3981 " {\n" 3982 " if (aaaaaaaaaaaaaaaaaaaaaaaa) return;\n" 3983 " },\n" 3984 " a);", 3985 Style); 3986 3987 verifyFormat("SomeFunction({MACRO({ return output; }), b});"); 3988 3989 verifyNoCrash("^{v^{a}}"); 3990 } 3991 3992 TEST_F(FormatTest, FormatNestedBlocksInMacros) { 3993 EXPECT_EQ("#define MACRO() \\\n" 3994 " Debug(aaa, /* force line break */ \\\n" 3995 " { \\\n" 3996 " int i; \\\n" 3997 " int j; \\\n" 3998 " })", 3999 format("#define MACRO() Debug(aaa, /* force line break */ \\\n" 4000 " { int i; int j; })", 4001 getGoogleStyle())); 4002 4003 EXPECT_EQ("#define A \\\n" 4004 " [] { \\\n" 4005 " xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n" 4006 " xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); \\\n" 4007 " }", 4008 format("#define A [] { xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n" 4009 "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); }", 4010 getGoogleStyle())); 4011 } 4012 4013 TEST_F(FormatTest, PutEmptyBlocksIntoOneLine) { 4014 EXPECT_EQ("{}", format("{}")); 4015 verifyFormat("enum E {};"); 4016 verifyFormat("enum E {}"); 4017 FormatStyle Style = getLLVMStyle(); 4018 Style.SpaceInEmptyBlock = true; 4019 EXPECT_EQ("void f() { }", format("void f() {}", Style)); 4020 Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty; 4021 EXPECT_EQ("while (true) { }", format("while (true) {}", Style)); 4022 } 4023 4024 TEST_F(FormatTest, FormatBeginBlockEndMacros) { 4025 FormatStyle Style = getLLVMStyle(); 4026 Style.MacroBlockBegin = "^[A-Z_]+_BEGIN$"; 4027 Style.MacroBlockEnd = "^[A-Z_]+_END$"; 4028 verifyFormat("FOO_BEGIN\n" 4029 " FOO_ENTRY\n" 4030 "FOO_END", 4031 Style); 4032 verifyFormat("FOO_BEGIN\n" 4033 " NESTED_FOO_BEGIN\n" 4034 " NESTED_FOO_ENTRY\n" 4035 " NESTED_FOO_END\n" 4036 "FOO_END", 4037 Style); 4038 verifyFormat("FOO_BEGIN(Foo, Bar)\n" 4039 " int x;\n" 4040 " x = 1;\n" 4041 "FOO_END(Baz)", 4042 Style); 4043 } 4044 4045 //===----------------------------------------------------------------------===// 4046 // Line break tests. 4047 //===----------------------------------------------------------------------===// 4048 4049 TEST_F(FormatTest, PreventConfusingIndents) { 4050 verifyFormat( 4051 "void f() {\n" 4052 " SomeLongMethodName(SomeReallyLongMethod(CallOtherReallyLongMethod(\n" 4053 " parameter, parameter, parameter)),\n" 4054 " SecondLongCall(parameter));\n" 4055 "}"); 4056 verifyFormat( 4057 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4058 " aaaaaaaaaaaaaaaaaaaaaaaa(\n" 4059 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4060 " aaaaaaaaaaaaaaaaaaaaaaaa);"); 4061 verifyFormat( 4062 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4063 " [aaaaaaaaaaaaaaaaaaaaaaaa\n" 4064 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n" 4065 " [aaaaaaaaaaaaaaaaaaaaaaaa]];"); 4066 verifyFormat( 4067 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n" 4068 " aaaaaaaaaaaaaaaaaaaaaaaa<\n" 4069 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>,\n" 4070 " aaaaaaaaaaaaaaaaaaaaaaaa>;"); 4071 verifyFormat("int a = bbbb && ccc &&\n" 4072 " fffff(\n" 4073 "#define A Just forcing a new line\n" 4074 " ddd);"); 4075 } 4076 4077 TEST_F(FormatTest, LineBreakingInBinaryExpressions) { 4078 verifyFormat( 4079 "bool aaaaaaa =\n" 4080 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() ||\n" 4081 " bbbbbbbb();"); 4082 verifyFormat( 4083 "bool aaaaaaa =\n" 4084 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() or\n" 4085 " bbbbbbbb();"); 4086 4087 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n" 4088 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb &&\n" 4089 " ccccccccc == ddddddddddd;"); 4090 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n" 4091 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb and\n" 4092 " ccccccccc == ddddddddddd;"); 4093 verifyFormat( 4094 "bool aaaaaaaaaaaaaaaaaaaaa =\n" 4095 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa not_eq bbbbbbbbbbbbbbbbbb and\n" 4096 " ccccccccc == ddddddddddd;"); 4097 4098 verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n" 4099 " aaaaaa) &&\n" 4100 " bbbbbb && cccccc;"); 4101 verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n" 4102 " aaaaaa) >>\n" 4103 " bbbbbb;"); 4104 verifyFormat("aa = Whitespaces.addUntouchableComment(\n" 4105 " SourceMgr.getSpellingColumnNumber(\n" 4106 " TheLine.Last->FormatTok.Tok.getLocation()) -\n" 4107 " 1);"); 4108 4109 verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 4110 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaaaaaaa\n" 4111 " cccccc) {\n}"); 4112 verifyFormat("if constexpr ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 4113 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaa\n" 4114 " cccccc) {\n}"); 4115 verifyFormat("if CONSTEXPR ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 4116 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaa\n" 4117 " cccccc) {\n}"); 4118 verifyFormat("b = a &&\n" 4119 " // Comment\n" 4120 " b.c && d;"); 4121 4122 // If the LHS of a comparison is not a binary expression itself, the 4123 // additional linebreak confuses many people. 4124 verifyFormat( 4125 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4126 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) > 5) {\n" 4127 "}"); 4128 verifyFormat( 4129 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4130 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n" 4131 "}"); 4132 verifyFormat( 4133 "if (aaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaa(\n" 4134 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n" 4135 "}"); 4136 verifyFormat( 4137 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4138 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) <=> 5) {\n" 4139 "}"); 4140 // Even explicit parentheses stress the precedence enough to make the 4141 // additional break unnecessary. 4142 verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4143 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n" 4144 "}"); 4145 // This cases is borderline, but with the indentation it is still readable. 4146 verifyFormat( 4147 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4148 " aaaaaaaaaaaaaaa) > aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4149 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 4150 "}", 4151 getLLVMStyleWithColumns(75)); 4152 4153 // If the LHS is a binary expression, we should still use the additional break 4154 // as otherwise the formatting hides the operator precedence. 4155 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4156 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 4157 " 5) {\n" 4158 "}"); 4159 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4160 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa <=>\n" 4161 " 5) {\n" 4162 "}"); 4163 4164 FormatStyle OnePerLine = getLLVMStyle(); 4165 OnePerLine.BinPackParameters = false; 4166 verifyFormat( 4167 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 4168 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 4169 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}", 4170 OnePerLine); 4171 4172 verifyFormat("int i = someFunction(aaaaaaa, 0)\n" 4173 " .aaa(aaaaaaaaaaaaa) *\n" 4174 " aaaaaaa +\n" 4175 " aaaaaaa;", 4176 getLLVMStyleWithColumns(40)); 4177 } 4178 4179 TEST_F(FormatTest, ExpressionIndentation) { 4180 verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4181 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4182 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 4183 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 4184 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb +\n" 4185 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb &&\n" 4186 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 4187 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >\n" 4188 " ccccccccccccccccccccccccccccccccccccccccc;"); 4189 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 4190 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4191 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 4192 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); 4193 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4194 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 4195 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 4196 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); 4197 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 4198 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 4199 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4200 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); 4201 verifyFormat("if () {\n" 4202 "} else if (aaaaa && bbbbb > // break\n" 4203 " ccccc) {\n" 4204 "}"); 4205 verifyFormat("if () {\n" 4206 "} else if constexpr (aaaaa && bbbbb > // break\n" 4207 " ccccc) {\n" 4208 "}"); 4209 verifyFormat("if () {\n" 4210 "} else if CONSTEXPR (aaaaa && bbbbb > // break\n" 4211 " ccccc) {\n" 4212 "}"); 4213 verifyFormat("if () {\n" 4214 "} else if (aaaaa &&\n" 4215 " bbbbb > // break\n" 4216 " ccccc &&\n" 4217 " ddddd) {\n" 4218 "}"); 4219 4220 // Presence of a trailing comment used to change indentation of b. 4221 verifyFormat("return aaaaaaaaaaaaaaaaaaa +\n" 4222 " b;\n" 4223 "return aaaaaaaaaaaaaaaaaaa +\n" 4224 " b; //", 4225 getLLVMStyleWithColumns(30)); 4226 } 4227 4228 TEST_F(FormatTest, ExpressionIndentationBreakingBeforeOperators) { 4229 // Not sure what the best system is here. Like this, the LHS can be found 4230 // immediately above an operator (everything with the same or a higher 4231 // indent). The RHS is aligned right of the operator and so compasses 4232 // everything until something with the same indent as the operator is found. 4233 // FIXME: Is this a good system? 4234 FormatStyle Style = getLLVMStyle(); 4235 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 4236 verifyFormat( 4237 "bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4238 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4239 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4240 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4241 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4242 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4243 " && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4244 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4245 " > ccccccccccccccccccccccccccccccccccccccccc;", 4246 Style); 4247 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4248 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4249 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4250 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 4251 Style); 4252 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4253 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4254 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4255 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 4256 Style); 4257 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4258 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4259 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4260 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 4261 Style); 4262 verifyFormat("if () {\n" 4263 "} else if (aaaaa\n" 4264 " && bbbbb // break\n" 4265 " > ccccc) {\n" 4266 "}", 4267 Style); 4268 verifyFormat("return (a)\n" 4269 " // comment\n" 4270 " + b;", 4271 Style); 4272 verifyFormat( 4273 "int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4274 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4275 " + cc;", 4276 Style); 4277 4278 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4279 " = aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 4280 Style); 4281 4282 // Forced by comments. 4283 verifyFormat( 4284 "unsigned ContentSize =\n" 4285 " sizeof(int16_t) // DWARF ARange version number\n" 4286 " + sizeof(int32_t) // Offset of CU in the .debug_info section\n" 4287 " + sizeof(int8_t) // Pointer Size (in bytes)\n" 4288 " + sizeof(int8_t); // Segment Size (in bytes)"); 4289 4290 verifyFormat("return boost::fusion::at_c<0>(iiii).second\n" 4291 " == boost::fusion::at_c<1>(iiii).second;", 4292 Style); 4293 4294 Style.ColumnLimit = 60; 4295 verifyFormat("zzzzzzzzzz\n" 4296 " = bbbbbbbbbbbbbbbbb\n" 4297 " >> aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa);", 4298 Style); 4299 4300 Style.ColumnLimit = 80; 4301 Style.IndentWidth = 4; 4302 Style.TabWidth = 4; 4303 Style.UseTab = FormatStyle::UT_Always; 4304 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 4305 Style.AlignOperands = false; 4306 EXPECT_EQ("return someVeryVeryLongConditionThatBarelyFitsOnALine\n" 4307 "\t&& (someOtherLongishConditionPart1\n" 4308 "\t\t|| someOtherEvenLongerNestedConditionPart2);", 4309 format("return someVeryVeryLongConditionThatBarelyFitsOnALine && " 4310 "(someOtherLongishConditionPart1 || " 4311 "someOtherEvenLongerNestedConditionPart2);", 4312 Style)); 4313 } 4314 4315 TEST_F(FormatTest, EnforcedOperatorWraps) { 4316 // Here we'd like to wrap after the || operators, but a comment is forcing an 4317 // earlier wrap. 4318 verifyFormat("bool x = aaaaa //\n" 4319 " || bbbbb\n" 4320 " //\n" 4321 " || cccc;"); 4322 } 4323 4324 TEST_F(FormatTest, NoOperandAlignment) { 4325 FormatStyle Style = getLLVMStyle(); 4326 Style.AlignOperands = false; 4327 verifyFormat("aaaaaaaaaaaaaa(aaaaaaaaaaaa,\n" 4328 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4329 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 4330 Style); 4331 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment; 4332 verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4333 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4334 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4335 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4336 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4337 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4338 " && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4339 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4340 " > ccccccccccccccccccccccccccccccccccccccccc;", 4341 Style); 4342 4343 verifyFormat("int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4344 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4345 " + cc;", 4346 Style); 4347 verifyFormat("int a = aa\n" 4348 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4349 " * cccccccccccccccccccccccccccccccccccc;\n", 4350 Style); 4351 4352 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 4353 verifyFormat("return (a > b\n" 4354 " // comment1\n" 4355 " // comment2\n" 4356 " || c);", 4357 Style); 4358 } 4359 4360 TEST_F(FormatTest, BreakingBeforeNonAssigmentOperators) { 4361 FormatStyle Style = getLLVMStyle(); 4362 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment; 4363 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 4364 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4365 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;", 4366 Style); 4367 } 4368 4369 TEST_F(FormatTest, AllowBinPackingInsideArguments) { 4370 FormatStyle Style = getLLVMStyle(); 4371 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment; 4372 Style.BinPackArguments = false; 4373 Style.ColumnLimit = 40; 4374 verifyFormat("void test() {\n" 4375 " someFunction(\n" 4376 " this + argument + is + quite\n" 4377 " + long + so + it + gets + wrapped\n" 4378 " + but + remains + bin - packed);\n" 4379 "}", 4380 Style); 4381 verifyFormat("void test() {\n" 4382 " someFunction(arg1,\n" 4383 " this + argument + is\n" 4384 " + quite + long + so\n" 4385 " + it + gets + wrapped\n" 4386 " + but + remains + bin\n" 4387 " - packed,\n" 4388 " arg3);\n" 4389 "}", 4390 Style); 4391 verifyFormat("void test() {\n" 4392 " someFunction(\n" 4393 " arg1,\n" 4394 " this + argument + has\n" 4395 " + anotherFunc(nested,\n" 4396 " calls + whose\n" 4397 " + arguments\n" 4398 " + are + also\n" 4399 " + wrapped,\n" 4400 " in + addition)\n" 4401 " + to + being + bin - packed,\n" 4402 " arg3);\n" 4403 "}", 4404 Style); 4405 4406 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 4407 verifyFormat("void test() {\n" 4408 " someFunction(\n" 4409 " arg1,\n" 4410 " this + argument + has +\n" 4411 " anotherFunc(nested,\n" 4412 " calls + whose +\n" 4413 " arguments +\n" 4414 " are + also +\n" 4415 " wrapped,\n" 4416 " in + addition) +\n" 4417 " to + being + bin - packed,\n" 4418 " arg3);\n" 4419 "}", 4420 Style); 4421 } 4422 4423 TEST_F(FormatTest, ConstructorInitializers) { 4424 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}"); 4425 verifyFormat("Constructor() : Inttializer(FitsOnTheLine) {}", 4426 getLLVMStyleWithColumns(45)); 4427 verifyFormat("Constructor()\n" 4428 " : Inttializer(FitsOnTheLine) {}", 4429 getLLVMStyleWithColumns(44)); 4430 verifyFormat("Constructor()\n" 4431 " : Inttializer(FitsOnTheLine) {}", 4432 getLLVMStyleWithColumns(43)); 4433 4434 verifyFormat("template <typename T>\n" 4435 "Constructor() : Initializer(FitsOnTheLine) {}", 4436 getLLVMStyleWithColumns(45)); 4437 4438 verifyFormat( 4439 "SomeClass::Constructor()\n" 4440 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}"); 4441 4442 verifyFormat( 4443 "SomeClass::Constructor()\n" 4444 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4445 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}"); 4446 verifyFormat( 4447 "SomeClass::Constructor()\n" 4448 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4449 " aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}"); 4450 verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4451 " aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 4452 " : aaaaaaaaaa(aaaaaa) {}"); 4453 4454 verifyFormat("Constructor()\n" 4455 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4456 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4457 " aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4458 " aaaaaaaaaaaaaaaaaaaaaaa() {}"); 4459 4460 verifyFormat("Constructor()\n" 4461 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4462 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); 4463 4464 verifyFormat("Constructor(int Parameter = 0)\n" 4465 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n" 4466 " aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}"); 4467 verifyFormat("Constructor()\n" 4468 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n" 4469 "}", 4470 getLLVMStyleWithColumns(60)); 4471 verifyFormat("Constructor()\n" 4472 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4473 " aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}"); 4474 4475 // Here a line could be saved by splitting the second initializer onto two 4476 // lines, but that is not desirable. 4477 verifyFormat("Constructor()\n" 4478 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n" 4479 " aaaaaaaaaaa(aaaaaaaaaaa),\n" 4480 " aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); 4481 4482 FormatStyle OnePerLine = getLLVMStyle(); 4483 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4484 OnePerLine.AllowAllParametersOfDeclarationOnNextLine = false; 4485 verifyFormat("SomeClass::Constructor()\n" 4486 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4487 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4488 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4489 OnePerLine); 4490 verifyFormat("SomeClass::Constructor()\n" 4491 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n" 4492 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4493 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4494 OnePerLine); 4495 verifyFormat("MyClass::MyClass(int var)\n" 4496 " : some_var_(var), // 4 space indent\n" 4497 " some_other_var_(var + 1) { // lined up\n" 4498 "}", 4499 OnePerLine); 4500 verifyFormat("Constructor()\n" 4501 " : aaaaa(aaaaaa),\n" 4502 " aaaaa(aaaaaa),\n" 4503 " aaaaa(aaaaaa),\n" 4504 " aaaaa(aaaaaa),\n" 4505 " aaaaa(aaaaaa) {}", 4506 OnePerLine); 4507 verifyFormat("Constructor()\n" 4508 " : aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n" 4509 " aaaaaaaaaaaaaaaaaaaaaa) {}", 4510 OnePerLine); 4511 OnePerLine.BinPackParameters = false; 4512 verifyFormat( 4513 "Constructor()\n" 4514 " : aaaaaaaaaaaaaaaaaaaaaaaa(\n" 4515 " aaaaaaaaaaa().aaa(),\n" 4516 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4517 OnePerLine); 4518 OnePerLine.ColumnLimit = 60; 4519 verifyFormat("Constructor()\n" 4520 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4521 " bbbbbbbbbbbbbbbbbbbbbbbb(b) {}", 4522 OnePerLine); 4523 4524 EXPECT_EQ("Constructor()\n" 4525 " : // Comment forcing unwanted break.\n" 4526 " aaaa(aaaa) {}", 4527 format("Constructor() :\n" 4528 " // Comment forcing unwanted break.\n" 4529 " aaaa(aaaa) {}")); 4530 } 4531 4532 TEST_F(FormatTest, AllowAllConstructorInitializersOnNextLine) { 4533 FormatStyle Style = getLLVMStyle(); 4534 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 4535 Style.ColumnLimit = 60; 4536 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4537 Style.AllowAllConstructorInitializersOnNextLine = true; 4538 Style.BinPackParameters = false; 4539 4540 for (int i = 0; i < 4; ++i) { 4541 // Test all combinations of parameters that should not have an effect. 4542 Style.AllowAllParametersOfDeclarationOnNextLine = i & 1; 4543 Style.AllowAllArgumentsOnNextLine = i & 2; 4544 4545 Style.AllowAllConstructorInitializersOnNextLine = true; 4546 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 4547 verifyFormat("Constructor()\n" 4548 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4549 Style); 4550 verifyFormat("Constructor() : a(a), b(b) {}", Style); 4551 4552 Style.AllowAllConstructorInitializersOnNextLine = false; 4553 verifyFormat("Constructor()\n" 4554 " : aaaaaaaaaaaaaaaaaaaa(a)\n" 4555 " , bbbbbbbbbbbbbbbbbbbbb(b) {}", 4556 Style); 4557 verifyFormat("Constructor() : a(a), b(b) {}", Style); 4558 4559 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon; 4560 Style.AllowAllConstructorInitializersOnNextLine = true; 4561 verifyFormat("Constructor()\n" 4562 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4563 Style); 4564 4565 Style.AllowAllConstructorInitializersOnNextLine = false; 4566 verifyFormat("Constructor()\n" 4567 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4568 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4569 Style); 4570 4571 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 4572 Style.AllowAllConstructorInitializersOnNextLine = true; 4573 verifyFormat("Constructor() :\n" 4574 " aaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4575 Style); 4576 4577 Style.AllowAllConstructorInitializersOnNextLine = false; 4578 verifyFormat("Constructor() :\n" 4579 " aaaaaaaaaaaaaaaaaa(a),\n" 4580 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4581 Style); 4582 } 4583 4584 // Test interactions between AllowAllParametersOfDeclarationOnNextLine and 4585 // AllowAllConstructorInitializersOnNextLine in all 4586 // BreakConstructorInitializers modes 4587 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 4588 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4589 Style.AllowAllConstructorInitializersOnNextLine = false; 4590 verifyFormat("SomeClassWithALongName::Constructor(\n" 4591 " int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb)\n" 4592 " : aaaaaaaaaaaaaaaaaaaa(a)\n" 4593 " , bbbbbbbbbbbbbbbbbbbbb(b) {}", 4594 Style); 4595 4596 Style.AllowAllConstructorInitializersOnNextLine = true; 4597 verifyFormat("SomeClassWithALongName::Constructor(\n" 4598 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4599 " int bbbbbbbbbbbbb,\n" 4600 " int cccccccccccccccc)\n" 4601 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4602 Style); 4603 4604 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4605 Style.AllowAllConstructorInitializersOnNextLine = false; 4606 verifyFormat("SomeClassWithALongName::Constructor(\n" 4607 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4608 " int bbbbbbbbbbbbb)\n" 4609 " : aaaaaaaaaaaaaaaaaaaa(a)\n" 4610 " , bbbbbbbbbbbbbbbbbbbbb(b) {}", 4611 Style); 4612 4613 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon; 4614 4615 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4616 verifyFormat("SomeClassWithALongName::Constructor(\n" 4617 " int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb)\n" 4618 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4619 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4620 Style); 4621 4622 Style.AllowAllConstructorInitializersOnNextLine = true; 4623 verifyFormat("SomeClassWithALongName::Constructor(\n" 4624 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4625 " int bbbbbbbbbbbbb,\n" 4626 " int cccccccccccccccc)\n" 4627 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4628 Style); 4629 4630 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4631 Style.AllowAllConstructorInitializersOnNextLine = false; 4632 verifyFormat("SomeClassWithALongName::Constructor(\n" 4633 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4634 " int bbbbbbbbbbbbb)\n" 4635 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4636 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4637 Style); 4638 4639 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 4640 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4641 verifyFormat("SomeClassWithALongName::Constructor(\n" 4642 " int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb) :\n" 4643 " aaaaaaaaaaaaaaaaaaaa(a),\n" 4644 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4645 Style); 4646 4647 Style.AllowAllConstructorInitializersOnNextLine = true; 4648 verifyFormat("SomeClassWithALongName::Constructor(\n" 4649 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4650 " int bbbbbbbbbbbbb,\n" 4651 " int cccccccccccccccc) :\n" 4652 " aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4653 Style); 4654 4655 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4656 Style.AllowAllConstructorInitializersOnNextLine = false; 4657 verifyFormat("SomeClassWithALongName::Constructor(\n" 4658 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4659 " int bbbbbbbbbbbbb) :\n" 4660 " aaaaaaaaaaaaaaaaaaaa(a),\n" 4661 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4662 Style); 4663 } 4664 4665 TEST_F(FormatTest, AllowAllArgumentsOnNextLine) { 4666 FormatStyle Style = getLLVMStyle(); 4667 Style.ColumnLimit = 60; 4668 Style.BinPackArguments = false; 4669 for (int i = 0; i < 4; ++i) { 4670 // Test all combinations of parameters that should not have an effect. 4671 Style.AllowAllParametersOfDeclarationOnNextLine = i & 1; 4672 Style.AllowAllConstructorInitializersOnNextLine = i & 2; 4673 4674 Style.AllowAllArgumentsOnNextLine = true; 4675 verifyFormat("void foo() {\n" 4676 " FunctionCallWithReallyLongName(\n" 4677 " aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbb);\n" 4678 "}", 4679 Style); 4680 Style.AllowAllArgumentsOnNextLine = false; 4681 verifyFormat("void foo() {\n" 4682 " FunctionCallWithReallyLongName(\n" 4683 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4684 " bbbbbbbbbbbb);\n" 4685 "}", 4686 Style); 4687 4688 Style.AllowAllArgumentsOnNextLine = true; 4689 verifyFormat("void foo() {\n" 4690 " auto VariableWithReallyLongName = {\n" 4691 " aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbb};\n" 4692 "}", 4693 Style); 4694 Style.AllowAllArgumentsOnNextLine = false; 4695 verifyFormat("void foo() {\n" 4696 " auto VariableWithReallyLongName = {\n" 4697 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4698 " bbbbbbbbbbbb};\n" 4699 "}", 4700 Style); 4701 } 4702 4703 // This parameter should not affect declarations. 4704 Style.BinPackParameters = false; 4705 Style.AllowAllArgumentsOnNextLine = false; 4706 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4707 verifyFormat("void FunctionCallWithReallyLongName(\n" 4708 " int aaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbb);", 4709 Style); 4710 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4711 verifyFormat("void FunctionCallWithReallyLongName(\n" 4712 " int aaaaaaaaaaaaaaaaaaaaaaa,\n" 4713 " int bbbbbbbbbbbb);", 4714 Style); 4715 } 4716 4717 TEST_F(FormatTest, BreakConstructorInitializersAfterColon) { 4718 FormatStyle Style = getLLVMStyle(); 4719 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 4720 4721 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}"); 4722 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}", 4723 getStyleWithColumns(Style, 45)); 4724 verifyFormat("Constructor() :\n" 4725 " Initializer(FitsOnTheLine) {}", 4726 getStyleWithColumns(Style, 44)); 4727 verifyFormat("Constructor() :\n" 4728 " Initializer(FitsOnTheLine) {}", 4729 getStyleWithColumns(Style, 43)); 4730 4731 verifyFormat("template <typename T>\n" 4732 "Constructor() : Initializer(FitsOnTheLine) {}", 4733 getStyleWithColumns(Style, 50)); 4734 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4735 verifyFormat( 4736 "SomeClass::Constructor() :\n" 4737 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}", 4738 Style); 4739 4740 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = false; 4741 verifyFormat( 4742 "SomeClass::Constructor() :\n" 4743 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}", 4744 Style); 4745 4746 verifyFormat( 4747 "SomeClass::Constructor() :\n" 4748 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4749 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4750 Style); 4751 verifyFormat( 4752 "SomeClass::Constructor() :\n" 4753 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4754 " aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}", 4755 Style); 4756 verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4757 " aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n" 4758 " aaaaaaaaaa(aaaaaa) {}", 4759 Style); 4760 4761 verifyFormat("Constructor() :\n" 4762 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4763 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4764 " aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4765 " aaaaaaaaaaaaaaaaaaaaaaa() {}", 4766 Style); 4767 4768 verifyFormat("Constructor() :\n" 4769 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4770 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4771 Style); 4772 4773 verifyFormat("Constructor(int Parameter = 0) :\n" 4774 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n" 4775 " aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}", 4776 Style); 4777 verifyFormat("Constructor() :\n" 4778 " aaaaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n" 4779 "}", 4780 getStyleWithColumns(Style, 60)); 4781 verifyFormat("Constructor() :\n" 4782 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4783 " aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}", 4784 Style); 4785 4786 // Here a line could be saved by splitting the second initializer onto two 4787 // lines, but that is not desirable. 4788 verifyFormat("Constructor() :\n" 4789 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n" 4790 " aaaaaaaaaaa(aaaaaaaaaaa),\n" 4791 " aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4792 Style); 4793 4794 FormatStyle OnePerLine = Style; 4795 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4796 OnePerLine.AllowAllConstructorInitializersOnNextLine = false; 4797 verifyFormat("SomeClass::Constructor() :\n" 4798 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4799 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4800 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4801 OnePerLine); 4802 verifyFormat("SomeClass::Constructor() :\n" 4803 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n" 4804 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4805 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4806 OnePerLine); 4807 verifyFormat("MyClass::MyClass(int var) :\n" 4808 " some_var_(var), // 4 space indent\n" 4809 " some_other_var_(var + 1) { // lined up\n" 4810 "}", 4811 OnePerLine); 4812 verifyFormat("Constructor() :\n" 4813 " aaaaa(aaaaaa),\n" 4814 " aaaaa(aaaaaa),\n" 4815 " aaaaa(aaaaaa),\n" 4816 " aaaaa(aaaaaa),\n" 4817 " aaaaa(aaaaaa) {}", 4818 OnePerLine); 4819 verifyFormat("Constructor() :\n" 4820 " aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n" 4821 " aaaaaaaaaaaaaaaaaaaaaa) {}", 4822 OnePerLine); 4823 OnePerLine.BinPackParameters = false; 4824 verifyFormat("Constructor() :\n" 4825 " aaaaaaaaaaaaaaaaaaaaaaaa(\n" 4826 " aaaaaaaaaaa().aaa(),\n" 4827 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4828 OnePerLine); 4829 OnePerLine.ColumnLimit = 60; 4830 verifyFormat("Constructor() :\n" 4831 " aaaaaaaaaaaaaaaaaaaa(a),\n" 4832 " bbbbbbbbbbbbbbbbbbbbbbbb(b) {}", 4833 OnePerLine); 4834 4835 EXPECT_EQ("Constructor() :\n" 4836 " // Comment forcing unwanted break.\n" 4837 " aaaa(aaaa) {}", 4838 format("Constructor() :\n" 4839 " // Comment forcing unwanted break.\n" 4840 " aaaa(aaaa) {}", 4841 Style)); 4842 4843 Style.ColumnLimit = 0; 4844 verifyFormat("SomeClass::Constructor() :\n" 4845 " a(a) {}", 4846 Style); 4847 verifyFormat("SomeClass::Constructor() noexcept :\n" 4848 " a(a) {}", 4849 Style); 4850 verifyFormat("SomeClass::Constructor() :\n" 4851 " a(a), b(b), c(c) {}", 4852 Style); 4853 verifyFormat("SomeClass::Constructor() :\n" 4854 " a(a) {\n" 4855 " foo();\n" 4856 " bar();\n" 4857 "}", 4858 Style); 4859 4860 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 4861 verifyFormat("SomeClass::Constructor() :\n" 4862 " a(a), b(b), c(c) {\n" 4863 "}", 4864 Style); 4865 verifyFormat("SomeClass::Constructor() :\n" 4866 " a(a) {\n" 4867 "}", 4868 Style); 4869 4870 Style.ColumnLimit = 80; 4871 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 4872 Style.ConstructorInitializerIndentWidth = 2; 4873 verifyFormat("SomeClass::Constructor() : a(a), b(b), c(c) {}", Style); 4874 verifyFormat("SomeClass::Constructor() :\n" 4875 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4876 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {}", 4877 Style); 4878 4879 // `ConstructorInitializerIndentWidth` actually applies to InheritanceList as 4880 // well 4881 Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon; 4882 verifyFormat( 4883 "class SomeClass\n" 4884 " : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4885 " public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};", 4886 Style); 4887 Style.BreakInheritanceList = FormatStyle::BILS_BeforeComma; 4888 verifyFormat( 4889 "class SomeClass\n" 4890 " : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4891 " , public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};", 4892 Style); 4893 Style.BreakInheritanceList = FormatStyle::BILS_AfterColon; 4894 verifyFormat( 4895 "class SomeClass :\n" 4896 " public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4897 " public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};", 4898 Style); 4899 } 4900 4901 #ifndef EXPENSIVE_CHECKS 4902 // Expensive checks enables libstdc++ checking which includes validating the 4903 // state of ranges used in std::priority_queue - this blows out the 4904 // runtime/scalability of the function and makes this test unacceptably slow. 4905 TEST_F(FormatTest, MemoizationTests) { 4906 // This breaks if the memoization lookup does not take \c Indent and 4907 // \c LastSpace into account. 4908 verifyFormat( 4909 "extern CFRunLoopTimerRef\n" 4910 "CFRunLoopTimerCreate(CFAllocatorRef allocato, CFAbsoluteTime fireDate,\n" 4911 " CFTimeInterval interval, CFOptionFlags flags,\n" 4912 " CFIndex order, CFRunLoopTimerCallBack callout,\n" 4913 " CFRunLoopTimerContext *context) {}"); 4914 4915 // Deep nesting somewhat works around our memoization. 4916 verifyFormat( 4917 "aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 4918 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 4919 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 4920 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 4921 " aaaaa())))))))))))))))))))))))))))))))))))))));", 4922 getLLVMStyleWithColumns(65)); 4923 verifyFormat( 4924 "aaaaa(\n" 4925 " aaaaa,\n" 4926 " aaaaa(\n" 4927 " aaaaa,\n" 4928 " aaaaa(\n" 4929 " aaaaa,\n" 4930 " aaaaa(\n" 4931 " aaaaa,\n" 4932 " aaaaa(\n" 4933 " aaaaa,\n" 4934 " aaaaa(\n" 4935 " aaaaa,\n" 4936 " aaaaa(\n" 4937 " aaaaa,\n" 4938 " aaaaa(\n" 4939 " aaaaa,\n" 4940 " aaaaa(\n" 4941 " aaaaa,\n" 4942 " aaaaa(\n" 4943 " aaaaa,\n" 4944 " aaaaa(\n" 4945 " aaaaa,\n" 4946 " aaaaa(\n" 4947 " aaaaa,\n" 4948 " aaaaa))))))))))));", 4949 getLLVMStyleWithColumns(65)); 4950 verifyFormat( 4951 "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" 4952 " a),\n" 4953 " a),\n" 4954 " a),\n" 4955 " a),\n" 4956 " a),\n" 4957 " a),\n" 4958 " a),\n" 4959 " a),\n" 4960 " a),\n" 4961 " a),\n" 4962 " a),\n" 4963 " a),\n" 4964 " a),\n" 4965 " a),\n" 4966 " a),\n" 4967 " a),\n" 4968 " a)", 4969 getLLVMStyleWithColumns(65)); 4970 4971 // This test takes VERY long when memoization is broken. 4972 FormatStyle OnePerLine = getLLVMStyle(); 4973 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4974 OnePerLine.BinPackParameters = false; 4975 std::string input = "Constructor()\n" 4976 " : aaaa(a,\n"; 4977 for (unsigned i = 0, e = 80; i != e; ++i) { 4978 input += " a,\n"; 4979 } 4980 input += " a) {}"; 4981 verifyFormat(input, OnePerLine); 4982 } 4983 #endif 4984 4985 TEST_F(FormatTest, BreaksAsHighAsPossible) { 4986 verifyFormat( 4987 "void f() {\n" 4988 " if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaaaaaaaa) ||\n" 4989 " (bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb && bbbbbbbbbbbbbbbbbbbbbbbbbb))\n" 4990 " f();\n" 4991 "}"); 4992 verifyFormat("if (Intervals[i].getRange().getFirst() <\n" 4993 " Intervals[i - 1].getRange().getLast()) {\n}"); 4994 } 4995 4996 TEST_F(FormatTest, BreaksFunctionDeclarations) { 4997 // Principially, we break function declarations in a certain order: 4998 // 1) break amongst arguments. 4999 verifyFormat("Aaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccc,\n" 5000 " Cccccccccccccc cccccccccccccc);"); 5001 verifyFormat("template <class TemplateIt>\n" 5002 "SomeReturnType SomeFunction(TemplateIt begin, TemplateIt end,\n" 5003 " TemplateIt *stop) {}"); 5004 5005 // 2) break after return type. 5006 verifyFormat( 5007 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5008 "bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccccccccccccccc);", 5009 getGoogleStyle()); 5010 5011 // 3) break after (. 5012 verifyFormat( 5013 "Aaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbb(\n" 5014 " Cccccccccccccccccccccccccccccc cccccccccccccccccccccccccccccccc);", 5015 getGoogleStyle()); 5016 5017 // 4) break before after nested name specifiers. 5018 verifyFormat( 5019 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5020 "SomeClasssssssssssssssssssssssssssssssssssssss::\n" 5021 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc);", 5022 getGoogleStyle()); 5023 5024 // However, there are exceptions, if a sufficient amount of lines can be 5025 // saved. 5026 // FIXME: The precise cut-offs wrt. the number of saved lines might need some 5027 // more adjusting. 5028 verifyFormat("Aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n" 5029 " Cccccccccccccc cccccccccc,\n" 5030 " Cccccccccccccc cccccccccc,\n" 5031 " Cccccccccccccc cccccccccc,\n" 5032 " Cccccccccccccc cccccccccc);"); 5033 verifyFormat( 5034 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5035 "bbbbbbbbbbb(Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 5036 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 5037 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);", 5038 getGoogleStyle()); 5039 verifyFormat( 5040 "Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n" 5041 " Cccccccccccccc cccccccccc,\n" 5042 " Cccccccccccccc cccccccccc,\n" 5043 " Cccccccccccccc cccccccccc,\n" 5044 " Cccccccccccccc cccccccccc,\n" 5045 " Cccccccccccccc cccccccccc,\n" 5046 " Cccccccccccccc cccccccccc);"); 5047 verifyFormat("Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 5048 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 5049 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 5050 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 5051 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);"); 5052 5053 // Break after multi-line parameters. 5054 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5055 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5056 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5057 " bbbb bbbb);"); 5058 verifyFormat("void SomeLoooooooooooongFunction(\n" 5059 " std::unique_ptr<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n" 5060 " aaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5061 " int bbbbbbbbbbbbb);"); 5062 5063 // Treat overloaded operators like other functions. 5064 verifyFormat("SomeLoooooooooooooooooooooooooogType\n" 5065 "operator>(const SomeLoooooooooooooooooooooooooogType &other);"); 5066 verifyFormat("SomeLoooooooooooooooooooooooooogType\n" 5067 "operator>>(const SomeLooooooooooooooooooooooooogType &other);"); 5068 verifyFormat("SomeLoooooooooooooooooooooooooogType\n" 5069 "operator<<(const SomeLooooooooooooooooooooooooogType &other);"); 5070 verifyGoogleFormat( 5071 "SomeLoooooooooooooooooooooooooooooogType operator>>(\n" 5072 " const SomeLooooooooogType &a, const SomeLooooooooogType &b);"); 5073 verifyGoogleFormat( 5074 "SomeLoooooooooooooooooooooooooooooogType operator<<(\n" 5075 " const SomeLooooooooogType &a, const SomeLooooooooogType &b);"); 5076 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5077 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = 1);"); 5078 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa\n" 5079 "aaaaaaaaaaaaaaaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaa = 1);"); 5080 verifyGoogleFormat( 5081 "typename aaaaaaaaaa<aaaaaa>::aaaaaaaaaaa\n" 5082 "aaaaaaaaaa<aaaaaa>::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5083 " bool *aaaaaaaaaaaaaaaaaa, bool *aa) {}"); 5084 verifyGoogleFormat("template <typename T>\n" 5085 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5086 "aaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaaaaa(\n" 5087 " aaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaa);"); 5088 5089 FormatStyle Style = getLLVMStyle(); 5090 Style.PointerAlignment = FormatStyle::PAS_Left; 5091 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5092 " aaaaaaaaaaaaaaaaaaaaaaaaa* const aaaaaaaaaaaa) {}", 5093 Style); 5094 verifyFormat("void aaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*\n" 5095 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 5096 Style); 5097 } 5098 5099 TEST_F(FormatTest, DontBreakBeforeQualifiedOperator) { 5100 // Regression test for https://bugs.llvm.org/show_bug.cgi?id=40516: 5101 // Prefer keeping `::` followed by `operator` together. 5102 EXPECT_EQ("const aaaa::bbbbbbb &\n" 5103 "ccccccccc::operator++() {\n" 5104 " stuff();\n" 5105 "}", 5106 format("const aaaa::bbbbbbb\n" 5107 "&ccccccccc::operator++() { stuff(); }", 5108 getLLVMStyleWithColumns(40))); 5109 } 5110 5111 TEST_F(FormatTest, TrailingReturnType) { 5112 verifyFormat("auto foo() -> int;\n"); 5113 // correct trailing return type spacing 5114 verifyFormat("auto operator->() -> int;\n"); 5115 verifyFormat("auto operator++(int) -> int;\n"); 5116 5117 verifyFormat("struct S {\n" 5118 " auto bar() const -> int;\n" 5119 "};"); 5120 verifyFormat("template <size_t Order, typename T>\n" 5121 "auto load_img(const std::string &filename)\n" 5122 " -> alias::tensor<Order, T, mem::tag::cpu> {}"); 5123 verifyFormat("auto SomeFunction(A aaaaaaaaaaaaaaaaaaaaa) const\n" 5124 " -> decltype(f(aaaaaaaaaaaaaaaaaaaaa)) {}"); 5125 verifyFormat("auto doSomething(Aaaaaa *aaaaaa) -> decltype(aaaaaa->f()) {}"); 5126 verifyFormat("template <typename T>\n" 5127 "auto aaaaaaaaaaaaaaaaaaaaaa(T t)\n" 5128 " -> decltype(eaaaaaaaaaaaaaaa<T>(t.a).aaaaaaaa());"); 5129 5130 // Not trailing return types. 5131 verifyFormat("void f() { auto a = b->c(); }"); 5132 } 5133 5134 TEST_F(FormatTest, DeductionGuides) { 5135 verifyFormat("template <class T> A(const T &, const T &) -> A<T &>;"); 5136 verifyFormat("template <class T> explicit A(T &, T &&) -> A<T>;"); 5137 verifyFormat("template <class... Ts> S(Ts...) -> S<Ts...>;"); 5138 verifyFormat( 5139 "template <class... T>\n" 5140 "array(T &&... t) -> array<std::common_type_t<T...>, sizeof...(T)>;"); 5141 verifyFormat("template <class T> A() -> A<decltype(p->foo<3>())>;"); 5142 verifyFormat("template <class T> A() -> A<decltype(foo<traits<1>>)>;"); 5143 verifyFormat("template <class T> A() -> A<sizeof(p->foo<1>)>;"); 5144 verifyFormat("template <class T> A() -> A<(3 < 2)>;"); 5145 verifyFormat("template <class T> A() -> A<((3) < (2))>;"); 5146 verifyFormat("template <class T> x() -> x<1>;"); 5147 verifyFormat("template <class T> explicit x(T &) -> x<1>;"); 5148 5149 // Ensure not deduction guides. 5150 verifyFormat("c()->f<int>();"); 5151 verifyFormat("x()->foo<1>;"); 5152 verifyFormat("x = p->foo<3>();"); 5153 verifyFormat("x()->x<1>();"); 5154 verifyFormat("x()->x<1>;"); 5155 } 5156 5157 TEST_F(FormatTest, BreaksFunctionDeclarationsWithTrailingTokens) { 5158 // Avoid breaking before trailing 'const' or other trailing annotations, if 5159 // they are not function-like. 5160 FormatStyle Style = getGoogleStyle(); 5161 Style.ColumnLimit = 47; 5162 verifyFormat("void someLongFunction(\n" 5163 " int someLoooooooooooooongParameter) const {\n}", 5164 getLLVMStyleWithColumns(47)); 5165 verifyFormat("LoooooongReturnType\n" 5166 "someLoooooooongFunction() const {}", 5167 getLLVMStyleWithColumns(47)); 5168 verifyFormat("LoooooongReturnType someLoooooooongFunction()\n" 5169 " const {}", 5170 Style); 5171 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n" 5172 " aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE;"); 5173 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n" 5174 " aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE FINAL;"); 5175 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n" 5176 " aaaaa aaaaaaaaaaaaaaaaaaaa) override final;"); 5177 verifyFormat("virtual void aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa,\n" 5178 " aaaaaaaaaaa aaaaa) const override;"); 5179 verifyGoogleFormat( 5180 "virtual void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5181 " const override;"); 5182 5183 // Even if the first parameter has to be wrapped. 5184 verifyFormat("void someLongFunction(\n" 5185 " int someLongParameter) const {}", 5186 getLLVMStyleWithColumns(46)); 5187 verifyFormat("void someLongFunction(\n" 5188 " int someLongParameter) const {}", 5189 Style); 5190 verifyFormat("void someLongFunction(\n" 5191 " int someLongParameter) override {}", 5192 Style); 5193 verifyFormat("void someLongFunction(\n" 5194 " int someLongParameter) OVERRIDE {}", 5195 Style); 5196 verifyFormat("void someLongFunction(\n" 5197 " int someLongParameter) final {}", 5198 Style); 5199 verifyFormat("void someLongFunction(\n" 5200 " int someLongParameter) FINAL {}", 5201 Style); 5202 verifyFormat("void someLongFunction(\n" 5203 " int parameter) const override {}", 5204 Style); 5205 5206 Style.BreakBeforeBraces = FormatStyle::BS_Allman; 5207 verifyFormat("void someLongFunction(\n" 5208 " int someLongParameter) const\n" 5209 "{\n" 5210 "}", 5211 Style); 5212 5213 Style.BreakBeforeBraces = FormatStyle::BS_Whitesmiths; 5214 verifyFormat("void someLongFunction(\n" 5215 " int someLongParameter) const\n" 5216 " {\n" 5217 " }", 5218 Style); 5219 5220 // Unless these are unknown annotations. 5221 verifyFormat("void SomeFunction(aaaaaaaaaa aaaaaaaaaaaaaaa,\n" 5222 " aaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5223 " LONG_AND_UGLY_ANNOTATION;"); 5224 5225 // Breaking before function-like trailing annotations is fine to keep them 5226 // close to their arguments. 5227 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5228 " LOCKS_EXCLUDED(aaaaaaaaaaaaa);"); 5229 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n" 5230 " LOCKS_EXCLUDED(aaaaaaaaaaaaa);"); 5231 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n" 5232 " LOCKS_EXCLUDED(aaaaaaaaaaaaa) {}"); 5233 verifyGoogleFormat("void aaaaaaaaaaaaaa(aaaaaaaa aaa) override\n" 5234 " AAAAAAAAAAAAAAAAAAAAAAAA(aaaaaaaaaaaaaaa);"); 5235 verifyFormat("SomeFunction([](int i) LOCKS_EXCLUDED(a) {});"); 5236 5237 verifyFormat( 5238 "void aaaaaaaaaaaaaaaaaa()\n" 5239 " __attribute__((aaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaa,\n" 5240 " aaaaaaaaaaaaaaaaaaaaaaaaa));"); 5241 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5242 " __attribute__((unused));"); 5243 verifyGoogleFormat( 5244 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5245 " GUARDED_BY(aaaaaaaaaaaa);"); 5246 verifyGoogleFormat( 5247 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5248 " GUARDED_BY(aaaaaaaaaaaa);"); 5249 verifyGoogleFormat( 5250 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n" 5251 " aaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5252 verifyGoogleFormat( 5253 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n" 5254 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5255 } 5256 5257 TEST_F(FormatTest, FunctionAnnotations) { 5258 verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n" 5259 "int OldFunction(const string ¶meter) {}"); 5260 verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n" 5261 "string OldFunction(const string ¶meter) {}"); 5262 verifyFormat("template <typename T>\n" 5263 "DEPRECATED(\"Use NewClass::NewFunction instead.\")\n" 5264 "string OldFunction(const string ¶meter) {}"); 5265 5266 // Not function annotations. 5267 verifyFormat("ASSERT(\"aaaaa\") << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5268 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"); 5269 verifyFormat("TEST_F(ThisIsATestFixtureeeeeeeeeeeee,\n" 5270 " ThisIsATestWithAReallyReallyReallyReallyLongName) {}"); 5271 verifyFormat("MACRO(abc).function() // wrap\n" 5272 " << abc;"); 5273 verifyFormat("MACRO(abc)->function() // wrap\n" 5274 " << abc;"); 5275 verifyFormat("MACRO(abc)::function() // wrap\n" 5276 " << abc;"); 5277 } 5278 5279 TEST_F(FormatTest, BreaksDesireably) { 5280 verifyFormat("if (aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n" 5281 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n" 5282 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa)) {\n}"); 5283 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5284 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n" 5285 "}"); 5286 5287 verifyFormat( 5288 "aaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5289 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); 5290 5291 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5292 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5293 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 5294 5295 verifyFormat( 5296 "aaaaaaaa(aaaaaaaaaaaaa,\n" 5297 " aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5298 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n" 5299 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5300 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));"); 5301 5302 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 5303 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5304 5305 verifyFormat( 5306 "void f() {\n" 5307 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&\n" 5308 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 5309 "}"); 5310 verifyFormat( 5311 "aaaaaa(new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5312 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 5313 verifyFormat( 5314 "aaaaaa(aaa, new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5315 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 5316 verifyFormat( 5317 "aaaaaa(aaa,\n" 5318 " new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5319 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5320 " aaaa);"); 5321 verifyFormat("aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5322 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5323 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5324 5325 // Indent consistently independent of call expression and unary operator. 5326 verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 5327 " dddddddddddddddddddddddddddddd));"); 5328 verifyFormat("aaaaaaaaaaa(!bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 5329 " dddddddddddddddddddddddddddddd));"); 5330 verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbb.ccccccccccccccccc(\n" 5331 " dddddddddddddddddddddddddddddd));"); 5332 5333 // This test case breaks on an incorrect memoization, i.e. an optimization not 5334 // taking into account the StopAt value. 5335 verifyFormat( 5336 "return aaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 5337 " aaaaaaaaaaa(aaaaaaaaa) || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 5338 " aaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 5339 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5340 5341 verifyFormat("{\n {\n {\n" 5342 " Annotation.SpaceRequiredBefore =\n" 5343 " Line.Tokens[i - 1].Tok.isNot(tok::l_paren) &&\n" 5344 " Line.Tokens[i - 1].Tok.isNot(tok::l_square);\n" 5345 " }\n }\n}"); 5346 5347 // Break on an outer level if there was a break on an inner level. 5348 EXPECT_EQ("f(g(h(a, // comment\n" 5349 " b, c),\n" 5350 " d, e),\n" 5351 " x, y);", 5352 format("f(g(h(a, // comment\n" 5353 " b, c), d, e), x, y);")); 5354 5355 // Prefer breaking similar line breaks. 5356 verifyFormat( 5357 "const int kTrackingOptions = NSTrackingMouseMoved |\n" 5358 " NSTrackingMouseEnteredAndExited |\n" 5359 " NSTrackingActiveAlways;"); 5360 } 5361 5362 TEST_F(FormatTest, FormatsDeclarationsOnePerLine) { 5363 FormatStyle NoBinPacking = getGoogleStyle(); 5364 NoBinPacking.BinPackParameters = false; 5365 NoBinPacking.BinPackArguments = true; 5366 verifyFormat("void f() {\n" 5367 " f(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa,\n" 5368 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 5369 "}", 5370 NoBinPacking); 5371 verifyFormat("void f(int aaaaaaaaaaaaaaaaaaaa,\n" 5372 " int aaaaaaaaaaaaaaaaaaaa,\n" 5373 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 5374 NoBinPacking); 5375 5376 NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false; 5377 verifyFormat("void aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5378 " vector<int> bbbbbbbbbbbbbbb);", 5379 NoBinPacking); 5380 // FIXME: This behavior difference is probably not wanted. However, currently 5381 // we cannot distinguish BreakBeforeParameter being set because of the wrapped 5382 // template arguments from BreakBeforeParameter being set because of the 5383 // one-per-line formatting. 5384 verifyFormat( 5385 "void fffffffffff(aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa,\n" 5386 " aaaaaaaaaa> aaaaaaaaaa);", 5387 NoBinPacking); 5388 verifyFormat( 5389 "void fffffffffff(\n" 5390 " aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaa>\n" 5391 " aaaaaaaaaa);"); 5392 } 5393 5394 TEST_F(FormatTest, FormatsOneParameterPerLineIfNecessary) { 5395 FormatStyle NoBinPacking = getGoogleStyle(); 5396 NoBinPacking.BinPackParameters = false; 5397 NoBinPacking.BinPackArguments = false; 5398 verifyFormat("f(aaaaaaaaaaaaaaaaaaaa,\n" 5399 " aaaaaaaaaaaaaaaaaaaa,\n" 5400 " aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaa);", 5401 NoBinPacking); 5402 verifyFormat("aaaaaaa(aaaaaaaaaaaaa,\n" 5403 " aaaaaaaaaaaaa,\n" 5404 " aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));", 5405 NoBinPacking); 5406 verifyFormat( 5407 "aaaaaaaa(aaaaaaaaaaaaa,\n" 5408 " aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5409 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n" 5410 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5411 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));", 5412 NoBinPacking); 5413 verifyFormat("aaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n" 5414 " .aaaaaaaaaaaaaaaaaa();", 5415 NoBinPacking); 5416 verifyFormat("void f() {\n" 5417 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5418 " aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaa);\n" 5419 "}", 5420 NoBinPacking); 5421 5422 verifyFormat( 5423 "aaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5424 " aaaaaaaaaaaa,\n" 5425 " aaaaaaaaaaaa);", 5426 NoBinPacking); 5427 verifyFormat( 5428 "somefunction(someotherFunction(ddddddddddddddddddddddddddddddddddd,\n" 5429 " ddddddddddddddddddddddddddddd),\n" 5430 " test);", 5431 NoBinPacking); 5432 5433 verifyFormat("std::vector<aaaaaaaaaaaaaaaaaaaaaaa,\n" 5434 " aaaaaaaaaaaaaaaaaaaaaaa,\n" 5435 " aaaaaaaaaaaaaaaaaaaaaaa>\n" 5436 " aaaaaaaaaaaaaaaaaa;", 5437 NoBinPacking); 5438 verifyFormat("a(\"a\"\n" 5439 " \"a\",\n" 5440 " a);"); 5441 5442 NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false; 5443 verifyFormat("void aaaaaaaaaa(aaaaaaaaa,\n" 5444 " aaaaaaaaa,\n" 5445 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5446 NoBinPacking); 5447 verifyFormat( 5448 "void f() {\n" 5449 " aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n" 5450 " .aaaaaaa();\n" 5451 "}", 5452 NoBinPacking); 5453 verifyFormat( 5454 "template <class SomeType, class SomeOtherType>\n" 5455 "SomeType SomeFunction(SomeType Type, SomeOtherType OtherType) {}", 5456 NoBinPacking); 5457 } 5458 5459 TEST_F(FormatTest, AdaptiveOnePerLineFormatting) { 5460 FormatStyle Style = getLLVMStyleWithColumns(15); 5461 Style.ExperimentalAutoDetectBinPacking = true; 5462 EXPECT_EQ("aaa(aaaa,\n" 5463 " aaaa,\n" 5464 " aaaa);\n" 5465 "aaa(aaaa,\n" 5466 " aaaa,\n" 5467 " aaaa);", 5468 format("aaa(aaaa,\n" // one-per-line 5469 " aaaa,\n" 5470 " aaaa );\n" 5471 "aaa(aaaa, aaaa, aaaa);", // inconclusive 5472 Style)); 5473 EXPECT_EQ("aaa(aaaa, aaaa,\n" 5474 " aaaa);\n" 5475 "aaa(aaaa, aaaa,\n" 5476 " aaaa);", 5477 format("aaa(aaaa, aaaa,\n" // bin-packed 5478 " aaaa );\n" 5479 "aaa(aaaa, aaaa, aaaa);", // inconclusive 5480 Style)); 5481 } 5482 5483 TEST_F(FormatTest, FormatsBuilderPattern) { 5484 verifyFormat("return llvm::StringSwitch<Reference::Kind>(name)\n" 5485 " .StartsWith(\".eh_frame_hdr\", ORDER_EH_FRAMEHDR)\n" 5486 " .StartsWith(\".eh_frame\", ORDER_EH_FRAME)\n" 5487 " .StartsWith(\".init\", ORDER_INIT)\n" 5488 " .StartsWith(\".fini\", ORDER_FINI)\n" 5489 " .StartsWith(\".hash\", ORDER_HASH)\n" 5490 " .Default(ORDER_TEXT);\n"); 5491 5492 verifyFormat("return aaaaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa() <\n" 5493 " aaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa();"); 5494 verifyFormat("aaaaaaa->aaaaaaa\n" 5495 " ->aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5496 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5497 " ->aaaaaaaa(aaaaaaaaaaaaaaa);"); 5498 verifyFormat( 5499 "aaaaaaa->aaaaaaa\n" 5500 " ->aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5501 " ->aaaaaaaa(aaaaaaaaaaaaaaa);"); 5502 verifyFormat( 5503 "aaaaaaaaaaaaaaaaaaa()->aaaaaa(bbbbb)->aaaaaaaaaaaaaaaaaaa( // break\n" 5504 " aaaaaaaaaaaaaa);"); 5505 verifyFormat( 5506 "aaaaaaaaaaaaaaaaaaaaaaa *aaaaaaaaa =\n" 5507 " aaaaaa->aaaaaaaaaaaa()\n" 5508 " ->aaaaaaaaaaaaaaaa(\n" 5509 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5510 " ->aaaaaaaaaaaaaaaaa();"); 5511 verifyGoogleFormat( 5512 "void f() {\n" 5513 " someo->Add((new util::filetools::Handler(dir))\n" 5514 " ->OnEvent1(NewPermanentCallback(\n" 5515 " this, &HandlerHolderClass::EventHandlerCBA))\n" 5516 " ->OnEvent2(NewPermanentCallback(\n" 5517 " this, &HandlerHolderClass::EventHandlerCBB))\n" 5518 " ->OnEvent3(NewPermanentCallback(\n" 5519 " this, &HandlerHolderClass::EventHandlerCBC))\n" 5520 " ->OnEvent5(NewPermanentCallback(\n" 5521 " this, &HandlerHolderClass::EventHandlerCBD))\n" 5522 " ->OnEvent6(NewPermanentCallback(\n" 5523 " this, &HandlerHolderClass::EventHandlerCBE)));\n" 5524 "}"); 5525 5526 verifyFormat( 5527 "aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa();"); 5528 verifyFormat("aaaaaaaaaaaaaaa()\n" 5529 " .aaaaaaaaaaaaaaa()\n" 5530 " .aaaaaaaaaaaaaaa()\n" 5531 " .aaaaaaaaaaaaaaa()\n" 5532 " .aaaaaaaaaaaaaaa();"); 5533 verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n" 5534 " .aaaaaaaaaaaaaaa()\n" 5535 " .aaaaaaaaaaaaaaa()\n" 5536 " .aaaaaaaaaaaaaaa();"); 5537 verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n" 5538 " .aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n" 5539 " .aaaaaaaaaaaaaaa();"); 5540 verifyFormat("aaaaaaaaaaaaa->aaaaaaaaaaaaaaaaaaaaaaaa()\n" 5541 " ->aaaaaaaaaaaaaae(0)\n" 5542 " ->aaaaaaaaaaaaaaa();"); 5543 5544 // Don't linewrap after very short segments. 5545 verifyFormat("a().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5546 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5547 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 5548 verifyFormat("aa().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5549 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5550 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 5551 verifyFormat("aaa()\n" 5552 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5553 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5554 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 5555 5556 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n" 5557 " .aaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5558 " .has<bbbbbbbbbbbbbbbbbbbbb>();"); 5559 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n" 5560 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n" 5561 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>();"); 5562 5563 // Prefer not to break after empty parentheses. 5564 verifyFormat("FirstToken->WhitespaceRange.getBegin().getLocWithOffset(\n" 5565 " First->LastNewlineOffset);"); 5566 5567 // Prefer not to create "hanging" indents. 5568 verifyFormat( 5569 "return !soooooooooooooome_map\n" 5570 " .insert(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5571 " .second;"); 5572 verifyFormat( 5573 "return aaaaaaaaaaaaaaaa\n" 5574 " .aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa)\n" 5575 " .aaaa(aaaaaaaaaaaaaa);"); 5576 // No hanging indent here. 5577 verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa.aaaaaaaaaaaaaaa(\n" 5578 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5579 verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa().aaaaaaaaaaaaaaa(\n" 5580 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5581 verifyFormat("aaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n" 5582 " .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5583 getLLVMStyleWithColumns(60)); 5584 verifyFormat("aaaaaaaaaaaaaaaaaa\n" 5585 " .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n" 5586 " .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5587 getLLVMStyleWithColumns(59)); 5588 verifyFormat("aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5589 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5590 " .aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5591 5592 // Dont break if only closing statements before member call 5593 verifyFormat("test() {\n" 5594 " ([]() -> {\n" 5595 " int b = 32;\n" 5596 " return 3;\n" 5597 " }).foo();\n" 5598 "}"); 5599 verifyFormat("test() {\n" 5600 " (\n" 5601 " []() -> {\n" 5602 " int b = 32;\n" 5603 " return 3;\n" 5604 " },\n" 5605 " foo, bar)\n" 5606 " .foo();\n" 5607 "}"); 5608 verifyFormat("test() {\n" 5609 " ([]() -> {\n" 5610 " int b = 32;\n" 5611 " return 3;\n" 5612 " })\n" 5613 " .foo()\n" 5614 " .bar();\n" 5615 "}"); 5616 verifyFormat("test() {\n" 5617 " ([]() -> {\n" 5618 " int b = 32;\n" 5619 " return 3;\n" 5620 " })\n" 5621 " .foo(\"aaaaaaaaaaaaaaaaa\"\n" 5622 " \"bbbb\");\n" 5623 "}", 5624 getLLVMStyleWithColumns(30)); 5625 } 5626 5627 TEST_F(FormatTest, BreaksAccordingToOperatorPrecedence) { 5628 verifyFormat( 5629 "if (aaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 5630 " bbbbbbbbbbbbbbbbbbbbbbbbb && ccccccccccccccccccccccccc) {\n}"); 5631 verifyFormat( 5632 "if (aaaaaaaaaaaaaaaaaaaaaaaaa or\n" 5633 " bbbbbbbbbbbbbbbbbbbbbbbbb and cccccccccccccccccccccccc) {\n}"); 5634 5635 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa && bbbbbbbbbbbbbbbbbbbbbbbbb ||\n" 5636 " ccccccccccccccccccccccccc) {\n}"); 5637 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa and bbbbbbbbbbbbbbbbbbbbbbbb or\n" 5638 " ccccccccccccccccccccccccc) {\n}"); 5639 5640 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb ||\n" 5641 " ccccccccccccccccccccccccc) {\n}"); 5642 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb or\n" 5643 " ccccccccccccccccccccccccc) {\n}"); 5644 5645 verifyFormat( 5646 "if ((aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb) &&\n" 5647 " ccccccccccccccccccccccccc) {\n}"); 5648 verifyFormat( 5649 "if ((aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb) and\n" 5650 " ccccccccccccccccccccccccc) {\n}"); 5651 5652 verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA ||\n" 5653 " bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB ||\n" 5654 " cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC ||\n" 5655 " dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;"); 5656 verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA or\n" 5657 " bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB or\n" 5658 " cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC or\n" 5659 " dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;"); 5660 5661 verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa ||\n" 5662 " aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) &&\n" 5663 " aaaaaaaaaaaaaaa != aa) {\n}"); 5664 verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa or\n" 5665 " aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) and\n" 5666 " aaaaaaaaaaaaaaa != aa) {\n}"); 5667 } 5668 5669 TEST_F(FormatTest, BreaksAfterAssignments) { 5670 verifyFormat( 5671 "unsigned Cost =\n" 5672 " TTI.getMemoryOpCost(I->getOpcode(), VectorTy, SI->getAlignment(),\n" 5673 " SI->getPointerAddressSpaceee());\n"); 5674 verifyFormat( 5675 "CharSourceRange LineRange = CharSourceRange::getTokenRange(\n" 5676 " Line.Tokens.front().Tok.getLo(), Line.Tokens.back().Tok.getLoc());"); 5677 5678 verifyFormat( 5679 "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa = aaaaaaaaaaaaaa(0).aaaa().aaaaaaaaa(\n" 5680 " aaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaa);"); 5681 verifyFormat("unsigned OriginalStartColumn =\n" 5682 " SourceMgr.getSpellingColumnNumber(\n" 5683 " Current.FormatTok.getStartOfNonWhitespace()) -\n" 5684 " 1;"); 5685 } 5686 5687 TEST_F(FormatTest, ConfigurableBreakAssignmentPenalty) { 5688 FormatStyle Style = getLLVMStyle(); 5689 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 5690 " bbbbbbbbbbbbbbbbbbbbbbbbbb + cccccccccccccccccccccccccc;", 5691 Style); 5692 5693 Style.PenaltyBreakAssignment = 20; 5694 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa = bbbbbbbbbbbbbbbbbbbbbbbbbb +\n" 5695 " cccccccccccccccccccccccccc;", 5696 Style); 5697 } 5698 5699 TEST_F(FormatTest, AlignsAfterAssignments) { 5700 verifyFormat( 5701 "int Result = aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5702 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5703 verifyFormat( 5704 "Result += aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5705 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5706 verifyFormat( 5707 "Result >>= aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5708 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5709 verifyFormat( 5710 "int Result = (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5711 " aaaaaaaaaaaaaaaaaaaaaaaaa);"); 5712 verifyFormat( 5713 "double LooooooooooooooooooooooooongResult = aaaaaaaaaaaaaaaaaaaaaaaa +\n" 5714 " aaaaaaaaaaaaaaaaaaaaaaaa +\n" 5715 " aaaaaaaaaaaaaaaaaaaaaaaa;"); 5716 } 5717 5718 TEST_F(FormatTest, AlignsAfterReturn) { 5719 verifyFormat( 5720 "return aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5721 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5722 verifyFormat( 5723 "return (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5724 " aaaaaaaaaaaaaaaaaaaaaaaaa);"); 5725 verifyFormat( 5726 "return aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n" 5727 " aaaaaaaaaaaaaaaaaaaaaa();"); 5728 verifyFormat( 5729 "return (aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n" 5730 " aaaaaaaaaaaaaaaaaaaaaa());"); 5731 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5732 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5733 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5734 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) &&\n" 5735 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5736 verifyFormat("return\n" 5737 " // true if code is one of a or b.\n" 5738 " code == a || code == b;"); 5739 } 5740 5741 TEST_F(FormatTest, AlignsAfterOpenBracket) { 5742 verifyFormat( 5743 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n" 5744 " aaaaaaaaa aaaaaaa) {}"); 5745 verifyFormat( 5746 "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n" 5747 " aaaaaaaaaaa aaaaaaaaa);"); 5748 verifyFormat( 5749 "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n" 5750 " aaaaaaaaaaaaaaaaaaaaa));"); 5751 FormatStyle Style = getLLVMStyle(); 5752 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 5753 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5754 " aaaaaaaaaaa aaaaaaaa, aaaaaaaaa aaaaaaa) {}", 5755 Style); 5756 verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n" 5757 " aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaa aaaaaaaaa);", 5758 Style); 5759 verifyFormat("SomeLongVariableName->someFunction(\n" 5760 " foooooooo(aaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa));", 5761 Style); 5762 verifyFormat( 5763 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n" 5764 " aaaaaaaaa aaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 5765 Style); 5766 verifyFormat( 5767 "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n" 5768 " aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5769 Style); 5770 verifyFormat( 5771 "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n" 5772 " aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));", 5773 Style); 5774 5775 verifyFormat("bbbbbbbbbbbb(aaaaaaaaaaaaaaaaaaaaaaaa, //\n" 5776 " ccccccc(aaaaaaaaaaaaaaaaa, //\n" 5777 " b));", 5778 Style); 5779 5780 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 5781 Style.BinPackArguments = false; 5782 Style.BinPackParameters = false; 5783 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5784 " aaaaaaaaaaa aaaaaaaa,\n" 5785 " aaaaaaaaa aaaaaaa,\n" 5786 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 5787 Style); 5788 verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n" 5789 " aaaaaaaaaaa aaaaaaaaa,\n" 5790 " aaaaaaaaaaa aaaaaaaaa,\n" 5791 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5792 Style); 5793 verifyFormat("SomeLongVariableName->someFunction(foooooooo(\n" 5794 " aaaaaaaaaaaaaaa,\n" 5795 " aaaaaaaaaaaaaaaaaaaaa,\n" 5796 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));", 5797 Style); 5798 verifyFormat( 5799 "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa(\n" 5800 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));", 5801 Style); 5802 verifyFormat( 5803 "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaa.aaaaaaaaaa(\n" 5804 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));", 5805 Style); 5806 verifyFormat( 5807 "aaaaaaaaaaaaaaaaaaaaaaaa(\n" 5808 " aaaaaaaaaaaaaaaaaaaaa(\n" 5809 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)),\n" 5810 " aaaaaaaaaaaaaaaa);", 5811 Style); 5812 verifyFormat( 5813 "aaaaaaaaaaaaaaaaaaaaaaaa(\n" 5814 " aaaaaaaaaaaaaaaaaaaaa(\n" 5815 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)) &&\n" 5816 " aaaaaaaaaaaaaaaa);", 5817 Style); 5818 } 5819 5820 TEST_F(FormatTest, ParenthesesAndOperandAlignment) { 5821 FormatStyle Style = getLLVMStyleWithColumns(40); 5822 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5823 " bbbbbbbbbbbbbbbbbbbbbb);", 5824 Style); 5825 Style.AlignAfterOpenBracket = FormatStyle::BAS_Align; 5826 Style.AlignOperands = false; 5827 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5828 " bbbbbbbbbbbbbbbbbbbbbb);", 5829 Style); 5830 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 5831 Style.AlignOperands = true; 5832 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5833 " bbbbbbbbbbbbbbbbbbbbbb);", 5834 Style); 5835 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 5836 Style.AlignOperands = false; 5837 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5838 " bbbbbbbbbbbbbbbbbbbbbb);", 5839 Style); 5840 } 5841 5842 TEST_F(FormatTest, BreaksConditionalExpressions) { 5843 verifyFormat( 5844 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5845 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5846 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5847 verifyFormat( 5848 "aaaa(aaaaaaaaaa, aaaaaaaa,\n" 5849 " aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5850 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5851 verifyFormat( 5852 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5853 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5854 verifyFormat("aaaa(aaaaaaaaa, aaaaaaaaa,\n" 5855 " aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5856 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5857 verifyFormat( 5858 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa)\n" 5859 " : aaaaaaaaaaaaa);"); 5860 verifyFormat( 5861 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5862 " aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5863 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5864 " aaaaaaaaaaaaa);"); 5865 verifyFormat( 5866 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5867 " aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5868 " aaaaaaaaaaaaa);"); 5869 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5870 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5871 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5872 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5873 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5874 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5875 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5876 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5877 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5878 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5879 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5880 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5881 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5882 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5883 " ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5884 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5885 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5886 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5887 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5888 " : aaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5889 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n" 5890 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5891 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5892 " : aaaaaaaaaaaaaaaa;"); 5893 verifyFormat( 5894 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5895 " ? aaaaaaaaaaaaaaa\n" 5896 " : aaaaaaaaaaaaaaa;"); 5897 verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n" 5898 " aaaaaaaaa\n" 5899 " ? b\n" 5900 " : c);"); 5901 verifyFormat("return aaaa == bbbb\n" 5902 " // comment\n" 5903 " ? aaaa\n" 5904 " : bbbb;"); 5905 verifyFormat("unsigned Indent =\n" 5906 " format(TheLine.First,\n" 5907 " IndentForLevel[TheLine.Level] >= 0\n" 5908 " ? IndentForLevel[TheLine.Level]\n" 5909 " : TheLine * 2,\n" 5910 " TheLine.InPPDirective, PreviousEndOfLineColumn);", 5911 getLLVMStyleWithColumns(60)); 5912 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n" 5913 " ? aaaaaaaaaaaaaaa\n" 5914 " : bbbbbbbbbbbbbbb //\n" 5915 " ? ccccccccccccccc\n" 5916 " : ddddddddddddddd;"); 5917 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n" 5918 " ? aaaaaaaaaaaaaaa\n" 5919 " : (bbbbbbbbbbbbbbb //\n" 5920 " ? ccccccccccccccc\n" 5921 " : ddddddddddddddd);"); 5922 verifyFormat( 5923 "int aaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5924 " ? aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5925 " aaaaaaaaaaaaaaaaaaaaa +\n" 5926 " aaaaaaaaaaaaaaaaaaaaa\n" 5927 " : aaaaaaaaaa;"); 5928 verifyFormat( 5929 "aaaaaa = aaaaaaaaaaaa ? aaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5930 " : aaaaaaaaaaaaaaaaaaaaaa\n" 5931 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5932 5933 FormatStyle NoBinPacking = getLLVMStyle(); 5934 NoBinPacking.BinPackArguments = false; 5935 verifyFormat( 5936 "void f() {\n" 5937 " g(aaa,\n" 5938 " aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n" 5939 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5940 " ? aaaaaaaaaaaaaaa\n" 5941 " : aaaaaaaaaaaaaaa);\n" 5942 "}", 5943 NoBinPacking); 5944 verifyFormat( 5945 "void f() {\n" 5946 " g(aaa,\n" 5947 " aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n" 5948 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5949 " ?: aaaaaaaaaaaaaaa);\n" 5950 "}", 5951 NoBinPacking); 5952 5953 verifyFormat("SomeFunction(aaaaaaaaaaaaaaaaa,\n" 5954 " // comment.\n" 5955 " ccccccccccccccccccccccccccccccccccccccc\n" 5956 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5957 " : bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);"); 5958 5959 // Assignments in conditional expressions. Apparently not uncommon :-(. 5960 verifyFormat("return a != b\n" 5961 " // comment\n" 5962 " ? a = b\n" 5963 " : a = b;"); 5964 verifyFormat("return a != b\n" 5965 " // comment\n" 5966 " ? a = a != b\n" 5967 " // comment\n" 5968 " ? a = b\n" 5969 " : a\n" 5970 " : a;\n"); 5971 verifyFormat("return a != b\n" 5972 " // comment\n" 5973 " ? a\n" 5974 " : a = a != b\n" 5975 " // comment\n" 5976 " ? a = b\n" 5977 " : a;"); 5978 } 5979 5980 TEST_F(FormatTest, BreaksConditionalExpressionsAfterOperator) { 5981 FormatStyle Style = getLLVMStyle(); 5982 Style.BreakBeforeTernaryOperators = false; 5983 Style.ColumnLimit = 70; 5984 verifyFormat( 5985 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5986 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5987 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5988 Style); 5989 verifyFormat( 5990 "aaaa(aaaaaaaaaa, aaaaaaaa,\n" 5991 " aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5992 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5993 Style); 5994 verifyFormat( 5995 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5996 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5997 Style); 5998 verifyFormat("aaaa(aaaaaaaa, aaaaaaaaaa,\n" 5999 " aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 6000 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 6001 Style); 6002 verifyFormat( 6003 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa) :\n" 6004 " aaaaaaaaaaaaa);", 6005 Style); 6006 verifyFormat( 6007 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6008 " aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 6009 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6010 " aaaaaaaaaaaaa);", 6011 Style); 6012 verifyFormat( 6013 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6014 " aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6015 " aaaaaaaaaaaaa);", 6016 Style); 6017 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 6018 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6019 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n" 6020 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6021 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 6022 Style); 6023 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6024 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 6025 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6026 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n" 6027 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6028 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 6029 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);", 6030 Style); 6031 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6032 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?:\n" 6033 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6034 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 6035 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);", 6036 Style); 6037 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 6038 " aaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 6039 " aaaaaaaaaaaaaaaaaaaaaaaaaaa;", 6040 Style); 6041 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n" 6042 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 6043 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 6044 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 6045 Style); 6046 verifyFormat( 6047 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 6048 " aaaaaaaaaaaaaaa :\n" 6049 " aaaaaaaaaaaaaaa;", 6050 Style); 6051 verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n" 6052 " aaaaaaaaa ?\n" 6053 " b :\n" 6054 " c);", 6055 Style); 6056 verifyFormat("unsigned Indent =\n" 6057 " format(TheLine.First,\n" 6058 " IndentForLevel[TheLine.Level] >= 0 ?\n" 6059 " IndentForLevel[TheLine.Level] :\n" 6060 " TheLine * 2,\n" 6061 " TheLine.InPPDirective, PreviousEndOfLineColumn);", 6062 Style); 6063 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n" 6064 " aaaaaaaaaaaaaaa :\n" 6065 " bbbbbbbbbbbbbbb ? //\n" 6066 " ccccccccccccccc :\n" 6067 " ddddddddddddddd;", 6068 Style); 6069 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n" 6070 " aaaaaaaaaaaaaaa :\n" 6071 " (bbbbbbbbbbbbbbb ? //\n" 6072 " ccccccccccccccc :\n" 6073 " ddddddddddddddd);", 6074 Style); 6075 verifyFormat("int i = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 6076 " /*bbbbbbbbbbbbbbb=*/bbbbbbbbbbbbbbbbbbbbbbbbb :\n" 6077 " ccccccccccccccccccccccccccc;", 6078 Style); 6079 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 6080 " aaaaa :\n" 6081 " bbbbbbbbbbbbbbb + cccccccccccccccc;", 6082 Style); 6083 } 6084 6085 TEST_F(FormatTest, DeclarationsOfMultipleVariables) { 6086 verifyFormat("bool aaaaaaaaaaaaaaaaa = aaaaaa->aaaaaaaaaaaaaaaaa(),\n" 6087 " aaaaaaaaaaa = aaaaaa->aaaaaaaaaaa();"); 6088 verifyFormat("bool a = true, b = false;"); 6089 6090 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaa =\n" 6091 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa),\n" 6092 " bbbbbbbbbbbbbbbbbbbbbbbbb =\n" 6093 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(bbbbbbbbbbbbbbbb);"); 6094 verifyFormat( 6095 "bool aaaaaaaaaaaaaaaaaaaaa =\n" 6096 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb && cccccccccccccccccccccccccccc,\n" 6097 " d = e && f;"); 6098 verifyFormat("aaaaaaaaa a = aaaaaaaaaaaaaaaaaaaa, b = bbbbbbbbbbbbbbbbbbbb,\n" 6099 " c = cccccccccccccccccccc, d = dddddddddddddddddddd;"); 6100 verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n" 6101 " *c = ccccccccccccccccccc, *d = ddddddddddddddddddd;"); 6102 verifyFormat("aaaaaaaaa ***a = aaaaaaaaaaaaaaaaaaa, ***b = bbbbbbbbbbbbbbb,\n" 6103 " ***c = ccccccccccccccccccc, ***d = ddddddddddddddd;"); 6104 6105 FormatStyle Style = getGoogleStyle(); 6106 Style.PointerAlignment = FormatStyle::PAS_Left; 6107 Style.DerivePointerAlignment = false; 6108 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6109 " *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaa,\n" 6110 " *b = bbbbbbbbbbbbbbbbbbb;", 6111 Style); 6112 verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n" 6113 " *b = bbbbbbbbbbbbbbbbbbb, *d = ddddddddddddddddddd;", 6114 Style); 6115 verifyFormat("vector<int*> a, b;", Style); 6116 verifyFormat("for (int *p, *q; p != q; p = p->next) {\n}", Style); 6117 } 6118 6119 TEST_F(FormatTest, ConditionalExpressionsInBrackets) { 6120 verifyFormat("arr[foo ? bar : baz];"); 6121 verifyFormat("f()[foo ? bar : baz];"); 6122 verifyFormat("(a + b)[foo ? bar : baz];"); 6123 verifyFormat("arr[foo ? (4 > 5 ? 4 : 5) : 5 < 5 ? 5 : 7];"); 6124 } 6125 6126 TEST_F(FormatTest, AlignsStringLiterals) { 6127 verifyFormat("loooooooooooooooooooooooooongFunction(\"short literal \"\n" 6128 " \"short literal\");"); 6129 verifyFormat( 6130 "looooooooooooooooooooooooongFunction(\n" 6131 " \"short literal\"\n" 6132 " \"looooooooooooooooooooooooooooooooooooooooooooooooong literal\");"); 6133 verifyFormat("someFunction(\"Always break between multi-line\"\n" 6134 " \" string literals\",\n" 6135 " and, other, parameters);"); 6136 EXPECT_EQ("fun + \"1243\" /* comment */\n" 6137 " \"5678\";", 6138 format("fun + \"1243\" /* comment */\n" 6139 " \"5678\";", 6140 getLLVMStyleWithColumns(28))); 6141 EXPECT_EQ( 6142 "aaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 6143 " \"aaaaaaaaaaaaaaaaaaaaa\"\n" 6144 " \"aaaaaaaaaaaaaaaa\";", 6145 format("aaaaaa =" 6146 "\"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa " 6147 "aaaaaaaaaaaaaaaaaaaaa\" " 6148 "\"aaaaaaaaaaaaaaaa\";")); 6149 verifyFormat("a = a + \"a\"\n" 6150 " \"a\"\n" 6151 " \"a\";"); 6152 verifyFormat("f(\"a\", \"b\"\n" 6153 " \"c\");"); 6154 6155 verifyFormat( 6156 "#define LL_FORMAT \"ll\"\n" 6157 "printf(\"aaaaa: %d, bbbbbb: %\" LL_FORMAT \"d, cccccccc: %\" LL_FORMAT\n" 6158 " \"d, ddddddddd: %\" LL_FORMAT \"d\");"); 6159 6160 verifyFormat("#define A(X) \\\n" 6161 " \"aaaaa\" #X \"bbbbbb\" \\\n" 6162 " \"ccccc\"", 6163 getLLVMStyleWithColumns(23)); 6164 verifyFormat("#define A \"def\"\n" 6165 "f(\"abc\" A \"ghi\"\n" 6166 " \"jkl\");"); 6167 6168 verifyFormat("f(L\"a\"\n" 6169 " L\"b\");"); 6170 verifyFormat("#define A(X) \\\n" 6171 " L\"aaaaa\" #X L\"bbbbbb\" \\\n" 6172 " L\"ccccc\"", 6173 getLLVMStyleWithColumns(25)); 6174 6175 verifyFormat("f(@\"a\"\n" 6176 " @\"b\");"); 6177 verifyFormat("NSString s = @\"a\"\n" 6178 " @\"b\"\n" 6179 " @\"c\";"); 6180 verifyFormat("NSString s = @\"a\"\n" 6181 " \"b\"\n" 6182 " \"c\";"); 6183 } 6184 6185 TEST_F(FormatTest, ReturnTypeBreakingStyle) { 6186 FormatStyle Style = getLLVMStyle(); 6187 // No declarations or definitions should be moved to own line. 6188 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_None; 6189 verifyFormat("class A {\n" 6190 " int f() { return 1; }\n" 6191 " int g();\n" 6192 "};\n" 6193 "int f() { return 1; }\n" 6194 "int g();\n", 6195 Style); 6196 6197 // All declarations and definitions should have the return type moved to its 6198 // own 6199 // line. 6200 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All; 6201 verifyFormat("class E {\n" 6202 " int\n" 6203 " f() {\n" 6204 " return 1;\n" 6205 " }\n" 6206 " int\n" 6207 " g();\n" 6208 "};\n" 6209 "int\n" 6210 "f() {\n" 6211 " return 1;\n" 6212 "}\n" 6213 "int\n" 6214 "g();\n", 6215 Style); 6216 6217 // Top-level definitions, and no kinds of declarations should have the 6218 // return type moved to its own line. 6219 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevelDefinitions; 6220 verifyFormat("class B {\n" 6221 " int f() { return 1; }\n" 6222 " int g();\n" 6223 "};\n" 6224 "int\n" 6225 "f() {\n" 6226 " return 1;\n" 6227 "}\n" 6228 "int g();\n", 6229 Style); 6230 6231 // Top-level definitions and declarations should have the return type moved 6232 // to its own line. 6233 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevel; 6234 verifyFormat("class C {\n" 6235 " int f() { return 1; }\n" 6236 " int g();\n" 6237 "};\n" 6238 "int\n" 6239 "f() {\n" 6240 " return 1;\n" 6241 "}\n" 6242 "int\n" 6243 "g();\n", 6244 Style); 6245 6246 // All definitions should have the return type moved to its own line, but no 6247 // kinds of declarations. 6248 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions; 6249 verifyFormat("class D {\n" 6250 " int\n" 6251 " f() {\n" 6252 " return 1;\n" 6253 " }\n" 6254 " int g();\n" 6255 "};\n" 6256 "int\n" 6257 "f() {\n" 6258 " return 1;\n" 6259 "}\n" 6260 "int g();\n", 6261 Style); 6262 verifyFormat("const char *\n" 6263 "f(void) {\n" // Break here. 6264 " return \"\";\n" 6265 "}\n" 6266 "const char *bar(void);\n", // No break here. 6267 Style); 6268 verifyFormat("template <class T>\n" 6269 "T *\n" 6270 "f(T &c) {\n" // Break here. 6271 " return NULL;\n" 6272 "}\n" 6273 "template <class T> T *f(T &c);\n", // No break here. 6274 Style); 6275 verifyFormat("class C {\n" 6276 " int\n" 6277 " operator+() {\n" 6278 " return 1;\n" 6279 " }\n" 6280 " int\n" 6281 " operator()() {\n" 6282 " return 1;\n" 6283 " }\n" 6284 "};\n", 6285 Style); 6286 verifyFormat("void\n" 6287 "A::operator()() {}\n" 6288 "void\n" 6289 "A::operator>>() {}\n" 6290 "void\n" 6291 "A::operator+() {}\n" 6292 "void\n" 6293 "A::operator*() {}\n" 6294 "void\n" 6295 "A::operator->() {}\n" 6296 "void\n" 6297 "A::operator void *() {}\n" 6298 "void\n" 6299 "A::operator void &() {}\n" 6300 "void\n" 6301 "A::operator void &&() {}\n" 6302 "void\n" 6303 "A::operator char *() {}\n" 6304 "void\n" 6305 "A::operator[]() {}\n" 6306 "void\n" 6307 "A::operator!() {}\n" 6308 "void\n" 6309 "A::operator**() {}\n" 6310 "void\n" 6311 "A::operator<Foo> *() {}\n" 6312 "void\n" 6313 "A::operator<Foo> **() {}\n" 6314 "void\n" 6315 "A::operator<Foo> &() {}\n" 6316 "void\n" 6317 "A::operator void **() {}\n", 6318 Style); 6319 verifyFormat("constexpr auto\n" 6320 "operator()() const -> reference {}\n" 6321 "constexpr auto\n" 6322 "operator>>() const -> reference {}\n" 6323 "constexpr auto\n" 6324 "operator+() const -> reference {}\n" 6325 "constexpr auto\n" 6326 "operator*() const -> reference {}\n" 6327 "constexpr auto\n" 6328 "operator->() const -> reference {}\n" 6329 "constexpr auto\n" 6330 "operator++() const -> reference {}\n" 6331 "constexpr auto\n" 6332 "operator void *() const -> reference {}\n" 6333 "constexpr auto\n" 6334 "operator void **() const -> reference {}\n" 6335 "constexpr auto\n" 6336 "operator void *() const -> reference {}\n" 6337 "constexpr auto\n" 6338 "operator void &() const -> reference {}\n" 6339 "constexpr auto\n" 6340 "operator void &&() const -> reference {}\n" 6341 "constexpr auto\n" 6342 "operator char *() const -> reference {}\n" 6343 "constexpr auto\n" 6344 "operator!() const -> reference {}\n" 6345 "constexpr auto\n" 6346 "operator[]() const -> reference {}\n", 6347 Style); 6348 verifyFormat("void *operator new(std::size_t s);", // No break here. 6349 Style); 6350 verifyFormat("void *\n" 6351 "operator new(std::size_t s) {}", 6352 Style); 6353 verifyFormat("void *\n" 6354 "operator delete[](void *ptr) {}", 6355 Style); 6356 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 6357 verifyFormat("const char *\n" 6358 "f(void)\n" // Break here. 6359 "{\n" 6360 " return \"\";\n" 6361 "}\n" 6362 "const char *bar(void);\n", // No break here. 6363 Style); 6364 verifyFormat("template <class T>\n" 6365 "T *\n" // Problem here: no line break 6366 "f(T &c)\n" // Break here. 6367 "{\n" 6368 " return NULL;\n" 6369 "}\n" 6370 "template <class T> T *f(T &c);\n", // No break here. 6371 Style); 6372 verifyFormat("int\n" 6373 "foo(A<bool> a)\n" 6374 "{\n" 6375 " return a;\n" 6376 "}\n", 6377 Style); 6378 verifyFormat("int\n" 6379 "foo(A<8> a)\n" 6380 "{\n" 6381 " return a;\n" 6382 "}\n", 6383 Style); 6384 verifyFormat("int\n" 6385 "foo(A<B<bool>, 8> a)\n" 6386 "{\n" 6387 " return a;\n" 6388 "}\n", 6389 Style); 6390 verifyFormat("int\n" 6391 "foo(A<B<8>, bool> a)\n" 6392 "{\n" 6393 " return a;\n" 6394 "}\n", 6395 Style); 6396 verifyFormat("int\n" 6397 "foo(A<B<bool>, bool> a)\n" 6398 "{\n" 6399 " return a;\n" 6400 "}\n", 6401 Style); 6402 verifyFormat("int\n" 6403 "foo(A<B<8>, 8> a)\n" 6404 "{\n" 6405 " return a;\n" 6406 "}\n", 6407 Style); 6408 6409 Style = getGNUStyle(); 6410 6411 // Test for comments at the end of function declarations. 6412 verifyFormat("void\n" 6413 "foo (int a, /*abc*/ int b) // def\n" 6414 "{\n" 6415 "}\n", 6416 Style); 6417 6418 verifyFormat("void\n" 6419 "foo (int a, /* abc */ int b) /* def */\n" 6420 "{\n" 6421 "}\n", 6422 Style); 6423 6424 // Definitions that should not break after return type 6425 verifyFormat("void foo (int a, int b); // def\n", Style); 6426 verifyFormat("void foo (int a, int b); /* def */\n", Style); 6427 verifyFormat("void foo (int a, int b);\n", Style); 6428 } 6429 6430 TEST_F(FormatTest, AlwaysBreakBeforeMultilineStrings) { 6431 FormatStyle NoBreak = getLLVMStyle(); 6432 NoBreak.AlwaysBreakBeforeMultilineStrings = false; 6433 FormatStyle Break = getLLVMStyle(); 6434 Break.AlwaysBreakBeforeMultilineStrings = true; 6435 verifyFormat("aaaa = \"bbbb\"\n" 6436 " \"cccc\";", 6437 NoBreak); 6438 verifyFormat("aaaa =\n" 6439 " \"bbbb\"\n" 6440 " \"cccc\";", 6441 Break); 6442 verifyFormat("aaaa(\"bbbb\"\n" 6443 " \"cccc\");", 6444 NoBreak); 6445 verifyFormat("aaaa(\n" 6446 " \"bbbb\"\n" 6447 " \"cccc\");", 6448 Break); 6449 verifyFormat("aaaa(qqq, \"bbbb\"\n" 6450 " \"cccc\");", 6451 NoBreak); 6452 verifyFormat("aaaa(qqq,\n" 6453 " \"bbbb\"\n" 6454 " \"cccc\");", 6455 Break); 6456 verifyFormat("aaaa(qqq,\n" 6457 " L\"bbbb\"\n" 6458 " L\"cccc\");", 6459 Break); 6460 verifyFormat("aaaaa(aaaaaa, aaaaaaa(\"aaaa\"\n" 6461 " \"bbbb\"));", 6462 Break); 6463 verifyFormat("string s = someFunction(\n" 6464 " \"abc\"\n" 6465 " \"abc\");", 6466 Break); 6467 6468 // As we break before unary operators, breaking right after them is bad. 6469 verifyFormat("string foo = abc ? \"x\"\n" 6470 " \"blah blah blah blah blah blah\"\n" 6471 " : \"y\";", 6472 Break); 6473 6474 // Don't break if there is no column gain. 6475 verifyFormat("f(\"aaaa\"\n" 6476 " \"bbbb\");", 6477 Break); 6478 6479 // Treat literals with escaped newlines like multi-line string literals. 6480 EXPECT_EQ("x = \"a\\\n" 6481 "b\\\n" 6482 "c\";", 6483 format("x = \"a\\\n" 6484 "b\\\n" 6485 "c\";", 6486 NoBreak)); 6487 EXPECT_EQ("xxxx =\n" 6488 " \"a\\\n" 6489 "b\\\n" 6490 "c\";", 6491 format("xxxx = \"a\\\n" 6492 "b\\\n" 6493 "c\";", 6494 Break)); 6495 6496 EXPECT_EQ("NSString *const kString =\n" 6497 " @\"aaaa\"\n" 6498 " @\"bbbb\";", 6499 format("NSString *const kString = @\"aaaa\"\n" 6500 "@\"bbbb\";", 6501 Break)); 6502 6503 Break.ColumnLimit = 0; 6504 verifyFormat("const char *hello = \"hello llvm\";", Break); 6505 } 6506 6507 TEST_F(FormatTest, AlignsPipes) { 6508 verifyFormat( 6509 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6510 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6511 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6512 verifyFormat( 6513 "aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa\n" 6514 " << aaaaaaaaaaaaaaaaaaaa;"); 6515 verifyFormat( 6516 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6517 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6518 verifyFormat( 6519 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 6520 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6521 verifyFormat( 6522 "llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"\n" 6523 " \"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\"\n" 6524 " << \"ccccccccccccccccccccccccccccccccccccccccccccccccc\";"); 6525 verifyFormat( 6526 "aaaaaaaa << (aaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6527 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6528 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6529 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6530 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6531 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6532 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 6533 verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaaaaaa: \"\n" 6534 " << aaaaaaaaaaaaaaaaa(aaaaaaaa, aaaaaaaaaaa);"); 6535 verifyFormat( 6536 "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6537 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6538 verifyFormat( 6539 "auto Diag = diag() << aaaaaaaaaaaaaaaa(aaaaaaaaaaaa, aaaaaaaaaaaaa,\n" 6540 " aaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6541 6542 verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \"\n" 6543 " << aaaaaaaa.aaaaaaaaaaaa(aaa)->aaaaaaaaaaaaaa();"); 6544 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6545 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6546 " aaaaaaaaaaaaaaaaaaaaa)\n" 6547 " << aaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6548 verifyFormat("LOG_IF(aaa == //\n" 6549 " bbb)\n" 6550 " << a << b;"); 6551 6552 // But sometimes, breaking before the first "<<" is desirable. 6553 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n" 6554 " << aaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaa);"); 6555 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbb)\n" 6556 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6557 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6558 verifyFormat("SemaRef.Diag(Loc, diag::note_for_range_begin_end)\n" 6559 " << BEF << IsTemplate << Description << E->getType();"); 6560 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n" 6561 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6562 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6563 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n" 6564 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6565 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6566 " << aaa;"); 6567 6568 verifyFormat( 6569 "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6570 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6571 6572 // Incomplete string literal. 6573 EXPECT_EQ("llvm::errs() << \"\n" 6574 " << a;", 6575 format("llvm::errs() << \"\n<<a;")); 6576 6577 verifyFormat("void f() {\n" 6578 " CHECK_EQ(aaaa, (*bbbbbbbbb)->cccccc)\n" 6579 " << \"qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\";\n" 6580 "}"); 6581 6582 // Handle 'endl'. 6583 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << endl\n" 6584 " << bbbbbbbbbbbbbbbbbbbbbb << endl;"); 6585 verifyFormat("llvm::errs() << endl << bbbbbbbbbbbbbbbbbbbbbb << endl;"); 6586 6587 // Handle '\n'. 6588 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \"\\n\"\n" 6589 " << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";"); 6590 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \'\\n\'\n" 6591 " << bbbbbbbbbbbbbbbbbbbbbb << \'\\n\';"); 6592 verifyFormat("llvm::errs() << aaaa << \"aaaaaaaaaaaaaaaaaa\\n\"\n" 6593 " << bbbb << \"bbbbbbbbbbbbbbbbbb\\n\";"); 6594 verifyFormat("llvm::errs() << \"\\n\" << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";"); 6595 } 6596 6597 TEST_F(FormatTest, KeepStringLabelValuePairsOnALine) { 6598 verifyFormat("return out << \"somepacket = {\\n\"\n" 6599 " << \" aaaaaa = \" << pkt.aaaaaa << \"\\n\"\n" 6600 " << \" bbbb = \" << pkt.bbbb << \"\\n\"\n" 6601 " << \" cccccc = \" << pkt.cccccc << \"\\n\"\n" 6602 " << \" ddd = [\" << pkt.ddd << \"]\\n\"\n" 6603 " << \"}\";"); 6604 6605 verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n" 6606 " << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n" 6607 " << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa;"); 6608 verifyFormat( 6609 "llvm::outs() << \"aaaaaaaaaaaaaaaaa = \" << aaaaaaaaaaaaaaaaa\n" 6610 " << \"bbbbbbbbbbbbbbbbb = \" << bbbbbbbbbbbbbbbbb\n" 6611 " << \"ccccccccccccccccc = \" << ccccccccccccccccc\n" 6612 " << \"ddddddddddddddddd = \" << ddddddddddddddddd\n" 6613 " << \"eeeeeeeeeeeeeeeee = \" << eeeeeeeeeeeeeeeee;"); 6614 verifyFormat("llvm::outs() << aaaaaaaaaaaaaaaaaaaaaaaa << \"=\"\n" 6615 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 6616 verifyFormat( 6617 "void f() {\n" 6618 " llvm::outs() << \"aaaaaaaaaaaaaaaaaaaa: \"\n" 6619 " << aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 6620 "}"); 6621 6622 // Breaking before the first "<<" is generally not desirable. 6623 verifyFormat( 6624 "llvm::errs()\n" 6625 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6626 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6627 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6628 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 6629 getLLVMStyleWithColumns(70)); 6630 verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaa: \"\n" 6631 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6632 " << \"aaaaaaaaaaaaaaaaaaa: \"\n" 6633 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6634 " << \"aaaaaaaaaaaaaaaaaaa: \"\n" 6635 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 6636 getLLVMStyleWithColumns(70)); 6637 6638 verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n" 6639 " \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n" 6640 " \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa;"); 6641 verifyFormat("string v = StrCat(\"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n" 6642 " \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n" 6643 " \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa);"); 6644 verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" +\n" 6645 " (aaaa + aaaa);", 6646 getLLVMStyleWithColumns(40)); 6647 verifyFormat("string v = StrCat(\"aaaaaaaaaaaa: \" +\n" 6648 " (aaaaaaa + aaaaa));", 6649 getLLVMStyleWithColumns(40)); 6650 verifyFormat( 6651 "string v = StrCat(\"aaaaaaaaaaaaaaaaaaaaaaaaaaa: \",\n" 6652 " SomeFunction(aaaaaaaaaaaa, aaaaaaaa.aaaaaaa),\n" 6653 " bbbbbbbbbbbbbbbbbbbbbbb);"); 6654 } 6655 6656 TEST_F(FormatTest, UnderstandsEquals) { 6657 verifyFormat( 6658 "aaaaaaaaaaaaaaaaa =\n" 6659 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6660 verifyFormat( 6661 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 6662 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 6663 verifyFormat( 6664 "if (a) {\n" 6665 " f();\n" 6666 "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 6667 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 6668 "}"); 6669 6670 verifyFormat("if (int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 6671 " 100000000 + 10000000) {\n}"); 6672 } 6673 6674 TEST_F(FormatTest, WrapsAtFunctionCallsIfNecessary) { 6675 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n" 6676 " .looooooooooooooooooooooooooooooooooooooongFunction();"); 6677 6678 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n" 6679 " ->looooooooooooooooooooooooooooooooooooooongFunction();"); 6680 6681 verifyFormat( 6682 "LooooooooooooooooooooooooooooooooongObject->shortFunction(Parameter1,\n" 6683 " Parameter2);"); 6684 6685 verifyFormat( 6686 "ShortObject->shortFunction(\n" 6687 " LooooooooooooooooooooooooooooooooooooooooooooooongParameter1,\n" 6688 " LooooooooooooooooooooooooooooooooooooooooooooooongParameter2);"); 6689 6690 verifyFormat("loooooooooooooongFunction(\n" 6691 " LoooooooooooooongObject->looooooooooooooooongFunction());"); 6692 6693 verifyFormat( 6694 "function(LoooooooooooooooooooooooooooooooooooongObject\n" 6695 " ->loooooooooooooooooooooooooooooooooooooooongFunction());"); 6696 6697 verifyFormat("EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n" 6698 " .WillRepeatedly(Return(SomeValue));"); 6699 verifyFormat("void f() {\n" 6700 " EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n" 6701 " .Times(2)\n" 6702 " .WillRepeatedly(Return(SomeValue));\n" 6703 "}"); 6704 verifyFormat("SomeMap[std::pair(aaaaaaaaaaaa, bbbbbbbbbbbbbbb)].insert(\n" 6705 " ccccccccccccccccccccccc);"); 6706 verifyFormat("aaaaa(aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6707 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6708 " .aaaaa(aaaaa),\n" 6709 " aaaaaaaaaaaaaaaaaaaaa);"); 6710 verifyFormat("void f() {\n" 6711 " aaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6712 " aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa)->aaaaaaaaa());\n" 6713 "}"); 6714 verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6715 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6716 " .aaaaaaaaaaaaaaa(aa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6717 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6718 " aaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 6719 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6720 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6721 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6722 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()) {\n" 6723 "}"); 6724 6725 // Here, it is not necessary to wrap at "." or "->". 6726 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaa) ||\n" 6727 " aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 6728 verifyFormat( 6729 "aaaaaaaaaaa->aaaaaaaaa(\n" 6730 " aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6731 " aaaaaaaaaaaaaaaaaa->aaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa));\n"); 6732 6733 verifyFormat( 6734 "aaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6735 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa().aaaaaaaaaaaaaaaaa());"); 6736 verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() *\n" 6737 " aaaaaaaaa()->aaaaaa()->aaaaa());"); 6738 verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() ||\n" 6739 " aaaaaaaaa()->aaaaaa()->aaaaa());"); 6740 6741 verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6742 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6743 " .a();"); 6744 6745 FormatStyle NoBinPacking = getLLVMStyle(); 6746 NoBinPacking.BinPackParameters = false; 6747 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n" 6748 " .aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n" 6749 " .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa,\n" 6750 " aaaaaaaaaaaaaaaaaaa,\n" 6751 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 6752 NoBinPacking); 6753 6754 // If there is a subsequent call, change to hanging indentation. 6755 verifyFormat( 6756 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6757 " aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa))\n" 6758 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6759 verifyFormat( 6760 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6761 " aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa));"); 6762 verifyFormat("aaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6763 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6764 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6765 verifyFormat("aaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6766 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6767 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());"); 6768 } 6769 6770 TEST_F(FormatTest, WrapsTemplateDeclarations) { 6771 verifyFormat("template <typename T>\n" 6772 "virtual void loooooooooooongFunction(int Param1, int Param2);"); 6773 verifyFormat("template <typename T>\n" 6774 "// T should be one of {A, B}.\n" 6775 "virtual void loooooooooooongFunction(int Param1, int Param2);"); 6776 verifyFormat( 6777 "template <typename T>\n" 6778 "using comment_to_xml_conversion = comment_to_xml_conversion<T, int>;"); 6779 verifyFormat("template <typename T>\n" 6780 "void f(int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram1,\n" 6781 " int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram2);"); 6782 verifyFormat( 6783 "template <typename T>\n" 6784 "void looooooooooooooooooooongFunction(int Paaaaaaaaaaaaaaaaaaaaram1,\n" 6785 " int Paaaaaaaaaaaaaaaaaaaaram2);"); 6786 verifyFormat( 6787 "template <typename T>\n" 6788 "aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaa,\n" 6789 " aaaaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaa,\n" 6790 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6791 verifyFormat("template <typename T>\n" 6792 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6793 " int aaaaaaaaaaaaaaaaaaaaaa);"); 6794 verifyFormat( 6795 "template <typename T1, typename T2 = char, typename T3 = char,\n" 6796 " typename T4 = char>\n" 6797 "void f();"); 6798 verifyFormat("template <typename aaaaaaaaaaa, typename bbbbbbbbbbbbb,\n" 6799 " template <typename> class cccccccccccccccccccccc,\n" 6800 " typename ddddddddddddd>\n" 6801 "class C {};"); 6802 verifyFormat( 6803 "aaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>(\n" 6804 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6805 6806 verifyFormat("void f() {\n" 6807 " a<aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaa>(\n" 6808 " a(aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));\n" 6809 "}"); 6810 6811 verifyFormat("template <typename T> class C {};"); 6812 verifyFormat("template <typename T> void f();"); 6813 verifyFormat("template <typename T> void f() {}"); 6814 verifyFormat( 6815 "aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n" 6816 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6817 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> *aaaa =\n" 6818 " new aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n" 6819 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6820 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>(\n" 6821 " bbbbbbbbbbbbbbbbbbbbbbbb);", 6822 getLLVMStyleWithColumns(72)); 6823 EXPECT_EQ("static_cast<A< //\n" 6824 " B> *>(\n" 6825 "\n" 6826 ");", 6827 format("static_cast<A<//\n" 6828 " B>*>(\n" 6829 "\n" 6830 " );")); 6831 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6832 " const typename aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaa);"); 6833 6834 FormatStyle AlwaysBreak = getLLVMStyle(); 6835 AlwaysBreak.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes; 6836 verifyFormat("template <typename T>\nclass C {};", AlwaysBreak); 6837 verifyFormat("template <typename T>\nvoid f();", AlwaysBreak); 6838 verifyFormat("template <typename T>\nvoid f() {}", AlwaysBreak); 6839 verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6840 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n" 6841 " ccccccccccccccccccccccccccccccccccccccccccccccc);"); 6842 verifyFormat("template <template <typename> class Fooooooo,\n" 6843 " template <typename> class Baaaaaaar>\n" 6844 "struct C {};", 6845 AlwaysBreak); 6846 verifyFormat("template <typename T> // T can be A, B or C.\n" 6847 "struct C {};", 6848 AlwaysBreak); 6849 verifyFormat("template <enum E> class A {\n" 6850 "public:\n" 6851 " E *f();\n" 6852 "};"); 6853 6854 FormatStyle NeverBreak = getLLVMStyle(); 6855 NeverBreak.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_No; 6856 verifyFormat("template <typename T> class C {};", NeverBreak); 6857 verifyFormat("template <typename T> void f();", NeverBreak); 6858 verifyFormat("template <typename T> void f() {}", NeverBreak); 6859 verifyFormat("template <typename T>\nvoid foo(aaaaaaaaaaaaaaaaaaaaaaaaaa " 6860 "bbbbbbbbbbbbbbbbbbbb) {}", 6861 NeverBreak); 6862 verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6863 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n" 6864 " ccccccccccccccccccccccccccccccccccccccccccccccc);", 6865 NeverBreak); 6866 verifyFormat("template <template <typename> class Fooooooo,\n" 6867 " template <typename> class Baaaaaaar>\n" 6868 "struct C {};", 6869 NeverBreak); 6870 verifyFormat("template <typename T> // T can be A, B or C.\n" 6871 "struct C {};", 6872 NeverBreak); 6873 verifyFormat("template <enum E> class A {\n" 6874 "public:\n" 6875 " E *f();\n" 6876 "};", 6877 NeverBreak); 6878 NeverBreak.PenaltyBreakTemplateDeclaration = 100; 6879 verifyFormat("template <typename T> void\nfoo(aaaaaaaaaaaaaaaaaaaaaaaaaa " 6880 "bbbbbbbbbbbbbbbbbbbb) {}", 6881 NeverBreak); 6882 } 6883 6884 TEST_F(FormatTest, WrapsTemplateDeclarationsWithComments) { 6885 FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp); 6886 Style.ColumnLimit = 60; 6887 EXPECT_EQ("// Baseline - no comments.\n" 6888 "template <\n" 6889 " typename aaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbbb>::value>\n" 6890 "void f() {}", 6891 format("// Baseline - no comments.\n" 6892 "template <\n" 6893 " typename aaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbbb>::value>\n" 6894 "void f() {}", 6895 Style)); 6896 6897 EXPECT_EQ("template <\n" 6898 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 6899 "void f() {}", 6900 format("template <\n" 6901 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 6902 "void f() {}", 6903 Style)); 6904 6905 EXPECT_EQ( 6906 "template <\n" 6907 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> /* line */\n" 6908 "void f() {}", 6909 format("template <typename aaaaaaaaaa<bbbbbbbbbbbb>::value> /* line */\n" 6910 "void f() {}", 6911 Style)); 6912 6913 EXPECT_EQ( 6914 "template <\n" 6915 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 6916 " // multiline\n" 6917 "void f() {}", 6918 format("template <\n" 6919 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 6920 " // multiline\n" 6921 "void f() {}", 6922 Style)); 6923 6924 EXPECT_EQ( 6925 "template <typename aaaaaaaaaa<\n" 6926 " bbbbbbbbbbbb>::value> // trailing loooong\n" 6927 "void f() {}", 6928 format( 6929 "template <\n" 6930 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing loooong\n" 6931 "void f() {}", 6932 Style)); 6933 } 6934 6935 TEST_F(FormatTest, WrapsTemplateParameters) { 6936 FormatStyle Style = getLLVMStyle(); 6937 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 6938 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 6939 verifyFormat( 6940 "template <typename... a> struct q {};\n" 6941 "extern q<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n" 6942 " aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n" 6943 " y;", 6944 Style); 6945 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 6946 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 6947 verifyFormat( 6948 "template <typename... a> struct r {};\n" 6949 "extern r<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n" 6950 " aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n" 6951 " y;", 6952 Style); 6953 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 6954 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 6955 verifyFormat("template <typename... a> struct s {};\n" 6956 "extern s<\n" 6957 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, " 6958 "aaaaaaaaaaaaaaaaaaaaaa,\n" 6959 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, " 6960 "aaaaaaaaaaaaaaaaaaaaaa>\n" 6961 " y;", 6962 Style); 6963 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 6964 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 6965 verifyFormat("template <typename... a> struct t {};\n" 6966 "extern t<\n" 6967 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, " 6968 "aaaaaaaaaaaaaaaaaaaaaa,\n" 6969 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, " 6970 "aaaaaaaaaaaaaaaaaaaaaa>\n" 6971 " y;", 6972 Style); 6973 } 6974 6975 TEST_F(FormatTest, WrapsAtNestedNameSpecifiers) { 6976 verifyFormat( 6977 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6978 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6979 verifyFormat( 6980 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6981 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6982 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());"); 6983 6984 // FIXME: Should we have the extra indent after the second break? 6985 verifyFormat( 6986 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6987 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6988 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6989 6990 verifyFormat( 6991 "aaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb::\n" 6992 " cccccccccccccccccccccccccccccccccccccccccccccc());"); 6993 6994 // Breaking at nested name specifiers is generally not desirable. 6995 verifyFormat( 6996 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6997 " aaaaaaaaaaaaaaaaaaaaaaa);"); 6998 6999 verifyFormat("aaaaaaaaaaaaaaaaaa(aaaaaaaa,\n" 7000 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 7001 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 7002 " aaaaaaaaaaaaaaaaaaaaa);", 7003 getLLVMStyleWithColumns(74)); 7004 7005 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 7006 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7007 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 7008 } 7009 7010 TEST_F(FormatTest, UnderstandsTemplateParameters) { 7011 verifyFormat("A<int> a;"); 7012 verifyFormat("A<A<A<int>>> a;"); 7013 verifyFormat("A<A<A<int, 2>, 3>, 4> a;"); 7014 verifyFormat("bool x = a < 1 || 2 > a;"); 7015 verifyFormat("bool x = 5 < f<int>();"); 7016 verifyFormat("bool x = f<int>() > 5;"); 7017 verifyFormat("bool x = 5 < a<int>::x;"); 7018 verifyFormat("bool x = a < 4 ? a > 2 : false;"); 7019 verifyFormat("bool x = f() ? a < 2 : a > 2;"); 7020 7021 verifyGoogleFormat("A<A<int>> a;"); 7022 verifyGoogleFormat("A<A<A<int>>> a;"); 7023 verifyGoogleFormat("A<A<A<A<int>>>> a;"); 7024 verifyGoogleFormat("A<A<int> > a;"); 7025 verifyGoogleFormat("A<A<A<int> > > a;"); 7026 verifyGoogleFormat("A<A<A<A<int> > > > a;"); 7027 verifyGoogleFormat("A<::A<int>> a;"); 7028 verifyGoogleFormat("A<::A> a;"); 7029 verifyGoogleFormat("A< ::A> a;"); 7030 verifyGoogleFormat("A< ::A<int> > a;"); 7031 EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A> >> a;", getGoogleStyle())); 7032 EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A>> > a;", getGoogleStyle())); 7033 EXPECT_EQ("A<::A<int>> a;", format("A< ::A<int>> a;", getGoogleStyle())); 7034 EXPECT_EQ("A<::A<int>> a;", format("A<::A<int> > a;", getGoogleStyle())); 7035 EXPECT_EQ("auto x = [] { A<A<A<A>>> a; };", 7036 format("auto x=[]{A<A<A<A> >> a;};", getGoogleStyle())); 7037 7038 verifyFormat("A<A<int>> a;", getChromiumStyle(FormatStyle::LK_Cpp)); 7039 7040 // template closer followed by a token that starts with > or = 7041 verifyFormat("bool b = a<1> > 1;"); 7042 verifyFormat("bool b = a<1> >= 1;"); 7043 verifyFormat("int i = a<1> >> 1;"); 7044 FormatStyle Style = getLLVMStyle(); 7045 Style.SpaceBeforeAssignmentOperators = false; 7046 verifyFormat("bool b= a<1> == 1;", Style); 7047 verifyFormat("a<int> = 1;", Style); 7048 verifyFormat("a<int> >>= 1;", Style); 7049 7050 verifyFormat("test >> a >> b;"); 7051 verifyFormat("test << a >> b;"); 7052 7053 verifyFormat("f<int>();"); 7054 verifyFormat("template <typename T> void f() {}"); 7055 verifyFormat("struct A<std::enable_if<sizeof(T2) < sizeof(int32)>::type>;"); 7056 verifyFormat("struct A<std::enable_if<sizeof(T2) ? sizeof(int32) : " 7057 "sizeof(char)>::type>;"); 7058 verifyFormat("template <class T> struct S<std::is_arithmetic<T>{}> {};"); 7059 verifyFormat("f(a.operator()<A>());"); 7060 verifyFormat("f(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7061 " .template operator()<A>());", 7062 getLLVMStyleWithColumns(35)); 7063 7064 // Not template parameters. 7065 verifyFormat("return a < b && c > d;"); 7066 verifyFormat("void f() {\n" 7067 " while (a < b && c > d) {\n" 7068 " }\n" 7069 "}"); 7070 verifyFormat("template <typename... Types>\n" 7071 "typename enable_if<0 < sizeof...(Types)>::type Foo() {}"); 7072 7073 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7074 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa >> aaaaa);", 7075 getLLVMStyleWithColumns(60)); 7076 verifyFormat("static_assert(is_convertible<A &&, B>::value, \"AAA\");"); 7077 verifyFormat("Constructor(A... a) : a_(X<A>{std::forward<A>(a)}...) {}"); 7078 verifyFormat("< < < < < < < < < < < < < < < < < < < < < < < < < < < < < <"); 7079 } 7080 7081 TEST_F(FormatTest, BitshiftOperatorWidth) { 7082 EXPECT_EQ("int a = 1 << 2; /* foo\n" 7083 " bar */", 7084 format("int a=1<<2; /* foo\n" 7085 " bar */")); 7086 7087 EXPECT_EQ("int b = 256 >> 1; /* foo\n" 7088 " bar */", 7089 format("int b =256>>1 ; /* foo\n" 7090 " bar */")); 7091 } 7092 7093 TEST_F(FormatTest, UnderstandsBinaryOperators) { 7094 verifyFormat("COMPARE(a, ==, b);"); 7095 verifyFormat("auto s = sizeof...(Ts) - 1;"); 7096 } 7097 7098 TEST_F(FormatTest, UnderstandsPointersToMembers) { 7099 verifyFormat("int A::*x;"); 7100 verifyFormat("int (S::*func)(void *);"); 7101 verifyFormat("void f() { int (S::*func)(void *); }"); 7102 verifyFormat("typedef bool *(Class::*Member)() const;"); 7103 verifyFormat("void f() {\n" 7104 " (a->*f)();\n" 7105 " a->*x;\n" 7106 " (a.*f)();\n" 7107 " ((*a).*f)();\n" 7108 " a.*x;\n" 7109 "}"); 7110 verifyFormat("void f() {\n" 7111 " (a->*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n" 7112 " aaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);\n" 7113 "}"); 7114 verifyFormat( 7115 "(aaaaaaaaaa->*bbbbbbb)(\n" 7116 " aaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 7117 FormatStyle Style = getLLVMStyle(); 7118 Style.PointerAlignment = FormatStyle::PAS_Left; 7119 verifyFormat("typedef bool* (Class::*Member)() const;", Style); 7120 } 7121 7122 TEST_F(FormatTest, UnderstandsUnaryOperators) { 7123 verifyFormat("int a = -2;"); 7124 verifyFormat("f(-1, -2, -3);"); 7125 verifyFormat("a[-1] = 5;"); 7126 verifyFormat("int a = 5 + -2;"); 7127 verifyFormat("if (i == -1) {\n}"); 7128 verifyFormat("if (i != -1) {\n}"); 7129 verifyFormat("if (i > -1) {\n}"); 7130 verifyFormat("if (i < -1) {\n}"); 7131 verifyFormat("++(a->f());"); 7132 verifyFormat("--(a->f());"); 7133 verifyFormat("(a->f())++;"); 7134 verifyFormat("a[42]++;"); 7135 verifyFormat("if (!(a->f())) {\n}"); 7136 verifyFormat("if (!+i) {\n}"); 7137 verifyFormat("~&a;"); 7138 7139 verifyFormat("a-- > b;"); 7140 verifyFormat("b ? -a : c;"); 7141 verifyFormat("n * sizeof char16;"); 7142 verifyFormat("n * alignof char16;", getGoogleStyle()); 7143 verifyFormat("sizeof(char);"); 7144 verifyFormat("alignof(char);", getGoogleStyle()); 7145 7146 verifyFormat("return -1;"); 7147 verifyFormat("throw -1;"); 7148 verifyFormat("switch (a) {\n" 7149 "case -1:\n" 7150 " break;\n" 7151 "}"); 7152 verifyFormat("#define X -1"); 7153 verifyFormat("#define X -kConstant"); 7154 7155 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {-5, +3};"); 7156 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {+5, -3};"); 7157 7158 verifyFormat("int a = /* confusing comment */ -1;"); 7159 // FIXME: The space after 'i' is wrong, but hopefully, this is a rare case. 7160 verifyFormat("int a = i /* confusing comment */++;"); 7161 7162 verifyFormat("co_yield -1;"); 7163 verifyFormat("co_return -1;"); 7164 } 7165 7166 TEST_F(FormatTest, DoesNotIndentRelativeToUnaryOperators) { 7167 verifyFormat("if (!aaaaaaaaaa( // break\n" 7168 " aaaaa)) {\n" 7169 "}"); 7170 verifyFormat("aaaaaaaaaa(!aaaaaaaaaa( // break\n" 7171 " aaaaa));"); 7172 verifyFormat("*aaa = aaaaaaa( // break\n" 7173 " bbbbbb);"); 7174 } 7175 7176 TEST_F(FormatTest, UnderstandsOverloadedOperators) { 7177 verifyFormat("bool operator<();"); 7178 verifyFormat("bool operator>();"); 7179 verifyFormat("bool operator=();"); 7180 verifyFormat("bool operator==();"); 7181 verifyFormat("bool operator!=();"); 7182 verifyFormat("int operator+();"); 7183 verifyFormat("int operator++();"); 7184 verifyFormat("int operator++(int) volatile noexcept;"); 7185 verifyFormat("bool operator,();"); 7186 verifyFormat("bool operator();"); 7187 verifyFormat("bool operator()();"); 7188 verifyFormat("bool operator[]();"); 7189 verifyFormat("operator bool();"); 7190 verifyFormat("operator int();"); 7191 verifyFormat("operator void *();"); 7192 verifyFormat("operator SomeType<int>();"); 7193 verifyFormat("operator SomeType<int, int>();"); 7194 verifyFormat("operator SomeType<SomeType<int>>();"); 7195 verifyFormat("void *operator new(std::size_t size);"); 7196 verifyFormat("void *operator new[](std::size_t size);"); 7197 verifyFormat("void operator delete(void *ptr);"); 7198 verifyFormat("void operator delete[](void *ptr);"); 7199 verifyFormat("template <typename AAAAAAA, typename BBBBBBB>\n" 7200 "AAAAAAA operator/(const AAAAAAA &a, BBBBBBB &b);"); 7201 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa operator,(\n" 7202 " aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaaaaaaaaaaaaaaaaaaa) const;"); 7203 7204 verifyFormat( 7205 "ostream &operator<<(ostream &OutputStream,\n" 7206 " SomeReallyLongType WithSomeReallyLongValue);"); 7207 verifyFormat("bool operator<(const aaaaaaaaaaaaaaaaaaaaa &left,\n" 7208 " const aaaaaaaaaaaaaaaaaaaaa &right) {\n" 7209 " return left.group < right.group;\n" 7210 "}"); 7211 verifyFormat("SomeType &operator=(const SomeType &S);"); 7212 verifyFormat("f.template operator()<int>();"); 7213 7214 verifyGoogleFormat("operator void*();"); 7215 verifyGoogleFormat("operator SomeType<SomeType<int>>();"); 7216 verifyGoogleFormat("operator ::A();"); 7217 7218 verifyFormat("using A::operator+;"); 7219 verifyFormat("inline A operator^(const A &lhs, const A &rhs) {}\n" 7220 "int i;"); 7221 } 7222 7223 TEST_F(FormatTest, UnderstandsFunctionRefQualification) { 7224 verifyFormat("Deleted &operator=(const Deleted &) & = default;"); 7225 verifyFormat("Deleted &operator=(const Deleted &) && = delete;"); 7226 verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;"); 7227 verifyFormat("SomeType MemberFunction(const Deleted &) && = delete;"); 7228 verifyFormat("Deleted &operator=(const Deleted &) &;"); 7229 verifyFormat("Deleted &operator=(const Deleted &) &&;"); 7230 verifyFormat("SomeType MemberFunction(const Deleted &) &;"); 7231 verifyFormat("SomeType MemberFunction(const Deleted &) &&;"); 7232 verifyFormat("SomeType MemberFunction(const Deleted &) && {}"); 7233 verifyFormat("SomeType MemberFunction(const Deleted &) && final {}"); 7234 verifyFormat("SomeType MemberFunction(const Deleted &) && override {}"); 7235 verifyFormat("void Fn(T const &) const &;"); 7236 verifyFormat("void Fn(T const volatile &&) const volatile &&;"); 7237 verifyFormat("template <typename T>\n" 7238 "void F(T) && = delete;", 7239 getGoogleStyle()); 7240 7241 FormatStyle AlignLeft = getLLVMStyle(); 7242 AlignLeft.PointerAlignment = FormatStyle::PAS_Left; 7243 verifyFormat("void A::b() && {}", AlignLeft); 7244 verifyFormat("Deleted& operator=(const Deleted&) & = default;", AlignLeft); 7245 verifyFormat("SomeType MemberFunction(const Deleted&) & = delete;", 7246 AlignLeft); 7247 verifyFormat("Deleted& operator=(const Deleted&) &;", AlignLeft); 7248 verifyFormat("SomeType MemberFunction(const Deleted&) &;", AlignLeft); 7249 verifyFormat("auto Function(T t) & -> void {}", AlignLeft); 7250 verifyFormat("auto Function(T... t) & -> void {}", AlignLeft); 7251 verifyFormat("auto Function(T) & -> void {}", AlignLeft); 7252 verifyFormat("auto Function(T) & -> void;", AlignLeft); 7253 verifyFormat("void Fn(T const&) const&;", AlignLeft); 7254 verifyFormat("void Fn(T const volatile&&) const volatile&&;", AlignLeft); 7255 7256 FormatStyle Spaces = getLLVMStyle(); 7257 Spaces.SpacesInCStyleCastParentheses = true; 7258 verifyFormat("Deleted &operator=(const Deleted &) & = default;", Spaces); 7259 verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;", Spaces); 7260 verifyFormat("Deleted &operator=(const Deleted &) &;", Spaces); 7261 verifyFormat("SomeType MemberFunction(const Deleted &) &;", Spaces); 7262 7263 Spaces.SpacesInCStyleCastParentheses = false; 7264 Spaces.SpacesInParentheses = true; 7265 verifyFormat("Deleted &operator=( const Deleted & ) & = default;", Spaces); 7266 verifyFormat("SomeType MemberFunction( const Deleted & ) & = delete;", 7267 Spaces); 7268 verifyFormat("Deleted &operator=( const Deleted & ) &;", Spaces); 7269 verifyFormat("SomeType MemberFunction( const Deleted & ) &;", Spaces); 7270 7271 FormatStyle BreakTemplate = getLLVMStyle(); 7272 BreakTemplate.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes; 7273 7274 verifyFormat("struct f {\n" 7275 " template <class T>\n" 7276 " int &foo(const std::string &str) &noexcept {}\n" 7277 "};", 7278 BreakTemplate); 7279 7280 verifyFormat("struct f {\n" 7281 " template <class T>\n" 7282 " int &foo(const std::string &str) &&noexcept {}\n" 7283 "};", 7284 BreakTemplate); 7285 7286 verifyFormat("struct f {\n" 7287 " template <class T>\n" 7288 " int &foo(const std::string &str) const &noexcept {}\n" 7289 "};", 7290 BreakTemplate); 7291 7292 verifyFormat("struct f {\n" 7293 " template <class T>\n" 7294 " int &foo(const std::string &str) const &noexcept {}\n" 7295 "};", 7296 BreakTemplate); 7297 7298 verifyFormat("struct f {\n" 7299 " template <class T>\n" 7300 " auto foo(const std::string &str) &&noexcept -> int & {}\n" 7301 "};", 7302 BreakTemplate); 7303 7304 FormatStyle AlignLeftBreakTemplate = getLLVMStyle(); 7305 AlignLeftBreakTemplate.AlwaysBreakTemplateDeclarations = 7306 FormatStyle::BTDS_Yes; 7307 AlignLeftBreakTemplate.PointerAlignment = FormatStyle::PAS_Left; 7308 7309 verifyFormat("struct f {\n" 7310 " template <class T>\n" 7311 " int& foo(const std::string& str) & noexcept {}\n" 7312 "};", 7313 AlignLeftBreakTemplate); 7314 7315 verifyFormat("struct f {\n" 7316 " template <class T>\n" 7317 " int& foo(const std::string& str) && noexcept {}\n" 7318 "};", 7319 AlignLeftBreakTemplate); 7320 7321 verifyFormat("struct f {\n" 7322 " template <class T>\n" 7323 " int& foo(const std::string& str) const& noexcept {}\n" 7324 "};", 7325 AlignLeftBreakTemplate); 7326 7327 verifyFormat("struct f {\n" 7328 " template <class T>\n" 7329 " int& foo(const std::string& str) const&& noexcept {}\n" 7330 "};", 7331 AlignLeftBreakTemplate); 7332 7333 verifyFormat("struct f {\n" 7334 " template <class T>\n" 7335 " auto foo(const std::string& str) && noexcept -> int& {}\n" 7336 "};", 7337 AlignLeftBreakTemplate); 7338 7339 // The `&` in `Type&` should not be confused with a trailing `&` of 7340 // DEPRECATED(reason) member function. 7341 verifyFormat("struct f {\n" 7342 " template <class T>\n" 7343 " DEPRECATED(reason)\n" 7344 " Type &foo(arguments) {}\n" 7345 "};", 7346 BreakTemplate); 7347 7348 verifyFormat("struct f {\n" 7349 " template <class T>\n" 7350 " DEPRECATED(reason)\n" 7351 " Type& foo(arguments) {}\n" 7352 "};", 7353 AlignLeftBreakTemplate); 7354 7355 verifyFormat("void (*foopt)(int) = &func;"); 7356 } 7357 7358 TEST_F(FormatTest, UnderstandsNewAndDelete) { 7359 verifyFormat("void f() {\n" 7360 " A *a = new A;\n" 7361 " A *a = new (placement) A;\n" 7362 " delete a;\n" 7363 " delete (A *)a;\n" 7364 "}"); 7365 verifyFormat("new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n" 7366 " typename aaaaaaaaaaaaaaaaaaaaaaaa();"); 7367 verifyFormat("auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 7368 " new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n" 7369 " typename aaaaaaaaaaaaaaaaaaaaaaaa();"); 7370 verifyFormat("delete[] h->p;"); 7371 } 7372 7373 TEST_F(FormatTest, UnderstandsUsesOfStarAndAmp) { 7374 verifyFormat("int *f(int *a) {}"); 7375 verifyFormat("int main(int argc, char **argv) {}"); 7376 verifyFormat("Test::Test(int b) : a(b * b) {}"); 7377 verifyIndependentOfContext("f(a, *a);"); 7378 verifyFormat("void g() { f(*a); }"); 7379 verifyIndependentOfContext("int a = b * 10;"); 7380 verifyIndependentOfContext("int a = 10 * b;"); 7381 verifyIndependentOfContext("int a = b * c;"); 7382 verifyIndependentOfContext("int a += b * c;"); 7383 verifyIndependentOfContext("int a -= b * c;"); 7384 verifyIndependentOfContext("int a *= b * c;"); 7385 verifyIndependentOfContext("int a /= b * c;"); 7386 verifyIndependentOfContext("int a = *b;"); 7387 verifyIndependentOfContext("int a = *b * c;"); 7388 verifyIndependentOfContext("int a = b * *c;"); 7389 verifyIndependentOfContext("int a = b * (10);"); 7390 verifyIndependentOfContext("S << b * (10);"); 7391 verifyIndependentOfContext("return 10 * b;"); 7392 verifyIndependentOfContext("return *b * *c;"); 7393 verifyIndependentOfContext("return a & ~b;"); 7394 verifyIndependentOfContext("f(b ? *c : *d);"); 7395 verifyIndependentOfContext("int a = b ? *c : *d;"); 7396 verifyIndependentOfContext("*b = a;"); 7397 verifyIndependentOfContext("a * ~b;"); 7398 verifyIndependentOfContext("a * !b;"); 7399 verifyIndependentOfContext("a * +b;"); 7400 verifyIndependentOfContext("a * -b;"); 7401 verifyIndependentOfContext("a * ++b;"); 7402 verifyIndependentOfContext("a * --b;"); 7403 verifyIndependentOfContext("a[4] * b;"); 7404 verifyIndependentOfContext("a[a * a] = 1;"); 7405 verifyIndependentOfContext("f() * b;"); 7406 verifyIndependentOfContext("a * [self dostuff];"); 7407 verifyIndependentOfContext("int x = a * (a + b);"); 7408 verifyIndependentOfContext("(a *)(a + b);"); 7409 verifyIndependentOfContext("*(int *)(p & ~3UL) = 0;"); 7410 verifyIndependentOfContext("int *pa = (int *)&a;"); 7411 verifyIndependentOfContext("return sizeof(int **);"); 7412 verifyIndependentOfContext("return sizeof(int ******);"); 7413 verifyIndependentOfContext("return (int **&)a;"); 7414 verifyIndependentOfContext("f((*PointerToArray)[10]);"); 7415 verifyFormat("void f(Type (*parameter)[10]) {}"); 7416 verifyFormat("void f(Type (¶meter)[10]) {}"); 7417 verifyGoogleFormat("return sizeof(int**);"); 7418 verifyIndependentOfContext("Type **A = static_cast<Type **>(P);"); 7419 verifyGoogleFormat("Type** A = static_cast<Type**>(P);"); 7420 verifyFormat("auto a = [](int **&, int ***) {};"); 7421 verifyFormat("auto PointerBinding = [](const char *S) {};"); 7422 verifyFormat("typedef typeof(int(int, int)) *MyFunc;"); 7423 verifyFormat("[](const decltype(*a) &value) {}"); 7424 verifyFormat("decltype(a * b) F();"); 7425 verifyFormat("#define MACRO() [](A *a) { return 1; }"); 7426 verifyFormat("Constructor() : member([](A *a, B *b) {}) {}"); 7427 verifyIndependentOfContext("typedef void (*f)(int *a);"); 7428 verifyIndependentOfContext("int i{a * b};"); 7429 verifyIndependentOfContext("aaa && aaa->f();"); 7430 verifyIndependentOfContext("int x = ~*p;"); 7431 verifyFormat("Constructor() : a(a), area(width * height) {}"); 7432 verifyFormat("Constructor() : a(a), area(a, width * height) {}"); 7433 verifyGoogleFormat("MACRO Constructor(const int& i) : a(a), b(b) {}"); 7434 verifyFormat("void f() { f(a, c * d); }"); 7435 verifyFormat("void f() { f(new a(), c * d); }"); 7436 verifyFormat("void f(const MyOverride &override);"); 7437 verifyFormat("void f(const MyFinal &final);"); 7438 verifyIndependentOfContext("bool a = f() && override.f();"); 7439 verifyIndependentOfContext("bool a = f() && final.f();"); 7440 7441 verifyIndependentOfContext("InvalidRegions[*R] = 0;"); 7442 7443 verifyIndependentOfContext("A<int *> a;"); 7444 verifyIndependentOfContext("A<int **> a;"); 7445 verifyIndependentOfContext("A<int *, int *> a;"); 7446 verifyIndependentOfContext("A<int *[]> a;"); 7447 verifyIndependentOfContext( 7448 "const char *const p = reinterpret_cast<const char *const>(q);"); 7449 verifyIndependentOfContext("A<int **, int **> a;"); 7450 verifyIndependentOfContext("void f(int *a = d * e, int *b = c * d);"); 7451 verifyFormat("for (char **a = b; *a; ++a) {\n}"); 7452 verifyFormat("for (; a && b;) {\n}"); 7453 verifyFormat("bool foo = true && [] { return false; }();"); 7454 7455 verifyFormat( 7456 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7457 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa, *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 7458 7459 verifyGoogleFormat("int const* a = &b;"); 7460 verifyGoogleFormat("**outparam = 1;"); 7461 verifyGoogleFormat("*outparam = a * b;"); 7462 verifyGoogleFormat("int main(int argc, char** argv) {}"); 7463 verifyGoogleFormat("A<int*> a;"); 7464 verifyGoogleFormat("A<int**> a;"); 7465 verifyGoogleFormat("A<int*, int*> a;"); 7466 verifyGoogleFormat("A<int**, int**> a;"); 7467 verifyGoogleFormat("f(b ? *c : *d);"); 7468 verifyGoogleFormat("int a = b ? *c : *d;"); 7469 verifyGoogleFormat("Type* t = **x;"); 7470 verifyGoogleFormat("Type* t = *++*x;"); 7471 verifyGoogleFormat("*++*x;"); 7472 verifyGoogleFormat("Type* t = const_cast<T*>(&*x);"); 7473 verifyGoogleFormat("Type* t = x++ * y;"); 7474 verifyGoogleFormat( 7475 "const char* const p = reinterpret_cast<const char* const>(q);"); 7476 verifyGoogleFormat("void f(int i = 0, SomeType** temps = NULL);"); 7477 verifyGoogleFormat("void f(Bar* a = nullptr, Bar* b);"); 7478 verifyGoogleFormat("template <typename T>\n" 7479 "void f(int i = 0, SomeType** temps = NULL);"); 7480 7481 FormatStyle Left = getLLVMStyle(); 7482 Left.PointerAlignment = FormatStyle::PAS_Left; 7483 verifyFormat("x = *a(x) = *a(y);", Left); 7484 verifyFormat("for (;; *a = b) {\n}", Left); 7485 verifyFormat("return *this += 1;", Left); 7486 verifyFormat("throw *x;", Left); 7487 verifyFormat("delete *x;", Left); 7488 verifyFormat("typedef typeof(int(int, int))* MyFuncPtr;", Left); 7489 verifyFormat("[](const decltype(*a)* ptr) {}", Left); 7490 verifyFormat("typedef typeof /*comment*/ (int(int, int))* MyFuncPtr;", Left); 7491 verifyFormat("auto x(A&&, B&&, C&&) -> D;", Left); 7492 verifyFormat("auto x = [](A&&, B&&, C&&) -> D {};", Left); 7493 verifyFormat("template <class T> X(T&&, T&&, T&&) -> X<T>;", Left); 7494 7495 verifyIndependentOfContext("a = *(x + y);"); 7496 verifyIndependentOfContext("a = &(x + y);"); 7497 verifyIndependentOfContext("*(x + y).call();"); 7498 verifyIndependentOfContext("&(x + y)->call();"); 7499 verifyFormat("void f() { &(*I).first; }"); 7500 7501 verifyIndependentOfContext("f(b * /* confusing comment */ ++c);"); 7502 verifyFormat( 7503 "int *MyValues = {\n" 7504 " *A, // Operator detection might be confused by the '{'\n" 7505 " *BB // Operator detection might be confused by previous comment\n" 7506 "};"); 7507 7508 verifyIndependentOfContext("if (int *a = &b)"); 7509 verifyIndependentOfContext("if (int &a = *b)"); 7510 verifyIndependentOfContext("if (a & b[i])"); 7511 verifyIndependentOfContext("if constexpr (a & b[i])"); 7512 verifyIndependentOfContext("if CONSTEXPR (a & b[i])"); 7513 verifyIndependentOfContext("if (a * (b * c))"); 7514 verifyIndependentOfContext("if constexpr (a * (b * c))"); 7515 verifyIndependentOfContext("if CONSTEXPR (a * (b * c))"); 7516 verifyIndependentOfContext("if (a::b::c::d & b[i])"); 7517 verifyIndependentOfContext("if (*b[i])"); 7518 verifyIndependentOfContext("if (int *a = (&b))"); 7519 verifyIndependentOfContext("while (int *a = &b)"); 7520 verifyIndependentOfContext("while (a * (b * c))"); 7521 verifyIndependentOfContext("size = sizeof *a;"); 7522 verifyIndependentOfContext("if (a && (b = c))"); 7523 verifyFormat("void f() {\n" 7524 " for (const int &v : Values) {\n" 7525 " }\n" 7526 "}"); 7527 verifyFormat("for (int i = a * a; i < 10; ++i) {\n}"); 7528 verifyFormat("for (int i = 0; i < a * a; ++i) {\n}"); 7529 verifyGoogleFormat("for (int i = 0; i * 2 < z; i *= 2) {\n}"); 7530 7531 verifyFormat("#define A (!a * b)"); 7532 verifyFormat("#define MACRO \\\n" 7533 " int *i = a * b; \\\n" 7534 " void f(a *b);", 7535 getLLVMStyleWithColumns(19)); 7536 7537 verifyIndependentOfContext("A = new SomeType *[Length];"); 7538 verifyIndependentOfContext("A = new SomeType *[Length]();"); 7539 verifyIndependentOfContext("T **t = new T *;"); 7540 verifyIndependentOfContext("T **t = new T *();"); 7541 verifyGoogleFormat("A = new SomeType*[Length]();"); 7542 verifyGoogleFormat("A = new SomeType*[Length];"); 7543 verifyGoogleFormat("T** t = new T*;"); 7544 verifyGoogleFormat("T** t = new T*();"); 7545 7546 verifyFormat("STATIC_ASSERT((a & b) == 0);"); 7547 verifyFormat("STATIC_ASSERT(0 == (a & b));"); 7548 verifyFormat("template <bool a, bool b> " 7549 "typename t::if<x && y>::type f() {}"); 7550 verifyFormat("template <int *y> f() {}"); 7551 verifyFormat("vector<int *> v;"); 7552 verifyFormat("vector<int *const> v;"); 7553 verifyFormat("vector<int *const **const *> v;"); 7554 verifyFormat("vector<int *volatile> v;"); 7555 verifyFormat("vector<a * b> v;"); 7556 verifyFormat("foo<b && false>();"); 7557 verifyFormat("foo<b & 1>();"); 7558 verifyFormat("decltype(*::std::declval<const T &>()) void F();"); 7559 verifyFormat( 7560 "template <class T, class = typename std::enable_if<\n" 7561 " std::is_integral<T>::value &&\n" 7562 " (sizeof(T) > 1 || sizeof(T) < 8)>::type>\n" 7563 "void F();", 7564 getLLVMStyleWithColumns(70)); 7565 verifyFormat("template <class T,\n" 7566 " class = typename std::enable_if<\n" 7567 " std::is_integral<T>::value &&\n" 7568 " (sizeof(T) > 1 || sizeof(T) < 8)>::type,\n" 7569 " class U>\n" 7570 "void F();", 7571 getLLVMStyleWithColumns(70)); 7572 verifyFormat( 7573 "template <class T,\n" 7574 " class = typename ::std::enable_if<\n" 7575 " ::std::is_array<T>{} && ::std::is_array<T>{}>::type>\n" 7576 "void F();", 7577 getGoogleStyleWithColumns(68)); 7578 7579 verifyIndependentOfContext("MACRO(int *i);"); 7580 verifyIndependentOfContext("MACRO(auto *a);"); 7581 verifyIndependentOfContext("MACRO(const A *a);"); 7582 verifyIndependentOfContext("MACRO(A *const a);"); 7583 verifyIndependentOfContext("MACRO('0' <= c && c <= '9');"); 7584 verifyFormat("void f() { f(float{1}, a * a); }"); 7585 // FIXME: Is there a way to make this work? 7586 // verifyIndependentOfContext("MACRO(A *a);"); 7587 7588 verifyFormat("DatumHandle const *operator->() const { return input_; }"); 7589 verifyFormat("return options != nullptr && operator==(*options);"); 7590 7591 EXPECT_EQ("#define OP(x) \\\n" 7592 " ostream &operator<<(ostream &s, const A &a) { \\\n" 7593 " return s << a.DebugString(); \\\n" 7594 " }", 7595 format("#define OP(x) \\\n" 7596 " ostream &operator<<(ostream &s, const A &a) { \\\n" 7597 " return s << a.DebugString(); \\\n" 7598 " }", 7599 getLLVMStyleWithColumns(50))); 7600 7601 // FIXME: We cannot handle this case yet; we might be able to figure out that 7602 // foo<x> d > v; doesn't make sense. 7603 verifyFormat("foo<a<b && c> d> v;"); 7604 7605 FormatStyle PointerMiddle = getLLVMStyle(); 7606 PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle; 7607 verifyFormat("delete *x;", PointerMiddle); 7608 verifyFormat("int * x;", PointerMiddle); 7609 verifyFormat("int *[] x;", PointerMiddle); 7610 verifyFormat("template <int * y> f() {}", PointerMiddle); 7611 verifyFormat("int * f(int * a) {}", PointerMiddle); 7612 verifyFormat("int main(int argc, char ** argv) {}", PointerMiddle); 7613 verifyFormat("Test::Test(int b) : a(b * b) {}", PointerMiddle); 7614 verifyFormat("A<int *> a;", PointerMiddle); 7615 verifyFormat("A<int **> a;", PointerMiddle); 7616 verifyFormat("A<int *, int *> a;", PointerMiddle); 7617 verifyFormat("A<int *[]> a;", PointerMiddle); 7618 verifyFormat("A = new SomeType *[Length]();", PointerMiddle); 7619 verifyFormat("A = new SomeType *[Length];", PointerMiddle); 7620 verifyFormat("T ** t = new T *;", PointerMiddle); 7621 7622 // Member function reference qualifiers aren't binary operators. 7623 verifyFormat("string // break\n" 7624 "operator()() & {}"); 7625 verifyFormat("string // break\n" 7626 "operator()() && {}"); 7627 verifyGoogleFormat("template <typename T>\n" 7628 "auto x() & -> int {}"); 7629 } 7630 7631 TEST_F(FormatTest, UnderstandsAttributes) { 7632 verifyFormat("SomeType s __attribute__((unused)) (InitValue);"); 7633 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa __attribute__((unused))\n" 7634 "aaaaaaaaaaaaaaaaaaaaaaa(int i);"); 7635 FormatStyle AfterType = getLLVMStyle(); 7636 AfterType.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions; 7637 verifyFormat("__attribute__((nodebug)) void\n" 7638 "foo() {}\n", 7639 AfterType); 7640 } 7641 7642 TEST_F(FormatTest, UnderstandsSquareAttributes) { 7643 verifyFormat("SomeType s [[unused]] (InitValue);"); 7644 verifyFormat("SomeType s [[gnu::unused]] (InitValue);"); 7645 verifyFormat("SomeType s [[using gnu: unused]] (InitValue);"); 7646 verifyFormat("[[gsl::suppress(\"clang-tidy-check-name\")]] void f() {}"); 7647 verifyFormat("void f() [[deprecated(\"so sorry\")]];"); 7648 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7649 " [[unused]] aaaaaaaaaaaaaaaaaaaaaaa(int i);"); 7650 7651 // Make sure we do not mistake attributes for array subscripts. 7652 verifyFormat("int a() {}\n" 7653 "[[unused]] int b() {}\n"); 7654 verifyFormat("NSArray *arr;\n" 7655 "arr[[Foo() bar]];"); 7656 7657 // On the other hand, we still need to correctly find array subscripts. 7658 verifyFormat("int a = std::vector<int>{1, 2, 3}[0];"); 7659 7660 // Make sure that we do not mistake Objective-C method inside array literals 7661 // as attributes, even if those method names are also keywords. 7662 verifyFormat("@[ [foo bar] ];"); 7663 verifyFormat("@[ [NSArray class] ];"); 7664 verifyFormat("@[ [foo enum] ];"); 7665 7666 // Make sure we do not parse attributes as lambda introducers. 7667 FormatStyle MultiLineFunctions = getLLVMStyle(); 7668 MultiLineFunctions.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 7669 verifyFormat("[[unused]] int b() {\n" 7670 " return 42;\n" 7671 "}\n", 7672 MultiLineFunctions); 7673 } 7674 7675 TEST_F(FormatTest, UnderstandsEllipsis) { 7676 verifyFormat("int printf(const char *fmt, ...);"); 7677 verifyFormat("template <class... Ts> void Foo(Ts... ts) { Foo(ts...); }"); 7678 verifyFormat("template <class... Ts> void Foo(Ts *... ts) {}"); 7679 7680 FormatStyle PointersLeft = getLLVMStyle(); 7681 PointersLeft.PointerAlignment = FormatStyle::PAS_Left; 7682 verifyFormat("template <class... Ts> void Foo(Ts*... ts) {}", PointersLeft); 7683 } 7684 7685 TEST_F(FormatTest, AdaptivelyFormatsPointersAndReferences) { 7686 EXPECT_EQ("int *a;\n" 7687 "int *a;\n" 7688 "int *a;", 7689 format("int *a;\n" 7690 "int* a;\n" 7691 "int *a;", 7692 getGoogleStyle())); 7693 EXPECT_EQ("int* a;\n" 7694 "int* a;\n" 7695 "int* a;", 7696 format("int* a;\n" 7697 "int* a;\n" 7698 "int *a;", 7699 getGoogleStyle())); 7700 EXPECT_EQ("int *a;\n" 7701 "int *a;\n" 7702 "int *a;", 7703 format("int *a;\n" 7704 "int * a;\n" 7705 "int * a;", 7706 getGoogleStyle())); 7707 EXPECT_EQ("auto x = [] {\n" 7708 " int *a;\n" 7709 " int *a;\n" 7710 " int *a;\n" 7711 "};", 7712 format("auto x=[]{int *a;\n" 7713 "int * a;\n" 7714 "int * a;};", 7715 getGoogleStyle())); 7716 } 7717 7718 TEST_F(FormatTest, UnderstandsRvalueReferences) { 7719 verifyFormat("int f(int &&a) {}"); 7720 verifyFormat("int f(int a, char &&b) {}"); 7721 verifyFormat("void f() { int &&a = b; }"); 7722 verifyGoogleFormat("int f(int a, char&& b) {}"); 7723 verifyGoogleFormat("void f() { int&& a = b; }"); 7724 7725 verifyIndependentOfContext("A<int &&> a;"); 7726 verifyIndependentOfContext("A<int &&, int &&> a;"); 7727 verifyGoogleFormat("A<int&&> a;"); 7728 verifyGoogleFormat("A<int&&, int&&> a;"); 7729 7730 // Not rvalue references: 7731 verifyFormat("template <bool B, bool C> class A {\n" 7732 " static_assert(B && C, \"Something is wrong\");\n" 7733 "};"); 7734 verifyGoogleFormat("#define IF(a, b, c) if (a && (b == c))"); 7735 verifyGoogleFormat("#define WHILE(a, b, c) while (a && (b == c))"); 7736 verifyFormat("#define A(a, b) (a && b)"); 7737 } 7738 7739 TEST_F(FormatTest, FormatsBinaryOperatorsPrecedingEquals) { 7740 verifyFormat("void f() {\n" 7741 " x[aaaaaaaaa -\n" 7742 " b] = 23;\n" 7743 "}", 7744 getLLVMStyleWithColumns(15)); 7745 } 7746 7747 TEST_F(FormatTest, FormatsCasts) { 7748 verifyFormat("Type *A = static_cast<Type *>(P);"); 7749 verifyFormat("Type *A = (Type *)P;"); 7750 verifyFormat("Type *A = (vector<Type *, int *>)P;"); 7751 verifyFormat("int a = (int)(2.0f);"); 7752 verifyFormat("int a = (int)2.0f;"); 7753 verifyFormat("x[(int32)y];"); 7754 verifyFormat("x = (int32)y;"); 7755 verifyFormat("#define AA(X) sizeof(((X *)NULL)->a)"); 7756 verifyFormat("int a = (int)*b;"); 7757 verifyFormat("int a = (int)2.0f;"); 7758 verifyFormat("int a = (int)~0;"); 7759 verifyFormat("int a = (int)++a;"); 7760 verifyFormat("int a = (int)sizeof(int);"); 7761 verifyFormat("int a = (int)+2;"); 7762 verifyFormat("my_int a = (my_int)2.0f;"); 7763 verifyFormat("my_int a = (my_int)sizeof(int);"); 7764 verifyFormat("return (my_int)aaa;"); 7765 verifyFormat("#define x ((int)-1)"); 7766 verifyFormat("#define LENGTH(x, y) (x) - (y) + 1"); 7767 verifyFormat("#define p(q) ((int *)&q)"); 7768 verifyFormat("fn(a)(b) + 1;"); 7769 7770 verifyFormat("void f() { my_int a = (my_int)*b; }"); 7771 verifyFormat("void f() { return P ? (my_int)*P : (my_int)0; }"); 7772 verifyFormat("my_int a = (my_int)~0;"); 7773 verifyFormat("my_int a = (my_int)++a;"); 7774 verifyFormat("my_int a = (my_int)-2;"); 7775 verifyFormat("my_int a = (my_int)1;"); 7776 verifyFormat("my_int a = (my_int *)1;"); 7777 verifyFormat("my_int a = (const my_int)-1;"); 7778 verifyFormat("my_int a = (const my_int *)-1;"); 7779 verifyFormat("my_int a = (my_int)(my_int)-1;"); 7780 verifyFormat("my_int a = (ns::my_int)-2;"); 7781 verifyFormat("case (my_int)ONE:"); 7782 verifyFormat("auto x = (X)this;"); 7783 // Casts in Obj-C style calls used to not be recognized as such. 7784 verifyFormat("int a = [(type*)[((type*)val) arg] arg];", getGoogleStyle()); 7785 7786 // FIXME: single value wrapped with paren will be treated as cast. 7787 verifyFormat("void f(int i = (kValue)*kMask) {}"); 7788 7789 verifyFormat("{ (void)F; }"); 7790 7791 // Don't break after a cast's 7792 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 7793 " (aaaaaaaaaaaaaaaaaaaaaaaaaa *)(aaaaaaaaaaaaaaaaaaaaaa +\n" 7794 " bbbbbbbbbbbbbbbbbbbbbb);"); 7795 7796 // These are not casts. 7797 verifyFormat("void f(int *) {}"); 7798 verifyFormat("f(foo)->b;"); 7799 verifyFormat("f(foo).b;"); 7800 verifyFormat("f(foo)(b);"); 7801 verifyFormat("f(foo)[b];"); 7802 verifyFormat("[](foo) { return 4; }(bar);"); 7803 verifyFormat("(*funptr)(foo)[4];"); 7804 verifyFormat("funptrs[4](foo)[4];"); 7805 verifyFormat("void f(int *);"); 7806 verifyFormat("void f(int *) = 0;"); 7807 verifyFormat("void f(SmallVector<int>) {}"); 7808 verifyFormat("void f(SmallVector<int>);"); 7809 verifyFormat("void f(SmallVector<int>) = 0;"); 7810 verifyFormat("void f(int i = (kA * kB) & kMask) {}"); 7811 verifyFormat("int a = sizeof(int) * b;"); 7812 verifyFormat("int a = alignof(int) * b;", getGoogleStyle()); 7813 verifyFormat("template <> void f<int>(int i) SOME_ANNOTATION;"); 7814 verifyFormat("f(\"%\" SOME_MACRO(ll) \"d\");"); 7815 verifyFormat("aaaaa &operator=(const aaaaa &) LLVM_DELETED_FUNCTION;"); 7816 7817 // These are not casts, but at some point were confused with casts. 7818 verifyFormat("virtual void foo(int *) override;"); 7819 verifyFormat("virtual void foo(char &) const;"); 7820 verifyFormat("virtual void foo(int *a, char *) const;"); 7821 verifyFormat("int a = sizeof(int *) + b;"); 7822 verifyFormat("int a = alignof(int *) + b;", getGoogleStyle()); 7823 verifyFormat("bool b = f(g<int>) && c;"); 7824 verifyFormat("typedef void (*f)(int i) func;"); 7825 verifyFormat("void operator++(int) noexcept;"); 7826 verifyFormat("void operator++(int &) noexcept;"); 7827 verifyFormat("void operator delete(void *, std::size_t, const std::nothrow_t " 7828 "&) noexcept;"); 7829 verifyFormat( 7830 "void operator delete(std::size_t, const std::nothrow_t &) noexcept;"); 7831 verifyFormat("void operator delete(const std::nothrow_t &) noexcept;"); 7832 verifyFormat("void operator delete(std::nothrow_t &) noexcept;"); 7833 verifyFormat("void operator delete(nothrow_t &) noexcept;"); 7834 verifyFormat("void operator delete(foo &) noexcept;"); 7835 verifyFormat("void operator delete(foo) noexcept;"); 7836 verifyFormat("void operator delete(int) noexcept;"); 7837 verifyFormat("void operator delete(int &) noexcept;"); 7838 verifyFormat("void operator delete(int &) volatile noexcept;"); 7839 verifyFormat("void operator delete(int &) const"); 7840 verifyFormat("void operator delete(int &) = default"); 7841 verifyFormat("void operator delete(int &) = delete"); 7842 verifyFormat("void operator delete(int &) [[noreturn]]"); 7843 verifyFormat("void operator delete(int &) throw();"); 7844 verifyFormat("void operator delete(int &) throw(int);"); 7845 verifyFormat("auto operator delete(int &) -> int;"); 7846 verifyFormat("auto operator delete(int &) override"); 7847 verifyFormat("auto operator delete(int &) final"); 7848 7849 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *foo = (aaaaaaaaaaaaaaaaa *)\n" 7850 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 7851 // FIXME: The indentation here is not ideal. 7852 verifyFormat( 7853 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7854 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = (*cccccccccccccccc)\n" 7855 " [dddddddddddddddddddddddddddddddddddddddddddddddddddddddd];"); 7856 } 7857 7858 TEST_F(FormatTest, FormatsFunctionTypes) { 7859 verifyFormat("A<bool()> a;"); 7860 verifyFormat("A<SomeType()> a;"); 7861 verifyFormat("A<void (*)(int, std::string)> a;"); 7862 verifyFormat("A<void *(int)>;"); 7863 verifyFormat("void *(*a)(int *, SomeType *);"); 7864 verifyFormat("int (*func)(void *);"); 7865 verifyFormat("void f() { int (*func)(void *); }"); 7866 verifyFormat("template <class CallbackClass>\n" 7867 "using MyCallback = void (CallbackClass::*)(SomeObject *Data);"); 7868 7869 verifyGoogleFormat("A<void*(int*, SomeType*)>;"); 7870 verifyGoogleFormat("void* (*a)(int);"); 7871 verifyGoogleFormat( 7872 "template <class CallbackClass>\n" 7873 "using MyCallback = void (CallbackClass::*)(SomeObject* Data);"); 7874 7875 // Other constructs can look somewhat like function types: 7876 verifyFormat("A<sizeof(*x)> a;"); 7877 verifyFormat("#define DEREF_AND_CALL_F(x) f(*x)"); 7878 verifyFormat("some_var = function(*some_pointer_var)[0];"); 7879 verifyFormat("void f() { function(*some_pointer_var)[0] = 10; }"); 7880 verifyFormat("int x = f(&h)();"); 7881 verifyFormat("returnsFunction(¶m1, ¶m2)(param);"); 7882 verifyFormat("std::function<\n" 7883 " LooooooooooongTemplatedType<\n" 7884 " SomeType>*(\n" 7885 " LooooooooooooooooongType type)>\n" 7886 " function;", 7887 getGoogleStyleWithColumns(40)); 7888 } 7889 7890 TEST_F(FormatTest, FormatsPointersToArrayTypes) { 7891 verifyFormat("A (*foo_)[6];"); 7892 verifyFormat("vector<int> (*foo_)[6];"); 7893 } 7894 7895 TEST_F(FormatTest, BreaksLongVariableDeclarations) { 7896 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7897 " LoooooooooooooooooooooooooooooooooooooooongVariable;"); 7898 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType const\n" 7899 " LoooooooooooooooooooooooooooooooooooooooongVariable;"); 7900 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7901 " *LoooooooooooooooooooooooooooooooooooooooongVariable;"); 7902 7903 // Different ways of ()-initializiation. 7904 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7905 " LoooooooooooooooooooooooooooooooooooooooongVariable(1);"); 7906 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7907 " LoooooooooooooooooooooooooooooooooooooooongVariable(a);"); 7908 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7909 " LoooooooooooooooooooooooooooooooooooooooongVariable({});"); 7910 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7911 " LoooooooooooooooooooooooooooooooooooooongVariable([A a]);"); 7912 7913 // Lambdas should not confuse the variable declaration heuristic. 7914 verifyFormat("LooooooooooooooooongType\n" 7915 " variable(nullptr, [](A *a) {});", 7916 getLLVMStyleWithColumns(40)); 7917 } 7918 7919 TEST_F(FormatTest, BreaksLongDeclarations) { 7920 verifyFormat("typedef LoooooooooooooooooooooooooooooooooooooooongType\n" 7921 " AnotherNameForTheLongType;"); 7922 verifyFormat("typedef LongTemplateType<aaaaaaaaaaaaaaaaaaa()>\n" 7923 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 7924 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7925 "LoooooooooooooooooooooooooooooooongFunctionDeclaration();"); 7926 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType *\n" 7927 "LoooooooooooooooooooooooooooooooongFunctionDeclaration();"); 7928 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7929 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7930 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType MACRO\n" 7931 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7932 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType const\n" 7933 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7934 verifyFormat("decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n" 7935 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7936 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7937 "LooooooooooooooooooooooooooongFunctionDeclaration(T... t);"); 7938 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7939 "LooooooooooooooooooooooooooongFunctionDeclaration(T /*t*/) {}"); 7940 FormatStyle Indented = getLLVMStyle(); 7941 Indented.IndentWrappedFunctionNames = true; 7942 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7943 " LoooooooooooooooooooooooooooooooongFunctionDeclaration();", 7944 Indented); 7945 verifyFormat( 7946 "LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7947 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}", 7948 Indented); 7949 verifyFormat( 7950 "LoooooooooooooooooooooooooooooooooooooooongReturnType const\n" 7951 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}", 7952 Indented); 7953 verifyFormat( 7954 "decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n" 7955 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}", 7956 Indented); 7957 7958 // FIXME: Without the comment, this breaks after "(". 7959 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType // break\n" 7960 " (*LoooooooooooooooooooooooooooongFunctionTypeVarialbe)();", 7961 getGoogleStyle()); 7962 7963 verifyFormat("int *someFunction(int LoooooooooooooooooooongParam1,\n" 7964 " int LoooooooooooooooooooongParam2) {}"); 7965 verifyFormat( 7966 "TypeSpecDecl *TypeSpecDecl::Create(ASTContext &C, DeclContext *DC,\n" 7967 " SourceLocation L, IdentifierIn *II,\n" 7968 " Type *T) {}"); 7969 verifyFormat("ReallyLongReturnType<TemplateParam1, TemplateParam2>\n" 7970 "ReallyReaaallyLongFunctionName(\n" 7971 " const std::string &SomeParameter,\n" 7972 " const SomeType<string, SomeOtherTemplateParameter>\n" 7973 " &ReallyReallyLongParameterName,\n" 7974 " const SomeType<string, SomeOtherTemplateParameter>\n" 7975 " &AnotherLongParameterName) {}"); 7976 verifyFormat("template <typename A>\n" 7977 "SomeLoooooooooooooooooooooongType<\n" 7978 " typename some_namespace::SomeOtherType<A>::Type>\n" 7979 "Function() {}"); 7980 7981 verifyGoogleFormat( 7982 "aaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaa<aaaaaaaaaaaaa, aaaaaaaaaaaa>\n" 7983 " aaaaaaaaaaaaaaaaaaaaaaa;"); 7984 verifyGoogleFormat( 7985 "TypeSpecDecl* TypeSpecDecl::Create(ASTContext& C, DeclContext* DC,\n" 7986 " SourceLocation L) {}"); 7987 verifyGoogleFormat( 7988 "some_namespace::LongReturnType\n" 7989 "long_namespace::SomeVeryLongClass::SomeVeryLongFunction(\n" 7990 " int first_long_parameter, int second_parameter) {}"); 7991 7992 verifyGoogleFormat("template <typename T>\n" 7993 "aaaaaaaa::aaaaa::aaaaaa<T, aaaaaaaaaaaaaaaaaaaaaaaaa>\n" 7994 "aaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaa() {}"); 7995 verifyGoogleFormat("A<A<A>> aaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 7996 " int aaaaaaaaaaaaaaaaaaaaaaa);"); 7997 7998 verifyFormat("typedef size_t (*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n" 7999 " const aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 8000 " *aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 8001 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 8002 " vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n" 8003 " aaaaaaaaaaaaaaaaaaaaaaaa);"); 8004 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 8005 " vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n" 8006 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>>\n" 8007 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 8008 8009 verifyFormat("template <typename T> // Templates on own line.\n" 8010 "static int // Some comment.\n" 8011 "MyFunction(int a);", 8012 getLLVMStyle()); 8013 } 8014 8015 TEST_F(FormatTest, FormatsArrays) { 8016 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaaaaaaaaaa]\n" 8017 " [bbbbbbbbbbbbbbbbbbbbbbbbb] = c;"); 8018 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaa(aaaaaaaaaaaa)]\n" 8019 " [bbbbbbbbbbb(bbbbbbbbbbbb)] = c;"); 8020 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaa &&\n" 8021 " aaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaa][aaaaaaaaaaaaa]) {\n}"); 8022 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 8023 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;"); 8024 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 8025 " [a][bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = cccccccc;"); 8026 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 8027 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n" 8028 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;"); 8029 verifyFormat( 8030 "llvm::outs() << \"aaaaaaaaaaaa: \"\n" 8031 " << (*aaaaaaaiaaaaaaa)[aaaaaaaaaaaaaaaaaaaaaaaaa]\n" 8032 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa];"); 8033 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaa][a]\n" 8034 " .aaaaaaaaaaaaaaaaaaaaaa();"); 8035 8036 verifyGoogleFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<int>\n" 8037 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaa];"); 8038 verifyFormat( 8039 "aaaaaaaaaaa aaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaa->aaaaaaaaa[0]\n" 8040 " .aaaaaaa[0]\n" 8041 " .aaaaaaaaaaaaaaaaaaaaaa();"); 8042 verifyFormat("a[::b::c];"); 8043 8044 verifyNoCrash("a[,Y?)]", getLLVMStyleWithColumns(10)); 8045 8046 FormatStyle NoColumnLimit = getLLVMStyleWithColumns(0); 8047 verifyFormat("aaaaa[bbbbbb].cccccc()", NoColumnLimit); 8048 } 8049 8050 TEST_F(FormatTest, LineStartsWithSpecialCharacter) { 8051 verifyFormat("(a)->b();"); 8052 verifyFormat("--a;"); 8053 } 8054 8055 TEST_F(FormatTest, HandlesIncludeDirectives) { 8056 verifyFormat("#include <string>\n" 8057 "#include <a/b/c.h>\n" 8058 "#include \"a/b/string\"\n" 8059 "#include \"string.h\"\n" 8060 "#include \"string.h\"\n" 8061 "#include <a-a>\n" 8062 "#include < path with space >\n" 8063 "#include_next <test.h>" 8064 "#include \"abc.h\" // this is included for ABC\n" 8065 "#include \"some long include\" // with a comment\n" 8066 "#include \"some very long include path\"\n" 8067 "#include <some/very/long/include/path>\n", 8068 getLLVMStyleWithColumns(35)); 8069 EXPECT_EQ("#include \"a.h\"", format("#include \"a.h\"")); 8070 EXPECT_EQ("#include <a>", format("#include<a>")); 8071 8072 verifyFormat("#import <string>"); 8073 verifyFormat("#import <a/b/c.h>"); 8074 verifyFormat("#import \"a/b/string\""); 8075 verifyFormat("#import \"string.h\""); 8076 verifyFormat("#import \"string.h\""); 8077 verifyFormat("#if __has_include(<strstream>)\n" 8078 "#include <strstream>\n" 8079 "#endif"); 8080 8081 verifyFormat("#define MY_IMPORT <a/b>"); 8082 8083 verifyFormat("#if __has_include(<a/b>)"); 8084 verifyFormat("#if __has_include_next(<a/b>)"); 8085 verifyFormat("#define F __has_include(<a/b>)"); 8086 verifyFormat("#define F __has_include_next(<a/b>)"); 8087 8088 // Protocol buffer definition or missing "#". 8089 verifyFormat("import \"aaaaaaaaaaaaaaaaa/aaaaaaaaaaaaaaa\";", 8090 getLLVMStyleWithColumns(30)); 8091 8092 FormatStyle Style = getLLVMStyle(); 8093 Style.AlwaysBreakBeforeMultilineStrings = true; 8094 Style.ColumnLimit = 0; 8095 verifyFormat("#import \"abc.h\"", Style); 8096 8097 // But 'import' might also be a regular C++ namespace. 8098 verifyFormat("import::SomeFunction(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 8099 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 8100 } 8101 8102 //===----------------------------------------------------------------------===// 8103 // Error recovery tests. 8104 //===----------------------------------------------------------------------===// 8105 8106 TEST_F(FormatTest, IncompleteParameterLists) { 8107 FormatStyle NoBinPacking = getLLVMStyle(); 8108 NoBinPacking.BinPackParameters = false; 8109 verifyFormat("void aaaaaaaaaaaaaaaaaa(int level,\n" 8110 " double *min_x,\n" 8111 " double *max_x,\n" 8112 " double *min_y,\n" 8113 " double *max_y,\n" 8114 " double *min_z,\n" 8115 " double *max_z, ) {}", 8116 NoBinPacking); 8117 } 8118 8119 TEST_F(FormatTest, IncorrectCodeTrailingStuff) { 8120 verifyFormat("void f() { return; }\n42"); 8121 verifyFormat("void f() {\n" 8122 " if (0)\n" 8123 " return;\n" 8124 "}\n" 8125 "42"); 8126 verifyFormat("void f() { return }\n42"); 8127 verifyFormat("void f() {\n" 8128 " if (0)\n" 8129 " return\n" 8130 "}\n" 8131 "42"); 8132 } 8133 8134 TEST_F(FormatTest, IncorrectCodeMissingSemicolon) { 8135 EXPECT_EQ("void f() { return }", format("void f ( ) { return }")); 8136 EXPECT_EQ("void f() {\n" 8137 " if (a)\n" 8138 " return\n" 8139 "}", 8140 format("void f ( ) { if ( a ) return }")); 8141 EXPECT_EQ("namespace N {\n" 8142 "void f()\n" 8143 "}", 8144 format("namespace N { void f() }")); 8145 EXPECT_EQ("namespace N {\n" 8146 "void f() {}\n" 8147 "void g()\n" 8148 "} // namespace N", 8149 format("namespace N { void f( ) { } void g( ) }")); 8150 } 8151 8152 TEST_F(FormatTest, IndentationWithinColumnLimitNotPossible) { 8153 verifyFormat("int aaaaaaaa =\n" 8154 " // Overlylongcomment\n" 8155 " b;", 8156 getLLVMStyleWithColumns(20)); 8157 verifyFormat("function(\n" 8158 " ShortArgument,\n" 8159 " LoooooooooooongArgument);\n", 8160 getLLVMStyleWithColumns(20)); 8161 } 8162 8163 TEST_F(FormatTest, IncorrectAccessSpecifier) { 8164 verifyFormat("public:"); 8165 verifyFormat("class A {\n" 8166 "public\n" 8167 " void f() {}\n" 8168 "};"); 8169 verifyFormat("public\n" 8170 "int qwerty;"); 8171 verifyFormat("public\n" 8172 "B {}"); 8173 verifyFormat("public\n" 8174 "{}"); 8175 verifyFormat("public\n" 8176 "B { int x; }"); 8177 } 8178 8179 TEST_F(FormatTest, IncorrectCodeUnbalancedBraces) { 8180 verifyFormat("{"); 8181 verifyFormat("#})"); 8182 verifyNoCrash("(/**/[:!] ?[)."); 8183 } 8184 8185 TEST_F(FormatTest, IncorrectUnbalancedBracesInMacrosWithUnicode) { 8186 // Found by oss-fuzz: 8187 // https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=8212 8188 FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp); 8189 Style.ColumnLimit = 60; 8190 verifyNoCrash( 8191 "\x23\x47\xff\x20\x28\xff\x3c\xff\x3f\xff\x20\x2f\x7b\x7a\xff\x20" 8192 "\xff\xff\xff\xca\xb5\xff\xff\xff\xff\x3a\x7b\x7d\xff\x20\xff\x20" 8193 "\xff\x74\xff\x20\x7d\x7d\xff\x7b\x3a\xff\x20\x71\xff\x20\xff\x0a", 8194 Style); 8195 } 8196 8197 TEST_F(FormatTest, IncorrectCodeDoNoWhile) { 8198 verifyFormat("do {\n}"); 8199 verifyFormat("do {\n}\n" 8200 "f();"); 8201 verifyFormat("do {\n}\n" 8202 "wheeee(fun);"); 8203 verifyFormat("do {\n" 8204 " f();\n" 8205 "}"); 8206 } 8207 8208 TEST_F(FormatTest, IncorrectCodeMissingParens) { 8209 verifyFormat("if {\n foo;\n foo();\n}"); 8210 verifyFormat("switch {\n foo;\n foo();\n}"); 8211 verifyIncompleteFormat("for {\n foo;\n foo();\n}"); 8212 verifyFormat("while {\n foo;\n foo();\n}"); 8213 verifyFormat("do {\n foo;\n foo();\n} while;"); 8214 } 8215 8216 TEST_F(FormatTest, DoesNotTouchUnwrappedLinesWithErrors) { 8217 verifyIncompleteFormat("namespace {\n" 8218 "class Foo { Foo (\n" 8219 "};\n" 8220 "} // namespace"); 8221 } 8222 8223 TEST_F(FormatTest, IncorrectCodeErrorDetection) { 8224 EXPECT_EQ("{\n {}\n", format("{\n{\n}\n")); 8225 EXPECT_EQ("{\n {}\n", format("{\n {\n}\n")); 8226 EXPECT_EQ("{\n {}\n", format("{\n {\n }\n")); 8227 EXPECT_EQ("{\n {}\n}\n}\n", format("{\n {\n }\n }\n}\n")); 8228 8229 EXPECT_EQ("{\n" 8230 " {\n" 8231 " breakme(\n" 8232 " qwe);\n" 8233 " }\n", 8234 format("{\n" 8235 " {\n" 8236 " breakme(qwe);\n" 8237 "}\n", 8238 getLLVMStyleWithColumns(10))); 8239 } 8240 8241 TEST_F(FormatTest, LayoutCallsInsideBraceInitializers) { 8242 verifyFormat("int x = {\n" 8243 " avariable,\n" 8244 " b(alongervariable)};", 8245 getLLVMStyleWithColumns(25)); 8246 } 8247 8248 TEST_F(FormatTest, LayoutBraceInitializersInReturnStatement) { 8249 verifyFormat("return (a)(b){1, 2, 3};"); 8250 } 8251 8252 TEST_F(FormatTest, LayoutCxx11BraceInitializers) { 8253 verifyFormat("vector<int> x{1, 2, 3, 4};"); 8254 verifyFormat("vector<int> x{\n" 8255 " 1,\n" 8256 " 2,\n" 8257 " 3,\n" 8258 " 4,\n" 8259 "};"); 8260 verifyFormat("vector<T> x{{}, {}, {}, {}};"); 8261 verifyFormat("f({1, 2});"); 8262 verifyFormat("auto v = Foo{-1};"); 8263 verifyFormat("f({1, 2}, {{2, 3}, {4, 5}}, c, {d});"); 8264 verifyFormat("Class::Class : member{1, 2, 3} {}"); 8265 verifyFormat("new vector<int>{1, 2, 3};"); 8266 verifyFormat("new int[3]{1, 2, 3};"); 8267 verifyFormat("new int{1};"); 8268 verifyFormat("return {arg1, arg2};"); 8269 verifyFormat("return {arg1, SomeType{parameter}};"); 8270 verifyFormat("int count = set<int>{f(), g(), h()}.size();"); 8271 verifyFormat("new T{arg1, arg2};"); 8272 verifyFormat("f(MyMap[{composite, key}]);"); 8273 verifyFormat("class Class {\n" 8274 " T member = {arg1, arg2};\n" 8275 "};"); 8276 verifyFormat("vector<int> foo = {::SomeGlobalFunction()};"); 8277 verifyFormat("const struct A a = {.a = 1, .b = 2};"); 8278 verifyFormat("const struct A a = {[0] = 1, [1] = 2};"); 8279 verifyFormat("static_assert(std::is_integral<int>{} + 0, \"\");"); 8280 verifyFormat("int a = std::is_integral<int>{} + 0;"); 8281 8282 verifyFormat("int foo(int i) { return fo1{}(i); }"); 8283 verifyFormat("int foo(int i) { return fo1{}(i); }"); 8284 verifyFormat("auto i = decltype(x){};"); 8285 verifyFormat("std::vector<int> v = {1, 0 /* comment */};"); 8286 verifyFormat("Node n{1, Node{1000}, //\n" 8287 " 2};"); 8288 verifyFormat("Aaaa aaaaaaa{\n" 8289 " {\n" 8290 " aaaa,\n" 8291 " },\n" 8292 "};"); 8293 verifyFormat("class C : public D {\n" 8294 " SomeClass SC{2};\n" 8295 "};"); 8296 verifyFormat("class C : public A {\n" 8297 " class D : public B {\n" 8298 " void f() { int i{2}; }\n" 8299 " };\n" 8300 "};"); 8301 verifyFormat("#define A {a, a},"); 8302 8303 // Avoid breaking between equal sign and opening brace 8304 FormatStyle AvoidBreakingFirstArgument = getLLVMStyle(); 8305 AvoidBreakingFirstArgument.PenaltyBreakBeforeFirstCallParameter = 200; 8306 verifyFormat("const std::unordered_map<std::string, int> MyHashTable =\n" 8307 " {{\"aaaaaaaaaaaaaaaaaaaaa\", 0},\n" 8308 " {\"bbbbbbbbbbbbbbbbbbbbb\", 1},\n" 8309 " {\"ccccccccccccccccccccc\", 2}};", 8310 AvoidBreakingFirstArgument); 8311 8312 // Binpacking only if there is no trailing comma 8313 verifyFormat("const Aaaaaa aaaaa = {aaaaaaaaaa, bbbbbbbbbb,\n" 8314 " cccccccccc, dddddddddd};", 8315 getLLVMStyleWithColumns(50)); 8316 verifyFormat("const Aaaaaa aaaaa = {\n" 8317 " aaaaaaaaaaa,\n" 8318 " bbbbbbbbbbb,\n" 8319 " ccccccccccc,\n" 8320 " ddddddddddd,\n" 8321 "};", 8322 getLLVMStyleWithColumns(50)); 8323 8324 // Cases where distinguising braced lists and blocks is hard. 8325 verifyFormat("vector<int> v{12} GUARDED_BY(mutex);"); 8326 verifyFormat("void f() {\n" 8327 " return; // comment\n" 8328 "}\n" 8329 "SomeType t;"); 8330 verifyFormat("void f() {\n" 8331 " if (a) {\n" 8332 " f();\n" 8333 " }\n" 8334 "}\n" 8335 "SomeType t;"); 8336 8337 // In combination with BinPackArguments = false. 8338 FormatStyle NoBinPacking = getLLVMStyle(); 8339 NoBinPacking.BinPackArguments = false; 8340 verifyFormat("const Aaaaaa aaaaa = {aaaaa,\n" 8341 " bbbbb,\n" 8342 " ccccc,\n" 8343 " ddddd,\n" 8344 " eeeee,\n" 8345 " ffffff,\n" 8346 " ggggg,\n" 8347 " hhhhhh,\n" 8348 " iiiiii,\n" 8349 " jjjjjj,\n" 8350 " kkkkkk};", 8351 NoBinPacking); 8352 verifyFormat("const Aaaaaa aaaaa = {\n" 8353 " aaaaa,\n" 8354 " bbbbb,\n" 8355 " ccccc,\n" 8356 " ddddd,\n" 8357 " eeeee,\n" 8358 " ffffff,\n" 8359 " ggggg,\n" 8360 " hhhhhh,\n" 8361 " iiiiii,\n" 8362 " jjjjjj,\n" 8363 " kkkkkk,\n" 8364 "};", 8365 NoBinPacking); 8366 verifyFormat( 8367 "const Aaaaaa aaaaa = {\n" 8368 " aaaaa, bbbbb, ccccc, ddddd, eeeee, ffffff, ggggg, hhhhhh,\n" 8369 " iiiiii, jjjjjj, kkkkkk, aaaaa, bbbbb, ccccc, ddddd, eeeee,\n" 8370 " ffffff, ggggg, hhhhhh, iiiiii, jjjjjj, kkkkkk,\n" 8371 "};", 8372 NoBinPacking); 8373 8374 NoBinPacking.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 8375 EXPECT_EQ("static uint8 CddDp83848Reg[] = {\n" 8376 " CDDDP83848_BMCR_REGISTER,\n" 8377 " CDDDP83848_BMSR_REGISTER,\n" 8378 " CDDDP83848_RBR_REGISTER};", 8379 format("static uint8 CddDp83848Reg[] = {CDDDP83848_BMCR_REGISTER,\n" 8380 " CDDDP83848_BMSR_REGISTER,\n" 8381 " CDDDP83848_RBR_REGISTER};", 8382 NoBinPacking)); 8383 8384 // FIXME: The alignment of these trailing comments might be bad. Then again, 8385 // this might be utterly useless in real code. 8386 verifyFormat("Constructor::Constructor()\n" 8387 " : some_value{ //\n" 8388 " aaaaaaa, //\n" 8389 " bbbbbbb} {}"); 8390 8391 // In braced lists, the first comment is always assumed to belong to the 8392 // first element. Thus, it can be moved to the next or previous line as 8393 // appropriate. 8394 EXPECT_EQ("function({// First element:\n" 8395 " 1,\n" 8396 " // Second element:\n" 8397 " 2});", 8398 format("function({\n" 8399 " // First element:\n" 8400 " 1,\n" 8401 " // Second element:\n" 8402 " 2});")); 8403 EXPECT_EQ("std::vector<int> MyNumbers{\n" 8404 " // First element:\n" 8405 " 1,\n" 8406 " // Second element:\n" 8407 " 2};", 8408 format("std::vector<int> MyNumbers{// First element:\n" 8409 " 1,\n" 8410 " // Second element:\n" 8411 " 2};", 8412 getLLVMStyleWithColumns(30))); 8413 // A trailing comma should still lead to an enforced line break and no 8414 // binpacking. 8415 EXPECT_EQ("vector<int> SomeVector = {\n" 8416 " // aaa\n" 8417 " 1,\n" 8418 " 2,\n" 8419 "};", 8420 format("vector<int> SomeVector = { // aaa\n" 8421 " 1, 2, };")); 8422 8423 // C++11 brace initializer list l-braces should not be treated any differently 8424 // when breaking before lambda bodies is enabled 8425 FormatStyle BreakBeforeLambdaBody = getLLVMStyle(); 8426 BreakBeforeLambdaBody.BreakBeforeBraces = FormatStyle::BS_Custom; 8427 BreakBeforeLambdaBody.BraceWrapping.BeforeLambdaBody = true; 8428 BreakBeforeLambdaBody.AlwaysBreakBeforeMultilineStrings = true; 8429 verifyFormat( 8430 "std::runtime_error{\n" 8431 " \"Long string which will force a break onto the next line...\"};", 8432 BreakBeforeLambdaBody); 8433 8434 FormatStyle ExtraSpaces = getLLVMStyle(); 8435 ExtraSpaces.Cpp11BracedListStyle = false; 8436 ExtraSpaces.ColumnLimit = 75; 8437 verifyFormat("vector<int> x{ 1, 2, 3, 4 };", ExtraSpaces); 8438 verifyFormat("vector<T> x{ {}, {}, {}, {} };", ExtraSpaces); 8439 verifyFormat("f({ 1, 2 });", ExtraSpaces); 8440 verifyFormat("auto v = Foo{ 1 };", ExtraSpaces); 8441 verifyFormat("f({ 1, 2 }, { { 2, 3 }, { 4, 5 } }, c, { d });", ExtraSpaces); 8442 verifyFormat("Class::Class : member{ 1, 2, 3 } {}", ExtraSpaces); 8443 verifyFormat("new vector<int>{ 1, 2, 3 };", ExtraSpaces); 8444 verifyFormat("new int[3]{ 1, 2, 3 };", ExtraSpaces); 8445 verifyFormat("return { arg1, arg2 };", ExtraSpaces); 8446 verifyFormat("return { arg1, SomeType{ parameter } };", ExtraSpaces); 8447 verifyFormat("int count = set<int>{ f(), g(), h() }.size();", ExtraSpaces); 8448 verifyFormat("new T{ arg1, arg2 };", ExtraSpaces); 8449 verifyFormat("f(MyMap[{ composite, key }]);", ExtraSpaces); 8450 verifyFormat("class Class {\n" 8451 " T member = { arg1, arg2 };\n" 8452 "};", 8453 ExtraSpaces); 8454 verifyFormat( 8455 "foo = aaaaaaaaaaa ? vector<int>{ aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 8456 " aaaaaaaaaaaaaaaaaaaa, aaaaa }\n" 8457 " : vector<int>{ bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" 8458 " bbbbbbbbbbbbbbbbbbbb, bbbbb };", 8459 ExtraSpaces); 8460 verifyFormat("DoSomethingWithVector({} /* No data */);", ExtraSpaces); 8461 verifyFormat("DoSomethingWithVector({ {} /* No data */ }, { { 1, 2 } });", 8462 ExtraSpaces); 8463 verifyFormat( 8464 "someFunction(OtherParam,\n" 8465 " BracedList{ // comment 1 (Forcing interesting break)\n" 8466 " param1, param2,\n" 8467 " // comment 2\n" 8468 " param3, param4 });", 8469 ExtraSpaces); 8470 verifyFormat( 8471 "std::this_thread::sleep_for(\n" 8472 " std::chrono::nanoseconds{ std::chrono::seconds{ 1 } } / 5);", 8473 ExtraSpaces); 8474 verifyFormat("std::vector<MyValues> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa{\n" 8475 " aaaaaaa,\n" 8476 " aaaaaaaaaa,\n" 8477 " aaaaa,\n" 8478 " aaaaaaaaaaaaaaa,\n" 8479 " aaa,\n" 8480 " aaaaaaaaaa,\n" 8481 " a,\n" 8482 " aaaaaaaaaaaaaaaaaaaaa,\n" 8483 " aaaaaaaaaaaa,\n" 8484 " aaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaa,\n" 8485 " aaaaaaa,\n" 8486 " a};"); 8487 verifyFormat("vector<int> foo = { ::SomeGlobalFunction() };", ExtraSpaces); 8488 verifyFormat("const struct A a = { .a = 1, .b = 2 };", ExtraSpaces); 8489 verifyFormat("const struct A a = { [0] = 1, [1] = 2 };", ExtraSpaces); 8490 8491 // Avoid breaking between initializer/equal sign and opening brace 8492 ExtraSpaces.PenaltyBreakBeforeFirstCallParameter = 200; 8493 verifyFormat("const std::unordered_map<std::string, int> MyHashTable = {\n" 8494 " { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n" 8495 " { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n" 8496 " { \"ccccccccccccccccccccc\", 2 }\n" 8497 "};", 8498 ExtraSpaces); 8499 verifyFormat("const std::unordered_map<std::string, int> MyHashTable{\n" 8500 " { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n" 8501 " { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n" 8502 " { \"ccccccccccccccccccccc\", 2 }\n" 8503 "};", 8504 ExtraSpaces); 8505 8506 FormatStyle SpaceBeforeBrace = getLLVMStyle(); 8507 SpaceBeforeBrace.SpaceBeforeCpp11BracedList = true; 8508 verifyFormat("vector<int> x {1, 2, 3, 4};", SpaceBeforeBrace); 8509 verifyFormat("f({}, {{}, {}}, MyMap[{k, v}]);", SpaceBeforeBrace); 8510 8511 FormatStyle SpaceBetweenBraces = getLLVMStyle(); 8512 SpaceBetweenBraces.SpacesInAngles = true; 8513 SpaceBetweenBraces.SpacesInParentheses = true; 8514 SpaceBetweenBraces.SpacesInSquareBrackets = true; 8515 verifyFormat("vector< int > x{ 1, 2, 3, 4 };", SpaceBetweenBraces); 8516 verifyFormat("f( {}, { {}, {} }, MyMap[ { k, v } ] );", SpaceBetweenBraces); 8517 verifyFormat("vector< int > x{ // comment 1\n" 8518 " 1, 2, 3, 4 };", 8519 SpaceBetweenBraces); 8520 SpaceBetweenBraces.ColumnLimit = 20; 8521 EXPECT_EQ("vector< int > x{\n" 8522 " 1, 2, 3, 4 };", 8523 format("vector<int>x{1,2,3,4};", SpaceBetweenBraces)); 8524 SpaceBetweenBraces.ColumnLimit = 24; 8525 EXPECT_EQ("vector< int > x{ 1, 2,\n" 8526 " 3, 4 };", 8527 format("vector<int>x{1,2,3,4};", SpaceBetweenBraces)); 8528 EXPECT_EQ("vector< int > x{\n" 8529 " 1,\n" 8530 " 2,\n" 8531 " 3,\n" 8532 " 4,\n" 8533 "};", 8534 format("vector<int>x{1,2,3,4,};", SpaceBetweenBraces)); 8535 verifyFormat("vector< int > x{};", SpaceBetweenBraces); 8536 SpaceBetweenBraces.SpaceInEmptyParentheses = true; 8537 verifyFormat("vector< int > x{ };", SpaceBetweenBraces); 8538 } 8539 8540 TEST_F(FormatTest, FormatSpacesInAngles) { 8541 FormatStyle SpaceInAngles = getLLVMStyle(); 8542 SpaceInAngles.SpacesInAngles = true; 8543 verifyFormat("vector< ::std::string > x1;", SpaceInAngles); 8544 verifyFormat("Foo< int, Bar > x2;", SpaceInAngles); 8545 verifyFormat("Foo< ::int, ::Bar > x3;", SpaceInAngles); 8546 8547 SpaceInAngles.SpacesInAngles = false; 8548 verifyFormat("vector<::std::string> x4;", SpaceInAngles); 8549 verifyFormat("vector<int> x5;", SpaceInAngles); 8550 verifyFormat("Foo<int, Bar> x6;", SpaceInAngles); 8551 verifyFormat("Foo<::int, ::Bar> x7;", SpaceInAngles); 8552 } 8553 8554 TEST_F(FormatTest, FormatsBracedListsInColumnLayout) { 8555 verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8556 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8557 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8558 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8559 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8560 " 1, 22, 333, 4444, 55555, 666666, 7777777};"); 8561 verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777, //\n" 8562 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8563 " 1, 22, 333, 4444, 55555, //\n" 8564 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8565 " 1, 22, 333, 4444, 55555, 666666, 7777777};"); 8566 verifyFormat( 8567 "vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8568 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8569 " 1, 22, 333, 4444, 55555, 666666, // comment\n" 8570 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 8571 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 8572 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 8573 " 7777777};"); 8574 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n" 8575 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n" 8576 " X86::R8, X86::R9, X86::R10, X86::R11, 0};"); 8577 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n" 8578 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n" 8579 " // Separating comment.\n" 8580 " X86::R8, X86::R9, X86::R10, X86::R11, 0};"); 8581 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n" 8582 " // Leading comment\n" 8583 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n" 8584 " X86::R8, X86::R9, X86::R10, X86::R11, 0};"); 8585 verifyFormat("vector<int> x = {1, 1, 1, 1,\n" 8586 " 1, 1, 1, 1};", 8587 getLLVMStyleWithColumns(39)); 8588 verifyFormat("vector<int> x = {1, 1, 1, 1,\n" 8589 " 1, 1, 1, 1};", 8590 getLLVMStyleWithColumns(38)); 8591 verifyFormat("vector<int> aaaaaaaaaaaaaaaaaaaaaa = {\n" 8592 " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};", 8593 getLLVMStyleWithColumns(43)); 8594 verifyFormat( 8595 "static unsigned SomeValues[10][3] = {\n" 8596 " {1, 4, 0}, {4, 9, 0}, {4, 5, 9}, {8, 5, 4}, {1, 8, 4},\n" 8597 " {10, 1, 6}, {11, 0, 9}, {2, 11, 9}, {5, 2, 9}, {11, 2, 7}};"); 8598 verifyFormat("static auto fields = new vector<string>{\n" 8599 " \"aaaaaaaaaaaaa\",\n" 8600 " \"aaaaaaaaaaaaa\",\n" 8601 " \"aaaaaaaaaaaa\",\n" 8602 " \"aaaaaaaaaaaaaa\",\n" 8603 " \"aaaaaaaaaaaaaaaaaaaaaaaaa\",\n" 8604 " \"aaaaaaaaaaaa\",\n" 8605 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",\n" 8606 "};"); 8607 verifyFormat("vector<int> x = {1, 2, 3, 4, aaaaaaaaaaaaaaaaa, 6};"); 8608 verifyFormat("vector<int> x = {1, aaaaaaaaaaaaaaaaaaaaaa,\n" 8609 " 2, bbbbbbbbbbbbbbbbbbbbbb,\n" 8610 " 3, cccccccccccccccccccccc};", 8611 getLLVMStyleWithColumns(60)); 8612 8613 // Trailing commas. 8614 verifyFormat("vector<int> x = {\n" 8615 " 1, 1, 1, 1, 1, 1, 1, 1,\n" 8616 "};", 8617 getLLVMStyleWithColumns(39)); 8618 verifyFormat("vector<int> x = {\n" 8619 " 1, 1, 1, 1, 1, 1, 1, 1, //\n" 8620 "};", 8621 getLLVMStyleWithColumns(39)); 8622 verifyFormat("vector<int> x = {1, 1, 1, 1,\n" 8623 " 1, 1, 1, 1,\n" 8624 " /**/ /**/};", 8625 getLLVMStyleWithColumns(39)); 8626 8627 // Trailing comment in the first line. 8628 verifyFormat("vector<int> iiiiiiiiiiiiiii = { //\n" 8629 " 1111111111, 2222222222, 33333333333, 4444444444, //\n" 8630 " 111111111, 222222222, 3333333333, 444444444, //\n" 8631 " 11111111, 22222222, 333333333, 44444444};"); 8632 // Trailing comment in the last line. 8633 verifyFormat("int aaaaa[] = {\n" 8634 " 1, 2, 3, // comment\n" 8635 " 4, 5, 6 // comment\n" 8636 "};"); 8637 8638 // With nested lists, we should either format one item per line or all nested 8639 // lists one on line. 8640 // FIXME: For some nested lists, we can do better. 8641 verifyFormat("return {{aaaaaaaaaaaaaaaaaaaaa},\n" 8642 " {aaaaaaaaaaaaaaaaaaa},\n" 8643 " {aaaaaaaaaaaaaaaaaaaaa},\n" 8644 " {aaaaaaaaaaaaaaaaa}};", 8645 getLLVMStyleWithColumns(60)); 8646 verifyFormat( 8647 "SomeStruct my_struct_array = {\n" 8648 " {aaaaaa, aaaaaaaa, aaaaaaaaaa, aaaaaaaaa, aaaaaaaaa, aaaaaaaaaa,\n" 8649 " aaaaaaaaaaaaa, aaaaaaa, aaa},\n" 8650 " {aaa, aaa},\n" 8651 " {aaa, aaa},\n" 8652 " {aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaa},\n" 8653 " {aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaa,\n" 8654 " aaaaaaaaaaaa, a, aaaaaaaaaa, aaaaaaaaa, aaa}};"); 8655 8656 // No column layout should be used here. 8657 verifyFormat("aaaaaaaaaaaaaaa = {aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0, 0,\n" 8658 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb};"); 8659 8660 verifyNoCrash("a<,"); 8661 8662 // No braced initializer here. 8663 verifyFormat("void f() {\n" 8664 " struct Dummy {};\n" 8665 " f(v);\n" 8666 "}"); 8667 8668 // Long lists should be formatted in columns even if they are nested. 8669 verifyFormat( 8670 "vector<int> x = function({1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8671 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8672 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8673 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8674 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8675 " 1, 22, 333, 4444, 55555, 666666, 7777777});"); 8676 8677 // Allow "single-column" layout even if that violates the column limit. There 8678 // isn't going to be a better way. 8679 verifyFormat("std::vector<int> a = {\n" 8680 " aaaaaaaa,\n" 8681 " aaaaaaaa,\n" 8682 " aaaaaaaa,\n" 8683 " aaaaaaaa,\n" 8684 " aaaaaaaaaa,\n" 8685 " aaaaaaaa,\n" 8686 " aaaaaaaaaaaaaaaaaaaaaaaaaaa};", 8687 getLLVMStyleWithColumns(30)); 8688 verifyFormat("vector<int> aaaa = {\n" 8689 " aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 8690 " aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 8691 " aaaaaa.aaaaaaa,\n" 8692 " aaaaaa.aaaaaaa,\n" 8693 " aaaaaa.aaaaaaa,\n" 8694 " aaaaaa.aaaaaaa,\n" 8695 "};"); 8696 8697 // Don't create hanging lists. 8698 verifyFormat("someFunction(Param, {List1, List2,\n" 8699 " List3});", 8700 getLLVMStyleWithColumns(35)); 8701 verifyFormat("someFunction(Param, Param,\n" 8702 " {List1, List2,\n" 8703 " List3});", 8704 getLLVMStyleWithColumns(35)); 8705 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa, {},\n" 8706 " aaaaaaaaaaaaaaaaaaaaaaa);"); 8707 } 8708 8709 TEST_F(FormatTest, PullTrivialFunctionDefinitionsIntoSingleLine) { 8710 FormatStyle DoNotMerge = getLLVMStyle(); 8711 DoNotMerge.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 8712 8713 verifyFormat("void f() { return 42; }"); 8714 verifyFormat("void f() {\n" 8715 " return 42;\n" 8716 "}", 8717 DoNotMerge); 8718 verifyFormat("void f() {\n" 8719 " // Comment\n" 8720 "}"); 8721 verifyFormat("{\n" 8722 "#error {\n" 8723 " int a;\n" 8724 "}"); 8725 verifyFormat("{\n" 8726 " int a;\n" 8727 "#error {\n" 8728 "}"); 8729 verifyFormat("void f() {} // comment"); 8730 verifyFormat("void f() { int a; } // comment"); 8731 verifyFormat("void f() {\n" 8732 "} // comment", 8733 DoNotMerge); 8734 verifyFormat("void f() {\n" 8735 " int a;\n" 8736 "} // comment", 8737 DoNotMerge); 8738 verifyFormat("void f() {\n" 8739 "} // comment", 8740 getLLVMStyleWithColumns(15)); 8741 8742 verifyFormat("void f() { return 42; }", getLLVMStyleWithColumns(23)); 8743 verifyFormat("void f() {\n return 42;\n}", getLLVMStyleWithColumns(22)); 8744 8745 verifyFormat("void f() {}", getLLVMStyleWithColumns(11)); 8746 verifyFormat("void f() {\n}", getLLVMStyleWithColumns(10)); 8747 verifyFormat("class C {\n" 8748 " C()\n" 8749 " : iiiiiiii(nullptr),\n" 8750 " kkkkkkk(nullptr),\n" 8751 " mmmmmmm(nullptr),\n" 8752 " nnnnnnn(nullptr) {}\n" 8753 "};", 8754 getGoogleStyle()); 8755 8756 FormatStyle NoColumnLimit = getLLVMStyle(); 8757 NoColumnLimit.ColumnLimit = 0; 8758 EXPECT_EQ("A() : b(0) {}", format("A():b(0){}", NoColumnLimit)); 8759 EXPECT_EQ("class C {\n" 8760 " A() : b(0) {}\n" 8761 "};", 8762 format("class C{A():b(0){}};", NoColumnLimit)); 8763 EXPECT_EQ("A()\n" 8764 " : b(0) {\n" 8765 "}", 8766 format("A()\n:b(0)\n{\n}", NoColumnLimit)); 8767 8768 FormatStyle DoNotMergeNoColumnLimit = NoColumnLimit; 8769 DoNotMergeNoColumnLimit.AllowShortFunctionsOnASingleLine = 8770 FormatStyle::SFS_None; 8771 EXPECT_EQ("A()\n" 8772 " : b(0) {\n" 8773 "}", 8774 format("A():b(0){}", DoNotMergeNoColumnLimit)); 8775 EXPECT_EQ("A()\n" 8776 " : b(0) {\n" 8777 "}", 8778 format("A()\n:b(0)\n{\n}", DoNotMergeNoColumnLimit)); 8779 8780 verifyFormat("#define A \\\n" 8781 " void f() { \\\n" 8782 " int i; \\\n" 8783 " }", 8784 getLLVMStyleWithColumns(20)); 8785 verifyFormat("#define A \\\n" 8786 " void f() { int i; }", 8787 getLLVMStyleWithColumns(21)); 8788 verifyFormat("#define A \\\n" 8789 " void f() { \\\n" 8790 " int i; \\\n" 8791 " } \\\n" 8792 " int j;", 8793 getLLVMStyleWithColumns(22)); 8794 verifyFormat("#define A \\\n" 8795 " void f() { int i; } \\\n" 8796 " int j;", 8797 getLLVMStyleWithColumns(23)); 8798 } 8799 8800 TEST_F(FormatTest, PullEmptyFunctionDefinitionsIntoSingleLine) { 8801 FormatStyle MergeEmptyOnly = getLLVMStyle(); 8802 MergeEmptyOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty; 8803 verifyFormat("class C {\n" 8804 " int f() {}\n" 8805 "};", 8806 MergeEmptyOnly); 8807 verifyFormat("class C {\n" 8808 " int f() {\n" 8809 " return 42;\n" 8810 " }\n" 8811 "};", 8812 MergeEmptyOnly); 8813 verifyFormat("int f() {}", MergeEmptyOnly); 8814 verifyFormat("int f() {\n" 8815 " return 42;\n" 8816 "}", 8817 MergeEmptyOnly); 8818 8819 // Also verify behavior when BraceWrapping.AfterFunction = true 8820 MergeEmptyOnly.BreakBeforeBraces = FormatStyle::BS_Custom; 8821 MergeEmptyOnly.BraceWrapping.AfterFunction = true; 8822 verifyFormat("int f() {}", MergeEmptyOnly); 8823 verifyFormat("class C {\n" 8824 " int f() {}\n" 8825 "};", 8826 MergeEmptyOnly); 8827 } 8828 8829 TEST_F(FormatTest, PullInlineFunctionDefinitionsIntoSingleLine) { 8830 FormatStyle MergeInlineOnly = getLLVMStyle(); 8831 MergeInlineOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; 8832 verifyFormat("class C {\n" 8833 " int f() { return 42; }\n" 8834 "};", 8835 MergeInlineOnly); 8836 verifyFormat("int f() {\n" 8837 " return 42;\n" 8838 "}", 8839 MergeInlineOnly); 8840 8841 // SFS_Inline implies SFS_Empty 8842 verifyFormat("class C {\n" 8843 " int f() {}\n" 8844 "};", 8845 MergeInlineOnly); 8846 verifyFormat("int f() {}", MergeInlineOnly); 8847 8848 // Also verify behavior when BraceWrapping.AfterFunction = true 8849 MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom; 8850 MergeInlineOnly.BraceWrapping.AfterFunction = true; 8851 verifyFormat("class C {\n" 8852 " int f() { return 42; }\n" 8853 "};", 8854 MergeInlineOnly); 8855 verifyFormat("int f()\n" 8856 "{\n" 8857 " return 42;\n" 8858 "}", 8859 MergeInlineOnly); 8860 8861 // SFS_Inline implies SFS_Empty 8862 verifyFormat("int f() {}", MergeInlineOnly); 8863 verifyFormat("class C {\n" 8864 " int f() {}\n" 8865 "};", 8866 MergeInlineOnly); 8867 } 8868 8869 TEST_F(FormatTest, PullInlineOnlyFunctionDefinitionsIntoSingleLine) { 8870 FormatStyle MergeInlineOnly = getLLVMStyle(); 8871 MergeInlineOnly.AllowShortFunctionsOnASingleLine = 8872 FormatStyle::SFS_InlineOnly; 8873 verifyFormat("class C {\n" 8874 " int f() { return 42; }\n" 8875 "};", 8876 MergeInlineOnly); 8877 verifyFormat("int f() {\n" 8878 " return 42;\n" 8879 "}", 8880 MergeInlineOnly); 8881 8882 // SFS_InlineOnly does not imply SFS_Empty 8883 verifyFormat("class C {\n" 8884 " int f() {}\n" 8885 "};", 8886 MergeInlineOnly); 8887 verifyFormat("int f() {\n" 8888 "}", 8889 MergeInlineOnly); 8890 8891 // Also verify behavior when BraceWrapping.AfterFunction = true 8892 MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom; 8893 MergeInlineOnly.BraceWrapping.AfterFunction = true; 8894 verifyFormat("class C {\n" 8895 " int f() { return 42; }\n" 8896 "};", 8897 MergeInlineOnly); 8898 verifyFormat("int f()\n" 8899 "{\n" 8900 " return 42;\n" 8901 "}", 8902 MergeInlineOnly); 8903 8904 // SFS_InlineOnly does not imply SFS_Empty 8905 verifyFormat("int f()\n" 8906 "{\n" 8907 "}", 8908 MergeInlineOnly); 8909 verifyFormat("class C {\n" 8910 " int f() {}\n" 8911 "};", 8912 MergeInlineOnly); 8913 } 8914 8915 TEST_F(FormatTest, SplitEmptyFunction) { 8916 FormatStyle Style = getLLVMStyle(); 8917 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 8918 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8919 Style.BraceWrapping.AfterFunction = true; 8920 Style.BraceWrapping.SplitEmptyFunction = false; 8921 Style.ColumnLimit = 40; 8922 8923 verifyFormat("int f()\n" 8924 "{}", 8925 Style); 8926 verifyFormat("int f()\n" 8927 "{\n" 8928 " return 42;\n" 8929 "}", 8930 Style); 8931 verifyFormat("int f()\n" 8932 "{\n" 8933 " // some comment\n" 8934 "}", 8935 Style); 8936 8937 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty; 8938 verifyFormat("int f() {}", Style); 8939 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8940 "{}", 8941 Style); 8942 verifyFormat("int f()\n" 8943 "{\n" 8944 " return 0;\n" 8945 "}", 8946 Style); 8947 8948 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; 8949 verifyFormat("class Foo {\n" 8950 " int f() {}\n" 8951 "};\n", 8952 Style); 8953 verifyFormat("class Foo {\n" 8954 " int f() { return 0; }\n" 8955 "};\n", 8956 Style); 8957 verifyFormat("class Foo {\n" 8958 " int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8959 " {}\n" 8960 "};\n", 8961 Style); 8962 verifyFormat("class Foo {\n" 8963 " int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8964 " {\n" 8965 " return 0;\n" 8966 " }\n" 8967 "};\n", 8968 Style); 8969 8970 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 8971 verifyFormat("int f() {}", Style); 8972 verifyFormat("int f() { return 0; }", Style); 8973 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8974 "{}", 8975 Style); 8976 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8977 "{\n" 8978 " return 0;\n" 8979 "}", 8980 Style); 8981 } 8982 TEST_F(FormatTest, KeepShortFunctionAfterPPElse) { 8983 FormatStyle Style = getLLVMStyle(); 8984 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 8985 verifyFormat("#ifdef A\n" 8986 "int f() {}\n" 8987 "#else\n" 8988 "int g() {}\n" 8989 "#endif", 8990 Style); 8991 } 8992 8993 TEST_F(FormatTest, SplitEmptyClass) { 8994 FormatStyle Style = getLLVMStyle(); 8995 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8996 Style.BraceWrapping.AfterClass = true; 8997 Style.BraceWrapping.SplitEmptyRecord = false; 8998 8999 verifyFormat("class Foo\n" 9000 "{};", 9001 Style); 9002 verifyFormat("/* something */ class Foo\n" 9003 "{};", 9004 Style); 9005 verifyFormat("template <typename X> class Foo\n" 9006 "{};", 9007 Style); 9008 verifyFormat("class Foo\n" 9009 "{\n" 9010 " Foo();\n" 9011 "};", 9012 Style); 9013 verifyFormat("typedef class Foo\n" 9014 "{\n" 9015 "} Foo_t;", 9016 Style); 9017 } 9018 9019 TEST_F(FormatTest, SplitEmptyStruct) { 9020 FormatStyle Style = getLLVMStyle(); 9021 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 9022 Style.BraceWrapping.AfterStruct = true; 9023 Style.BraceWrapping.SplitEmptyRecord = false; 9024 9025 verifyFormat("struct Foo\n" 9026 "{};", 9027 Style); 9028 verifyFormat("/* something */ struct Foo\n" 9029 "{};", 9030 Style); 9031 verifyFormat("template <typename X> struct Foo\n" 9032 "{};", 9033 Style); 9034 verifyFormat("struct Foo\n" 9035 "{\n" 9036 " Foo();\n" 9037 "};", 9038 Style); 9039 verifyFormat("typedef struct Foo\n" 9040 "{\n" 9041 "} Foo_t;", 9042 Style); 9043 // typedef struct Bar {} Bar_t; 9044 } 9045 9046 TEST_F(FormatTest, SplitEmptyUnion) { 9047 FormatStyle Style = getLLVMStyle(); 9048 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 9049 Style.BraceWrapping.AfterUnion = true; 9050 Style.BraceWrapping.SplitEmptyRecord = false; 9051 9052 verifyFormat("union Foo\n" 9053 "{};", 9054 Style); 9055 verifyFormat("/* something */ union Foo\n" 9056 "{};", 9057 Style); 9058 verifyFormat("union Foo\n" 9059 "{\n" 9060 " A,\n" 9061 "};", 9062 Style); 9063 verifyFormat("typedef union Foo\n" 9064 "{\n" 9065 "} Foo_t;", 9066 Style); 9067 } 9068 9069 TEST_F(FormatTest, SplitEmptyNamespace) { 9070 FormatStyle Style = getLLVMStyle(); 9071 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 9072 Style.BraceWrapping.AfterNamespace = true; 9073 Style.BraceWrapping.SplitEmptyNamespace = false; 9074 9075 verifyFormat("namespace Foo\n" 9076 "{};", 9077 Style); 9078 verifyFormat("/* something */ namespace Foo\n" 9079 "{};", 9080 Style); 9081 verifyFormat("inline namespace Foo\n" 9082 "{};", 9083 Style); 9084 verifyFormat("/* something */ inline namespace Foo\n" 9085 "{};", 9086 Style); 9087 verifyFormat("export namespace Foo\n" 9088 "{};", 9089 Style); 9090 verifyFormat("namespace Foo\n" 9091 "{\n" 9092 "void Bar();\n" 9093 "};", 9094 Style); 9095 } 9096 9097 TEST_F(FormatTest, NeverMergeShortRecords) { 9098 FormatStyle Style = getLLVMStyle(); 9099 9100 verifyFormat("class Foo {\n" 9101 " Foo();\n" 9102 "};", 9103 Style); 9104 verifyFormat("typedef class Foo {\n" 9105 " Foo();\n" 9106 "} Foo_t;", 9107 Style); 9108 verifyFormat("struct Foo {\n" 9109 " Foo();\n" 9110 "};", 9111 Style); 9112 verifyFormat("typedef struct Foo {\n" 9113 " Foo();\n" 9114 "} Foo_t;", 9115 Style); 9116 verifyFormat("union Foo {\n" 9117 " A,\n" 9118 "};", 9119 Style); 9120 verifyFormat("typedef union Foo {\n" 9121 " A,\n" 9122 "} Foo_t;", 9123 Style); 9124 verifyFormat("namespace Foo {\n" 9125 "void Bar();\n" 9126 "};", 9127 Style); 9128 9129 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 9130 Style.BraceWrapping.AfterClass = true; 9131 Style.BraceWrapping.AfterStruct = true; 9132 Style.BraceWrapping.AfterUnion = true; 9133 Style.BraceWrapping.AfterNamespace = true; 9134 verifyFormat("class Foo\n" 9135 "{\n" 9136 " Foo();\n" 9137 "};", 9138 Style); 9139 verifyFormat("typedef class Foo\n" 9140 "{\n" 9141 " Foo();\n" 9142 "} Foo_t;", 9143 Style); 9144 verifyFormat("struct Foo\n" 9145 "{\n" 9146 " Foo();\n" 9147 "};", 9148 Style); 9149 verifyFormat("typedef struct Foo\n" 9150 "{\n" 9151 " Foo();\n" 9152 "} Foo_t;", 9153 Style); 9154 verifyFormat("union Foo\n" 9155 "{\n" 9156 " A,\n" 9157 "};", 9158 Style); 9159 verifyFormat("typedef union Foo\n" 9160 "{\n" 9161 " A,\n" 9162 "} Foo_t;", 9163 Style); 9164 verifyFormat("namespace Foo\n" 9165 "{\n" 9166 "void Bar();\n" 9167 "};", 9168 Style); 9169 } 9170 9171 TEST_F(FormatTest, UnderstandContextOfRecordTypeKeywords) { 9172 // Elaborate type variable declarations. 9173 verifyFormat("struct foo a = {bar};\nint n;"); 9174 verifyFormat("class foo a = {bar};\nint n;"); 9175 verifyFormat("union foo a = {bar};\nint n;"); 9176 9177 // Elaborate types inside function definitions. 9178 verifyFormat("struct foo f() {}\nint n;"); 9179 verifyFormat("class foo f() {}\nint n;"); 9180 verifyFormat("union foo f() {}\nint n;"); 9181 9182 // Templates. 9183 verifyFormat("template <class X> void f() {}\nint n;"); 9184 verifyFormat("template <struct X> void f() {}\nint n;"); 9185 verifyFormat("template <union X> void f() {}\nint n;"); 9186 9187 // Actual definitions... 9188 verifyFormat("struct {\n} n;"); 9189 verifyFormat( 9190 "template <template <class T, class Y>, class Z> class X {\n} n;"); 9191 verifyFormat("union Z {\n int n;\n} x;"); 9192 verifyFormat("class MACRO Z {\n} n;"); 9193 verifyFormat("class MACRO(X) Z {\n} n;"); 9194 verifyFormat("class __attribute__(X) Z {\n} n;"); 9195 verifyFormat("class __declspec(X) Z {\n} n;"); 9196 verifyFormat("class A##B##C {\n} n;"); 9197 verifyFormat("class alignas(16) Z {\n} n;"); 9198 verifyFormat("class MACRO(X) alignas(16) Z {\n} n;"); 9199 verifyFormat("class MACROA MACRO(X) Z {\n} n;"); 9200 9201 // Redefinition from nested context: 9202 verifyFormat("class A::B::C {\n} n;"); 9203 9204 // Template definitions. 9205 verifyFormat( 9206 "template <typename F>\n" 9207 "Matcher(const Matcher<F> &Other,\n" 9208 " typename enable_if_c<is_base_of<F, T>::value &&\n" 9209 " !is_same<F, T>::value>::type * = 0)\n" 9210 " : Implementation(new ImplicitCastMatcher<F>(Other)) {}"); 9211 9212 // FIXME: This is still incorrectly handled at the formatter side. 9213 verifyFormat("template <> struct X < 15, i<3 && 42 < 50 && 33 < 28> {};"); 9214 verifyFormat("int i = SomeFunction(a<b, a> b);"); 9215 9216 // FIXME: 9217 // This now gets parsed incorrectly as class definition. 9218 // verifyFormat("class A<int> f() {\n}\nint n;"); 9219 9220 // Elaborate types where incorrectly parsing the structural element would 9221 // break the indent. 9222 verifyFormat("if (true)\n" 9223 " class X x;\n" 9224 "else\n" 9225 " f();\n"); 9226 9227 // This is simply incomplete. Formatting is not important, but must not crash. 9228 verifyFormat("class A:"); 9229 } 9230 9231 TEST_F(FormatTest, DoNotInterfereWithErrorAndWarning) { 9232 EXPECT_EQ("#error Leave all white!!!!! space* alone!\n", 9233 format("#error Leave all white!!!!! space* alone!\n")); 9234 EXPECT_EQ( 9235 "#warning Leave all white!!!!! space* alone!\n", 9236 format("#warning Leave all white!!!!! space* alone!\n")); 9237 EXPECT_EQ("#error 1", format(" # error 1")); 9238 EXPECT_EQ("#warning 1", format(" # warning 1")); 9239 } 9240 9241 TEST_F(FormatTest, FormatHashIfExpressions) { 9242 verifyFormat("#if AAAA && BBBB"); 9243 verifyFormat("#if (AAAA && BBBB)"); 9244 verifyFormat("#elif (AAAA && BBBB)"); 9245 // FIXME: Come up with a better indentation for #elif. 9246 verifyFormat( 9247 "#if !defined(AAAAAAA) && (defined CCCCCC || defined DDDDDD) && \\\n" 9248 " defined(BBBBBBBB)\n" 9249 "#elif !defined(AAAAAA) && (defined CCCCC || defined DDDDDD) && \\\n" 9250 " defined(BBBBBBBB)\n" 9251 "#endif", 9252 getLLVMStyleWithColumns(65)); 9253 } 9254 9255 TEST_F(FormatTest, MergeHandlingInTheFaceOfPreprocessorDirectives) { 9256 FormatStyle AllowsMergedIf = getGoogleStyle(); 9257 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = 9258 FormatStyle::SIS_WithoutElse; 9259 verifyFormat("void f() { f(); }\n#error E", AllowsMergedIf); 9260 verifyFormat("if (true) return 42;\n#error E", AllowsMergedIf); 9261 verifyFormat("if (true)\n#error E\n return 42;", AllowsMergedIf); 9262 EXPECT_EQ("if (true) return 42;", 9263 format("if (true)\nreturn 42;", AllowsMergedIf)); 9264 FormatStyle ShortMergedIf = AllowsMergedIf; 9265 ShortMergedIf.ColumnLimit = 25; 9266 verifyFormat("#define A \\\n" 9267 " if (true) return 42;", 9268 ShortMergedIf); 9269 verifyFormat("#define A \\\n" 9270 " f(); \\\n" 9271 " if (true)\n" 9272 "#define B", 9273 ShortMergedIf); 9274 verifyFormat("#define A \\\n" 9275 " f(); \\\n" 9276 " if (true)\n" 9277 "g();", 9278 ShortMergedIf); 9279 verifyFormat("{\n" 9280 "#ifdef A\n" 9281 " // Comment\n" 9282 " if (true) continue;\n" 9283 "#endif\n" 9284 " // Comment\n" 9285 " if (true) continue;\n" 9286 "}", 9287 ShortMergedIf); 9288 ShortMergedIf.ColumnLimit = 33; 9289 verifyFormat("#define A \\\n" 9290 " if constexpr (true) return 42;", 9291 ShortMergedIf); 9292 verifyFormat("#define A \\\n" 9293 " if CONSTEXPR (true) return 42;", 9294 ShortMergedIf); 9295 ShortMergedIf.ColumnLimit = 29; 9296 verifyFormat("#define A \\\n" 9297 " if (aaaaaaaaaa) return 1; \\\n" 9298 " return 2;", 9299 ShortMergedIf); 9300 ShortMergedIf.ColumnLimit = 28; 9301 verifyFormat("#define A \\\n" 9302 " if (aaaaaaaaaa) \\\n" 9303 " return 1; \\\n" 9304 " return 2;", 9305 ShortMergedIf); 9306 verifyFormat("#define A \\\n" 9307 " if constexpr (aaaaaaa) \\\n" 9308 " return 1; \\\n" 9309 " return 2;", 9310 ShortMergedIf); 9311 verifyFormat("#define A \\\n" 9312 " if CONSTEXPR (aaaaaaa) \\\n" 9313 " return 1; \\\n" 9314 " return 2;", 9315 ShortMergedIf); 9316 } 9317 9318 TEST_F(FormatTest, FormatStarDependingOnContext) { 9319 verifyFormat("void f(int *a);"); 9320 verifyFormat("void f() { f(fint * b); }"); 9321 verifyFormat("class A {\n void f(int *a);\n};"); 9322 verifyFormat("class A {\n int *a;\n};"); 9323 verifyFormat("namespace a {\n" 9324 "namespace b {\n" 9325 "class A {\n" 9326 " void f() {}\n" 9327 " int *a;\n" 9328 "};\n" 9329 "} // namespace b\n" 9330 "} // namespace a"); 9331 } 9332 9333 TEST_F(FormatTest, SpecialTokensAtEndOfLine) { 9334 verifyFormat("while"); 9335 verifyFormat("operator"); 9336 } 9337 9338 TEST_F(FormatTest, SkipsDeeplyNestedLines) { 9339 // This code would be painfully slow to format if we didn't skip it. 9340 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 9341 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 9342 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 9343 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 9344 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 9345 "A(1, 1)\n" 9346 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" // 10x 9347 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9348 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9349 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9350 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9351 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9352 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9353 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9354 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9355 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1);\n"); 9356 // Deeply nested part is untouched, rest is formatted. 9357 EXPECT_EQ(std::string("int i;\n") + Code + "int j;\n", 9358 format(std::string("int i;\n") + Code + "int j;\n", 9359 getLLVMStyle(), SC_ExpectIncomplete)); 9360 } 9361 9362 //===----------------------------------------------------------------------===// 9363 // Objective-C tests. 9364 //===----------------------------------------------------------------------===// 9365 9366 TEST_F(FormatTest, FormatForObjectiveCMethodDecls) { 9367 verifyFormat("- (void)sendAction:(SEL)aSelector to:(BOOL)anObject;"); 9368 EXPECT_EQ("- (NSUInteger)indexOfObject:(id)anObject;", 9369 format("-(NSUInteger)indexOfObject:(id)anObject;")); 9370 EXPECT_EQ("- (NSInteger)Mthod1;", format("-(NSInteger)Mthod1;")); 9371 EXPECT_EQ("+ (id)Mthod2;", format("+(id)Mthod2;")); 9372 EXPECT_EQ("- (NSInteger)Method3:(id)anObject;", 9373 format("-(NSInteger)Method3:(id)anObject;")); 9374 EXPECT_EQ("- (NSInteger)Method4:(id)anObject;", 9375 format("-(NSInteger)Method4:(id)anObject;")); 9376 EXPECT_EQ("- (NSInteger)Method5:(id)anObject:(id)AnotherObject;", 9377 format("-(NSInteger)Method5:(id)anObject:(id)AnotherObject;")); 9378 EXPECT_EQ("- (id)Method6:(id)A:(id)B:(id)C:(id)D;", 9379 format("- (id)Method6:(id)A:(id)B:(id)C:(id)D;")); 9380 EXPECT_EQ("- (void)sendAction:(SEL)aSelector to:(id)anObject " 9381 "forAllCells:(BOOL)flag;", 9382 format("- (void)sendAction:(SEL)aSelector to:(id)anObject " 9383 "forAllCells:(BOOL)flag;")); 9384 9385 // Very long objectiveC method declaration. 9386 verifyFormat("- (void)aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n" 9387 " (SoooooooooooooooooooooomeType *)bbbbbbbbbb;"); 9388 verifyFormat("- (NSUInteger)indexOfObject:(id)anObject\n" 9389 " inRange:(NSRange)range\n" 9390 " outRange:(NSRange)out_range\n" 9391 " outRange1:(NSRange)out_range1\n" 9392 " outRange2:(NSRange)out_range2\n" 9393 " outRange3:(NSRange)out_range3\n" 9394 " outRange4:(NSRange)out_range4\n" 9395 " outRange5:(NSRange)out_range5\n" 9396 " outRange6:(NSRange)out_range6\n" 9397 " outRange7:(NSRange)out_range7\n" 9398 " outRange8:(NSRange)out_range8\n" 9399 " outRange9:(NSRange)out_range9;"); 9400 9401 // When the function name has to be wrapped. 9402 FormatStyle Style = getLLVMStyle(); 9403 // ObjC ignores IndentWrappedFunctionNames when wrapping methods 9404 // and always indents instead. 9405 Style.IndentWrappedFunctionNames = false; 9406 verifyFormat("- (SomeLooooooooooooooooooooongType *)\n" 9407 " veryLooooooooooongName:(NSString)aaaaaaaaaaaaaa\n" 9408 " anotherName:(NSString)bbbbbbbbbbbbbb {\n" 9409 "}", 9410 Style); 9411 Style.IndentWrappedFunctionNames = true; 9412 verifyFormat("- (SomeLooooooooooooooooooooongType *)\n" 9413 " veryLooooooooooongName:(NSString)cccccccccccccc\n" 9414 " anotherName:(NSString)dddddddddddddd {\n" 9415 "}", 9416 Style); 9417 9418 verifyFormat("- (int)sum:(vector<int>)numbers;"); 9419 verifyGoogleFormat("- (void)setDelegate:(id<Protocol>)delegate;"); 9420 // FIXME: In LLVM style, there should be a space in front of a '<' for ObjC 9421 // protocol lists (but not for template classes): 9422 // verifyFormat("- (void)setDelegate:(id <Protocol>)delegate;"); 9423 9424 verifyFormat("- (int (*)())foo:(int (*)())f;"); 9425 verifyGoogleFormat("- (int (*)())foo:(int (*)())foo;"); 9426 9427 // If there's no return type (very rare in practice!), LLVM and Google style 9428 // agree. 9429 verifyFormat("- foo;"); 9430 verifyFormat("- foo:(int)f;"); 9431 verifyGoogleFormat("- foo:(int)foo;"); 9432 } 9433 9434 TEST_F(FormatTest, BreaksStringLiterals) { 9435 EXPECT_EQ("\"some text \"\n" 9436 "\"other\";", 9437 format("\"some text other\";", getLLVMStyleWithColumns(12))); 9438 EXPECT_EQ("\"some text \"\n" 9439 "\"other\";", 9440 format("\\\n\"some text other\";", getLLVMStyleWithColumns(12))); 9441 EXPECT_EQ( 9442 "#define A \\\n" 9443 " \"some \" \\\n" 9444 " \"text \" \\\n" 9445 " \"other\";", 9446 format("#define A \"some text other\";", getLLVMStyleWithColumns(12))); 9447 EXPECT_EQ( 9448 "#define A \\\n" 9449 " \"so \" \\\n" 9450 " \"text \" \\\n" 9451 " \"other\";", 9452 format("#define A \"so text other\";", getLLVMStyleWithColumns(12))); 9453 9454 EXPECT_EQ("\"some text\"", 9455 format("\"some text\"", getLLVMStyleWithColumns(1))); 9456 EXPECT_EQ("\"some text\"", 9457 format("\"some text\"", getLLVMStyleWithColumns(11))); 9458 EXPECT_EQ("\"some \"\n" 9459 "\"text\"", 9460 format("\"some text\"", getLLVMStyleWithColumns(10))); 9461 EXPECT_EQ("\"some \"\n" 9462 "\"text\"", 9463 format("\"some text\"", getLLVMStyleWithColumns(7))); 9464 EXPECT_EQ("\"some\"\n" 9465 "\" tex\"\n" 9466 "\"t\"", 9467 format("\"some text\"", getLLVMStyleWithColumns(6))); 9468 EXPECT_EQ("\"some\"\n" 9469 "\" tex\"\n" 9470 "\" and\"", 9471 format("\"some tex and\"", getLLVMStyleWithColumns(6))); 9472 EXPECT_EQ("\"some\"\n" 9473 "\"/tex\"\n" 9474 "\"/and\"", 9475 format("\"some/tex/and\"", getLLVMStyleWithColumns(6))); 9476 9477 EXPECT_EQ("variable =\n" 9478 " \"long string \"\n" 9479 " \"literal\";", 9480 format("variable = \"long string literal\";", 9481 getLLVMStyleWithColumns(20))); 9482 9483 EXPECT_EQ("variable = f(\n" 9484 " \"long string \"\n" 9485 " \"literal\",\n" 9486 " short,\n" 9487 " loooooooooooooooooooong);", 9488 format("variable = f(\"long string literal\", short, " 9489 "loooooooooooooooooooong);", 9490 getLLVMStyleWithColumns(20))); 9491 9492 EXPECT_EQ( 9493 "f(g(\"long string \"\n" 9494 " \"literal\"),\n" 9495 " b);", 9496 format("f(g(\"long string literal\"), b);", getLLVMStyleWithColumns(20))); 9497 EXPECT_EQ("f(g(\"long string \"\n" 9498 " \"literal\",\n" 9499 " a),\n" 9500 " b);", 9501 format("f(g(\"long string literal\", a), b);", 9502 getLLVMStyleWithColumns(20))); 9503 EXPECT_EQ( 9504 "f(\"one two\".split(\n" 9505 " variable));", 9506 format("f(\"one two\".split(variable));", getLLVMStyleWithColumns(20))); 9507 EXPECT_EQ("f(\"one two three four five six \"\n" 9508 " \"seven\".split(\n" 9509 " really_looooong_variable));", 9510 format("f(\"one two three four five six seven\"." 9511 "split(really_looooong_variable));", 9512 getLLVMStyleWithColumns(33))); 9513 9514 EXPECT_EQ("f(\"some \"\n" 9515 " \"text\",\n" 9516 " other);", 9517 format("f(\"some text\", other);", getLLVMStyleWithColumns(10))); 9518 9519 // Only break as a last resort. 9520 verifyFormat( 9521 "aaaaaaaaaaaaaaaaaaaa(\n" 9522 " aaaaaaaaaaaaaaaaaaaa,\n" 9523 " aaaaaa(\"aaa aaaaa aaa aaa aaaaa aaa aaaaa aaa aaa aaaaaa\"));"); 9524 9525 EXPECT_EQ("\"splitmea\"\n" 9526 "\"trandomp\"\n" 9527 "\"oint\"", 9528 format("\"splitmeatrandompoint\"", getLLVMStyleWithColumns(10))); 9529 9530 EXPECT_EQ("\"split/\"\n" 9531 "\"pathat/\"\n" 9532 "\"slashes\"", 9533 format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10))); 9534 9535 EXPECT_EQ("\"split/\"\n" 9536 "\"pathat/\"\n" 9537 "\"slashes\"", 9538 format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10))); 9539 EXPECT_EQ("\"split at \"\n" 9540 "\"spaces/at/\"\n" 9541 "\"slashes.at.any$\"\n" 9542 "\"non-alphanumeric%\"\n" 9543 "\"1111111111characte\"\n" 9544 "\"rs\"", 9545 format("\"split at " 9546 "spaces/at/" 9547 "slashes.at." 9548 "any$non-" 9549 "alphanumeric%" 9550 "1111111111characte" 9551 "rs\"", 9552 getLLVMStyleWithColumns(20))); 9553 9554 // Verify that splitting the strings understands 9555 // Style::AlwaysBreakBeforeMultilineStrings. 9556 EXPECT_EQ("aaaaaaaaaaaa(\n" 9557 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa \"\n" 9558 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\");", 9559 format("aaaaaaaaaaaa(\"aaaaaaaaaaaaaaaaaaaaaaaaaa " 9560 "aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa " 9561 "aaaaaaaaaaaaaaaaaaaaaa\");", 9562 getGoogleStyle())); 9563 EXPECT_EQ("return \"aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 9564 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\";", 9565 format("return \"aaaaaaaaaaaaaaaaaaaaaa " 9566 "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa " 9567 "aaaaaaaaaaaaaaaaaaaaaa\";", 9568 getGoogleStyle())); 9569 EXPECT_EQ("llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 9570 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";", 9571 format("llvm::outs() << " 9572 "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa" 9573 "aaaaaaaaaaaaaaaaaaa\";")); 9574 EXPECT_EQ("ffff(\n" 9575 " {\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 9576 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});", 9577 format("ffff({\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa " 9578 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});", 9579 getGoogleStyle())); 9580 9581 FormatStyle Style = getLLVMStyleWithColumns(12); 9582 Style.BreakStringLiterals = false; 9583 EXPECT_EQ("\"some text other\";", format("\"some text other\";", Style)); 9584 9585 FormatStyle AlignLeft = getLLVMStyleWithColumns(12); 9586 AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left; 9587 EXPECT_EQ("#define A \\\n" 9588 " \"some \" \\\n" 9589 " \"text \" \\\n" 9590 " \"other\";", 9591 format("#define A \"some text other\";", AlignLeft)); 9592 } 9593 9594 TEST_F(FormatTest, BreaksStringLiteralsAtColumnLimit) { 9595 EXPECT_EQ("C a = \"some more \"\n" 9596 " \"text\";", 9597 format("C a = \"some more text\";", getLLVMStyleWithColumns(18))); 9598 } 9599 9600 TEST_F(FormatTest, FullyRemoveEmptyLines) { 9601 FormatStyle NoEmptyLines = getLLVMStyleWithColumns(80); 9602 NoEmptyLines.MaxEmptyLinesToKeep = 0; 9603 EXPECT_EQ("int i = a(b());", 9604 format("int i=a(\n\n b(\n\n\n )\n\n);", NoEmptyLines)); 9605 } 9606 9607 TEST_F(FormatTest, BreaksStringLiteralsWithTabs) { 9608 EXPECT_EQ( 9609 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 9610 "(\n" 9611 " \"x\t\");", 9612 format("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 9613 "aaaaaaa(" 9614 "\"x\t\");")); 9615 } 9616 9617 TEST_F(FormatTest, BreaksWideAndNSStringLiterals) { 9618 EXPECT_EQ( 9619 "u8\"utf8 string \"\n" 9620 "u8\"literal\";", 9621 format("u8\"utf8 string literal\";", getGoogleStyleWithColumns(16))); 9622 EXPECT_EQ( 9623 "u\"utf16 string \"\n" 9624 "u\"literal\";", 9625 format("u\"utf16 string literal\";", getGoogleStyleWithColumns(16))); 9626 EXPECT_EQ( 9627 "U\"utf32 string \"\n" 9628 "U\"literal\";", 9629 format("U\"utf32 string literal\";", getGoogleStyleWithColumns(16))); 9630 EXPECT_EQ("L\"wide string \"\n" 9631 "L\"literal\";", 9632 format("L\"wide string literal\";", getGoogleStyleWithColumns(16))); 9633 EXPECT_EQ("@\"NSString \"\n" 9634 "@\"literal\";", 9635 format("@\"NSString literal\";", getGoogleStyleWithColumns(19))); 9636 verifyFormat(R"(NSString *s = @"那那那那";)", getLLVMStyleWithColumns(26)); 9637 9638 // This input makes clang-format try to split the incomplete unicode escape 9639 // sequence, which used to lead to a crasher. 9640 verifyNoCrash( 9641 "aaaaaaaaaaaaaaaaaaaa = L\"\\udff\"'; // aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 9642 getLLVMStyleWithColumns(60)); 9643 } 9644 9645 TEST_F(FormatTest, DoesNotBreakRawStringLiterals) { 9646 FormatStyle Style = getGoogleStyleWithColumns(15); 9647 EXPECT_EQ("R\"x(raw literal)x\";", format("R\"x(raw literal)x\";", Style)); 9648 EXPECT_EQ("uR\"x(raw literal)x\";", format("uR\"x(raw literal)x\";", Style)); 9649 EXPECT_EQ("LR\"x(raw literal)x\";", format("LR\"x(raw literal)x\";", Style)); 9650 EXPECT_EQ("UR\"x(raw literal)x\";", format("UR\"x(raw literal)x\";", Style)); 9651 EXPECT_EQ("u8R\"x(raw literal)x\";", 9652 format("u8R\"x(raw literal)x\";", Style)); 9653 } 9654 9655 TEST_F(FormatTest, BreaksStringLiteralsWithin_TMacro) { 9656 FormatStyle Style = getLLVMStyleWithColumns(20); 9657 EXPECT_EQ( 9658 "_T(\"aaaaaaaaaaaaaa\")\n" 9659 "_T(\"aaaaaaaaaaaaaa\")\n" 9660 "_T(\"aaaaaaaaaaaa\")", 9661 format(" _T(\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\")", Style)); 9662 EXPECT_EQ("f(x,\n" 9663 " _T(\"aaaaaaaaaaaa\")\n" 9664 " _T(\"aaa\"),\n" 9665 " z);", 9666 format("f(x, _T(\"aaaaaaaaaaaaaaa\"), z);", Style)); 9667 9668 // FIXME: Handle embedded spaces in one iteration. 9669 // EXPECT_EQ("_T(\"aaaaaaaaaaaaa\")\n" 9670 // "_T(\"aaaaaaaaaaaaa\")\n" 9671 // "_T(\"aaaaaaaaaaaaa\")\n" 9672 // "_T(\"a\")", 9673 // format(" _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", 9674 // getLLVMStyleWithColumns(20))); 9675 EXPECT_EQ( 9676 "_T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", 9677 format(" _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", Style)); 9678 EXPECT_EQ("f(\n" 9679 "#if !TEST\n" 9680 " _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n" 9681 "#endif\n" 9682 ");", 9683 format("f(\n" 9684 "#if !TEST\n" 9685 "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n" 9686 "#endif\n" 9687 ");")); 9688 EXPECT_EQ("f(\n" 9689 "\n" 9690 " _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));", 9691 format("f(\n" 9692 "\n" 9693 "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));")); 9694 } 9695 9696 TEST_F(FormatTest, BreaksStringLiteralOperands) { 9697 // In a function call with two operands, the second can be broken with no line 9698 // break before it. 9699 EXPECT_EQ( 9700 "func(a, \"long long \"\n" 9701 " \"long long\");", 9702 format("func(a, \"long long long long\");", getLLVMStyleWithColumns(24))); 9703 // In a function call with three operands, the second must be broken with a 9704 // line break before it. 9705 EXPECT_EQ("func(a,\n" 9706 " \"long long long \"\n" 9707 " \"long\",\n" 9708 " c);", 9709 format("func(a, \"long long long long\", c);", 9710 getLLVMStyleWithColumns(24))); 9711 // In a function call with three operands, the third must be broken with a 9712 // line break before it. 9713 EXPECT_EQ("func(a, b,\n" 9714 " \"long long long \"\n" 9715 " \"long\");", 9716 format("func(a, b, \"long long long long\");", 9717 getLLVMStyleWithColumns(24))); 9718 // In a function call with three operands, both the second and the third must 9719 // be broken with a line break before them. 9720 EXPECT_EQ("func(a,\n" 9721 " \"long long long \"\n" 9722 " \"long\",\n" 9723 " \"long long long \"\n" 9724 " \"long\");", 9725 format("func(a, \"long long long long\", \"long long long long\");", 9726 getLLVMStyleWithColumns(24))); 9727 // In a chain of << with two operands, the second can be broken with no line 9728 // break before it. 9729 EXPECT_EQ("a << \"line line \"\n" 9730 " \"line\";", 9731 format("a << \"line line line\";", getLLVMStyleWithColumns(20))); 9732 // In a chain of << with three operands, the second can be broken with no line 9733 // break before it. 9734 EXPECT_EQ( 9735 "abcde << \"line \"\n" 9736 " \"line line\"\n" 9737 " << c;", 9738 format("abcde << \"line line line\" << c;", getLLVMStyleWithColumns(20))); 9739 // In a chain of << with three operands, the third must be broken with a line 9740 // break before it. 9741 EXPECT_EQ( 9742 "a << b\n" 9743 " << \"line line \"\n" 9744 " \"line\";", 9745 format("a << b << \"line line line\";", getLLVMStyleWithColumns(20))); 9746 // In a chain of << with three operands, the second can be broken with no line 9747 // break before it and the third must be broken with a line break before it. 9748 EXPECT_EQ("abcd << \"line line \"\n" 9749 " \"line\"\n" 9750 " << \"line line \"\n" 9751 " \"line\";", 9752 format("abcd << \"line line line\" << \"line line line\";", 9753 getLLVMStyleWithColumns(20))); 9754 // In a chain of binary operators with two operands, the second can be broken 9755 // with no line break before it. 9756 EXPECT_EQ( 9757 "abcd + \"line line \"\n" 9758 " \"line line\";", 9759 format("abcd + \"line line line line\";", getLLVMStyleWithColumns(20))); 9760 // In a chain of binary operators with three operands, the second must be 9761 // broken with a line break before it. 9762 EXPECT_EQ("abcd +\n" 9763 " \"line line \"\n" 9764 " \"line line\" +\n" 9765 " e;", 9766 format("abcd + \"line line line line\" + e;", 9767 getLLVMStyleWithColumns(20))); 9768 // In a function call with two operands, with AlignAfterOpenBracket enabled, 9769 // the first must be broken with a line break before it. 9770 FormatStyle Style = getLLVMStyleWithColumns(25); 9771 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 9772 EXPECT_EQ("someFunction(\n" 9773 " \"long long long \"\n" 9774 " \"long\",\n" 9775 " a);", 9776 format("someFunction(\"long long long long\", a);", Style)); 9777 } 9778 9779 TEST_F(FormatTest, DontSplitStringLiteralsWithEscapedNewlines) { 9780 EXPECT_EQ( 9781 "aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 9782 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 9783 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";", 9784 format("aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 9785 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 9786 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";")); 9787 } 9788 9789 TEST_F(FormatTest, CountsCharactersInMultilineRawStringLiterals) { 9790 EXPECT_EQ("f(g(R\"x(raw literal)x\", a), b);", 9791 format("f(g(R\"x(raw literal)x\", a), b);", getGoogleStyle())); 9792 EXPECT_EQ("fffffffffff(g(R\"x(\n" 9793 "multiline raw string literal xxxxxxxxxxxxxx\n" 9794 ")x\",\n" 9795 " a),\n" 9796 " b);", 9797 format("fffffffffff(g(R\"x(\n" 9798 "multiline raw string literal xxxxxxxxxxxxxx\n" 9799 ")x\", a), b);", 9800 getGoogleStyleWithColumns(20))); 9801 EXPECT_EQ("fffffffffff(\n" 9802 " g(R\"x(qqq\n" 9803 "multiline raw string literal xxxxxxxxxxxxxx\n" 9804 ")x\",\n" 9805 " a),\n" 9806 " b);", 9807 format("fffffffffff(g(R\"x(qqq\n" 9808 "multiline raw string literal xxxxxxxxxxxxxx\n" 9809 ")x\", a), b);", 9810 getGoogleStyleWithColumns(20))); 9811 9812 EXPECT_EQ("fffffffffff(R\"x(\n" 9813 "multiline raw string literal xxxxxxxxxxxxxx\n" 9814 ")x\");", 9815 format("fffffffffff(R\"x(\n" 9816 "multiline raw string literal xxxxxxxxxxxxxx\n" 9817 ")x\");", 9818 getGoogleStyleWithColumns(20))); 9819 EXPECT_EQ("fffffffffff(R\"x(\n" 9820 "multiline raw string literal xxxxxxxxxxxxxx\n" 9821 ")x\" + bbbbbb);", 9822 format("fffffffffff(R\"x(\n" 9823 "multiline raw string literal xxxxxxxxxxxxxx\n" 9824 ")x\" + bbbbbb);", 9825 getGoogleStyleWithColumns(20))); 9826 EXPECT_EQ("fffffffffff(\n" 9827 " R\"x(\n" 9828 "multiline raw string literal xxxxxxxxxxxxxx\n" 9829 ")x\" +\n" 9830 " bbbbbb);", 9831 format("fffffffffff(\n" 9832 " R\"x(\n" 9833 "multiline raw string literal xxxxxxxxxxxxxx\n" 9834 ")x\" + bbbbbb);", 9835 getGoogleStyleWithColumns(20))); 9836 EXPECT_EQ("fffffffffff(R\"(single line raw string)\" + bbbbbb);", 9837 format("fffffffffff(\n" 9838 " R\"(single line raw string)\" + bbbbbb);")); 9839 } 9840 9841 TEST_F(FormatTest, SkipsUnknownStringLiterals) { 9842 verifyFormat("string a = \"unterminated;"); 9843 EXPECT_EQ("function(\"unterminated,\n" 9844 " OtherParameter);", 9845 format("function( \"unterminated,\n" 9846 " OtherParameter);")); 9847 } 9848 9849 TEST_F(FormatTest, DoesNotTryToParseUDLiteralsInPreCpp11Code) { 9850 FormatStyle Style = getLLVMStyle(); 9851 Style.Standard = FormatStyle::LS_Cpp03; 9852 EXPECT_EQ("#define x(_a) printf(\"foo\" _a);", 9853 format("#define x(_a) printf(\"foo\"_a);", Style)); 9854 } 9855 9856 TEST_F(FormatTest, CppLexVersion) { 9857 FormatStyle Style = getLLVMStyle(); 9858 // Formatting of x * y differs if x is a type. 9859 verifyFormat("void foo() { MACRO(a * b); }", Style); 9860 verifyFormat("void foo() { MACRO(int *b); }", Style); 9861 9862 // LLVM style uses latest lexer. 9863 verifyFormat("void foo() { MACRO(char8_t *b); }", Style); 9864 Style.Standard = FormatStyle::LS_Cpp17; 9865 // But in c++17, char8_t isn't a keyword. 9866 verifyFormat("void foo() { MACRO(char8_t * b); }", Style); 9867 } 9868 9869 TEST_F(FormatTest, UnderstandsCpp1y) { verifyFormat("int bi{1'000'000};"); } 9870 9871 TEST_F(FormatTest, BreakStringLiteralsBeforeUnbreakableTokenSequence) { 9872 EXPECT_EQ("someFunction(\"aaabbbcccd\"\n" 9873 " \"ddeeefff\");", 9874 format("someFunction(\"aaabbbcccdddeeefff\");", 9875 getLLVMStyleWithColumns(25))); 9876 EXPECT_EQ("someFunction1234567890(\n" 9877 " \"aaabbbcccdddeeefff\");", 9878 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 9879 getLLVMStyleWithColumns(26))); 9880 EXPECT_EQ("someFunction1234567890(\n" 9881 " \"aaabbbcccdddeeeff\"\n" 9882 " \"f\");", 9883 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 9884 getLLVMStyleWithColumns(25))); 9885 EXPECT_EQ("someFunction1234567890(\n" 9886 " \"aaabbbcccdddeeeff\"\n" 9887 " \"f\");", 9888 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 9889 getLLVMStyleWithColumns(24))); 9890 EXPECT_EQ("someFunction(\n" 9891 " \"aaabbbcc ddde \"\n" 9892 " \"efff\");", 9893 format("someFunction(\"aaabbbcc ddde efff\");", 9894 getLLVMStyleWithColumns(25))); 9895 EXPECT_EQ("someFunction(\"aaabbbccc \"\n" 9896 " \"ddeeefff\");", 9897 format("someFunction(\"aaabbbccc ddeeefff\");", 9898 getLLVMStyleWithColumns(25))); 9899 EXPECT_EQ("someFunction1234567890(\n" 9900 " \"aaabb \"\n" 9901 " \"cccdddeeefff\");", 9902 format("someFunction1234567890(\"aaabb cccdddeeefff\");", 9903 getLLVMStyleWithColumns(25))); 9904 EXPECT_EQ("#define A \\\n" 9905 " string s = \\\n" 9906 " \"123456789\" \\\n" 9907 " \"0\"; \\\n" 9908 " int i;", 9909 format("#define A string s = \"1234567890\"; int i;", 9910 getLLVMStyleWithColumns(20))); 9911 EXPECT_EQ("someFunction(\n" 9912 " \"aaabbbcc \"\n" 9913 " \"dddeeefff\");", 9914 format("someFunction(\"aaabbbcc dddeeefff\");", 9915 getLLVMStyleWithColumns(25))); 9916 } 9917 9918 TEST_F(FormatTest, DoNotBreakStringLiteralsInEscapeSequence) { 9919 EXPECT_EQ("\"\\a\"", format("\"\\a\"", getLLVMStyleWithColumns(3))); 9920 EXPECT_EQ("\"\\\"", format("\"\\\"", getLLVMStyleWithColumns(2))); 9921 EXPECT_EQ("\"test\"\n" 9922 "\"\\n\"", 9923 format("\"test\\n\"", getLLVMStyleWithColumns(7))); 9924 EXPECT_EQ("\"tes\\\\\"\n" 9925 "\"n\"", 9926 format("\"tes\\\\n\"", getLLVMStyleWithColumns(7))); 9927 EXPECT_EQ("\"\\\\\\\\\"\n" 9928 "\"\\n\"", 9929 format("\"\\\\\\\\\\n\"", getLLVMStyleWithColumns(7))); 9930 EXPECT_EQ("\"\\uff01\"", format("\"\\uff01\"", getLLVMStyleWithColumns(7))); 9931 EXPECT_EQ("\"\\uff01\"\n" 9932 "\"test\"", 9933 format("\"\\uff01test\"", getLLVMStyleWithColumns(8))); 9934 EXPECT_EQ("\"\\Uff01ff02\"", 9935 format("\"\\Uff01ff02\"", getLLVMStyleWithColumns(11))); 9936 EXPECT_EQ("\"\\x000000000001\"\n" 9937 "\"next\"", 9938 format("\"\\x000000000001next\"", getLLVMStyleWithColumns(16))); 9939 EXPECT_EQ("\"\\x000000000001next\"", 9940 format("\"\\x000000000001next\"", getLLVMStyleWithColumns(15))); 9941 EXPECT_EQ("\"\\x000000000001\"", 9942 format("\"\\x000000000001\"", getLLVMStyleWithColumns(7))); 9943 EXPECT_EQ("\"test\"\n" 9944 "\"\\000000\"\n" 9945 "\"000001\"", 9946 format("\"test\\000000000001\"", getLLVMStyleWithColumns(9))); 9947 EXPECT_EQ("\"test\\000\"\n" 9948 "\"00000000\"\n" 9949 "\"1\"", 9950 format("\"test\\000000000001\"", getLLVMStyleWithColumns(10))); 9951 } 9952 9953 TEST_F(FormatTest, DoNotCreateUnreasonableUnwrappedLines) { 9954 verifyFormat("void f() {\n" 9955 " return g() {}\n" 9956 " void h() {}"); 9957 verifyFormat("int a[] = {void forgot_closing_brace(){f();\n" 9958 "g();\n" 9959 "}"); 9960 } 9961 9962 TEST_F(FormatTest, DoNotPrematurelyEndUnwrappedLineForReturnStatements) { 9963 verifyFormat( 9964 "void f() { return C{param1, param2}.SomeCall(param1, param2); }"); 9965 } 9966 9967 TEST_F(FormatTest, FormatsClosingBracesInEmptyNestedBlocks) { 9968 verifyFormat("class X {\n" 9969 " void f() {\n" 9970 " }\n" 9971 "};", 9972 getLLVMStyleWithColumns(12)); 9973 } 9974 9975 TEST_F(FormatTest, ConfigurableIndentWidth) { 9976 FormatStyle EightIndent = getLLVMStyleWithColumns(18); 9977 EightIndent.IndentWidth = 8; 9978 EightIndent.ContinuationIndentWidth = 8; 9979 verifyFormat("void f() {\n" 9980 " someFunction();\n" 9981 " if (true) {\n" 9982 " f();\n" 9983 " }\n" 9984 "}", 9985 EightIndent); 9986 verifyFormat("class X {\n" 9987 " void f() {\n" 9988 " }\n" 9989 "};", 9990 EightIndent); 9991 verifyFormat("int x[] = {\n" 9992 " call(),\n" 9993 " call()};", 9994 EightIndent); 9995 } 9996 9997 TEST_F(FormatTest, ConfigurableFunctionDeclarationIndentAfterType) { 9998 verifyFormat("double\n" 9999 "f();", 10000 getLLVMStyleWithColumns(8)); 10001 } 10002 10003 TEST_F(FormatTest, ConfigurableUseOfTab) { 10004 FormatStyle Tab = getLLVMStyleWithColumns(42); 10005 Tab.IndentWidth = 8; 10006 Tab.UseTab = FormatStyle::UT_Always; 10007 Tab.AlignEscapedNewlines = FormatStyle::ENAS_Left; 10008 10009 EXPECT_EQ("if (aaaaaaaa && // q\n" 10010 " bb)\t\t// w\n" 10011 "\t;", 10012 format("if (aaaaaaaa &&// q\n" 10013 "bb)// w\n" 10014 ";", 10015 Tab)); 10016 EXPECT_EQ("if (aaa && bbb) // w\n" 10017 "\t;", 10018 format("if(aaa&&bbb)// w\n" 10019 ";", 10020 Tab)); 10021 10022 verifyFormat("class X {\n" 10023 "\tvoid f() {\n" 10024 "\t\tsomeFunction(parameter1,\n" 10025 "\t\t\t parameter2);\n" 10026 "\t}\n" 10027 "};", 10028 Tab); 10029 verifyFormat("#define A \\\n" 10030 "\tvoid f() { \\\n" 10031 "\t\tsomeFunction( \\\n" 10032 "\t\t parameter1, \\\n" 10033 "\t\t parameter2); \\\n" 10034 "\t}", 10035 Tab); 10036 verifyFormat("int a;\t // x\n" 10037 "int bbbbbbbb; // x\n", 10038 Tab); 10039 10040 Tab.TabWidth = 4; 10041 Tab.IndentWidth = 8; 10042 verifyFormat("class TabWidth4Indent8 {\n" 10043 "\t\tvoid f() {\n" 10044 "\t\t\t\tsomeFunction(parameter1,\n" 10045 "\t\t\t\t\t\t\t parameter2);\n" 10046 "\t\t}\n" 10047 "};", 10048 Tab); 10049 10050 Tab.TabWidth = 4; 10051 Tab.IndentWidth = 4; 10052 verifyFormat("class TabWidth4Indent4 {\n" 10053 "\tvoid f() {\n" 10054 "\t\tsomeFunction(parameter1,\n" 10055 "\t\t\t\t\t parameter2);\n" 10056 "\t}\n" 10057 "};", 10058 Tab); 10059 10060 Tab.TabWidth = 8; 10061 Tab.IndentWidth = 4; 10062 verifyFormat("class TabWidth8Indent4 {\n" 10063 " void f() {\n" 10064 "\tsomeFunction(parameter1,\n" 10065 "\t\t parameter2);\n" 10066 " }\n" 10067 "};", 10068 Tab); 10069 10070 Tab.TabWidth = 8; 10071 Tab.IndentWidth = 8; 10072 EXPECT_EQ("/*\n" 10073 "\t a\t\tcomment\n" 10074 "\t in multiple lines\n" 10075 " */", 10076 format(" /*\t \t \n" 10077 " \t \t a\t\tcomment\t \t\n" 10078 " \t \t in multiple lines\t\n" 10079 " \t */", 10080 Tab)); 10081 10082 Tab.UseTab = FormatStyle::UT_ForIndentation; 10083 verifyFormat("{\n" 10084 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10085 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10086 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10087 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10088 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10089 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10090 "};", 10091 Tab); 10092 verifyFormat("enum AA {\n" 10093 "\ta1, // Force multiple lines\n" 10094 "\ta2,\n" 10095 "\ta3\n" 10096 "};", 10097 Tab); 10098 EXPECT_EQ("if (aaaaaaaa && // q\n" 10099 " bb) // w\n" 10100 "\t;", 10101 format("if (aaaaaaaa &&// q\n" 10102 "bb)// w\n" 10103 ";", 10104 Tab)); 10105 verifyFormat("class X {\n" 10106 "\tvoid f() {\n" 10107 "\t\tsomeFunction(parameter1,\n" 10108 "\t\t parameter2);\n" 10109 "\t}\n" 10110 "};", 10111 Tab); 10112 verifyFormat("{\n" 10113 "\tQ(\n" 10114 "\t {\n" 10115 "\t\t int a;\n" 10116 "\t\t someFunction(aaaaaaaa,\n" 10117 "\t\t bbbbbbb);\n" 10118 "\t },\n" 10119 "\t p);\n" 10120 "}", 10121 Tab); 10122 EXPECT_EQ("{\n" 10123 "\t/* aaaa\n" 10124 "\t bbbb */\n" 10125 "}", 10126 format("{\n" 10127 "/* aaaa\n" 10128 " bbbb */\n" 10129 "}", 10130 Tab)); 10131 EXPECT_EQ("{\n" 10132 "\t/*\n" 10133 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10134 "\t bbbbbbbbbbbbb\n" 10135 "\t*/\n" 10136 "}", 10137 format("{\n" 10138 "/*\n" 10139 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10140 "*/\n" 10141 "}", 10142 Tab)); 10143 EXPECT_EQ("{\n" 10144 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10145 "\t// bbbbbbbbbbbbb\n" 10146 "}", 10147 format("{\n" 10148 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10149 "}", 10150 Tab)); 10151 EXPECT_EQ("{\n" 10152 "\t/*\n" 10153 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10154 "\t bbbbbbbbbbbbb\n" 10155 "\t*/\n" 10156 "}", 10157 format("{\n" 10158 "\t/*\n" 10159 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10160 "\t*/\n" 10161 "}", 10162 Tab)); 10163 EXPECT_EQ("{\n" 10164 "\t/*\n" 10165 "\n" 10166 "\t*/\n" 10167 "}", 10168 format("{\n" 10169 "\t/*\n" 10170 "\n" 10171 "\t*/\n" 10172 "}", 10173 Tab)); 10174 EXPECT_EQ("{\n" 10175 "\t/*\n" 10176 " asdf\n" 10177 "\t*/\n" 10178 "}", 10179 format("{\n" 10180 "\t/*\n" 10181 " asdf\n" 10182 "\t*/\n" 10183 "}", 10184 Tab)); 10185 10186 Tab.UseTab = FormatStyle::UT_Never; 10187 EXPECT_EQ("/*\n" 10188 " a\t\tcomment\n" 10189 " in multiple lines\n" 10190 " */", 10191 format(" /*\t \t \n" 10192 " \t \t a\t\tcomment\t \t\n" 10193 " \t \t in multiple lines\t\n" 10194 " \t */", 10195 Tab)); 10196 EXPECT_EQ("/* some\n" 10197 " comment */", 10198 format(" \t \t /* some\n" 10199 " \t \t comment */", 10200 Tab)); 10201 EXPECT_EQ("int a; /* some\n" 10202 " comment */", 10203 format(" \t \t int a; /* some\n" 10204 " \t \t comment */", 10205 Tab)); 10206 10207 EXPECT_EQ("int a; /* some\n" 10208 "comment */", 10209 format(" \t \t int\ta; /* some\n" 10210 " \t \t comment */", 10211 Tab)); 10212 EXPECT_EQ("f(\"\t\t\"); /* some\n" 10213 " comment */", 10214 format(" \t \t f(\"\t\t\"); /* some\n" 10215 " \t \t comment */", 10216 Tab)); 10217 EXPECT_EQ("{\n" 10218 " /*\n" 10219 " * Comment\n" 10220 " */\n" 10221 " int i;\n" 10222 "}", 10223 format("{\n" 10224 "\t/*\n" 10225 "\t * Comment\n" 10226 "\t */\n" 10227 "\t int i;\n" 10228 "}", 10229 Tab)); 10230 10231 Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation; 10232 Tab.TabWidth = 8; 10233 Tab.IndentWidth = 8; 10234 EXPECT_EQ("if (aaaaaaaa && // q\n" 10235 " bb) // w\n" 10236 "\t;", 10237 format("if (aaaaaaaa &&// q\n" 10238 "bb)// w\n" 10239 ";", 10240 Tab)); 10241 EXPECT_EQ("if (aaa && bbb) // w\n" 10242 "\t;", 10243 format("if(aaa&&bbb)// w\n" 10244 ";", 10245 Tab)); 10246 verifyFormat("class X {\n" 10247 "\tvoid f() {\n" 10248 "\t\tsomeFunction(parameter1,\n" 10249 "\t\t\t parameter2);\n" 10250 "\t}\n" 10251 "};", 10252 Tab); 10253 verifyFormat("#define A \\\n" 10254 "\tvoid f() { \\\n" 10255 "\t\tsomeFunction( \\\n" 10256 "\t\t parameter1, \\\n" 10257 "\t\t parameter2); \\\n" 10258 "\t}", 10259 Tab); 10260 Tab.TabWidth = 4; 10261 Tab.IndentWidth = 8; 10262 verifyFormat("class TabWidth4Indent8 {\n" 10263 "\t\tvoid f() {\n" 10264 "\t\t\t\tsomeFunction(parameter1,\n" 10265 "\t\t\t\t\t\t\t parameter2);\n" 10266 "\t\t}\n" 10267 "};", 10268 Tab); 10269 Tab.TabWidth = 4; 10270 Tab.IndentWidth = 4; 10271 verifyFormat("class TabWidth4Indent4 {\n" 10272 "\tvoid f() {\n" 10273 "\t\tsomeFunction(parameter1,\n" 10274 "\t\t\t\t\t parameter2);\n" 10275 "\t}\n" 10276 "};", 10277 Tab); 10278 Tab.TabWidth = 8; 10279 Tab.IndentWidth = 4; 10280 verifyFormat("class TabWidth8Indent4 {\n" 10281 " void f() {\n" 10282 "\tsomeFunction(parameter1,\n" 10283 "\t\t parameter2);\n" 10284 " }\n" 10285 "};", 10286 Tab); 10287 Tab.TabWidth = 8; 10288 Tab.IndentWidth = 8; 10289 EXPECT_EQ("/*\n" 10290 "\t a\t\tcomment\n" 10291 "\t in multiple lines\n" 10292 " */", 10293 format(" /*\t \t \n" 10294 " \t \t a\t\tcomment\t \t\n" 10295 " \t \t in multiple lines\t\n" 10296 " \t */", 10297 Tab)); 10298 verifyFormat("{\n" 10299 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10300 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10301 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10302 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10303 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10304 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10305 "};", 10306 Tab); 10307 verifyFormat("enum AA {\n" 10308 "\ta1, // Force multiple lines\n" 10309 "\ta2,\n" 10310 "\ta3\n" 10311 "};", 10312 Tab); 10313 EXPECT_EQ("if (aaaaaaaa && // q\n" 10314 " bb) // w\n" 10315 "\t;", 10316 format("if (aaaaaaaa &&// q\n" 10317 "bb)// w\n" 10318 ";", 10319 Tab)); 10320 verifyFormat("class X {\n" 10321 "\tvoid f() {\n" 10322 "\t\tsomeFunction(parameter1,\n" 10323 "\t\t\t parameter2);\n" 10324 "\t}\n" 10325 "};", 10326 Tab); 10327 verifyFormat("{\n" 10328 "\tQ(\n" 10329 "\t {\n" 10330 "\t\t int a;\n" 10331 "\t\t someFunction(aaaaaaaa,\n" 10332 "\t\t\t\t bbbbbbb);\n" 10333 "\t },\n" 10334 "\t p);\n" 10335 "}", 10336 Tab); 10337 EXPECT_EQ("{\n" 10338 "\t/* aaaa\n" 10339 "\t bbbb */\n" 10340 "}", 10341 format("{\n" 10342 "/* aaaa\n" 10343 " bbbb */\n" 10344 "}", 10345 Tab)); 10346 EXPECT_EQ("{\n" 10347 "\t/*\n" 10348 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10349 "\t bbbbbbbbbbbbb\n" 10350 "\t*/\n" 10351 "}", 10352 format("{\n" 10353 "/*\n" 10354 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10355 "*/\n" 10356 "}", 10357 Tab)); 10358 EXPECT_EQ("{\n" 10359 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10360 "\t// bbbbbbbbbbbbb\n" 10361 "}", 10362 format("{\n" 10363 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10364 "}", 10365 Tab)); 10366 EXPECT_EQ("{\n" 10367 "\t/*\n" 10368 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10369 "\t bbbbbbbbbbbbb\n" 10370 "\t*/\n" 10371 "}", 10372 format("{\n" 10373 "\t/*\n" 10374 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10375 "\t*/\n" 10376 "}", 10377 Tab)); 10378 EXPECT_EQ("{\n" 10379 "\t/*\n" 10380 "\n" 10381 "\t*/\n" 10382 "}", 10383 format("{\n" 10384 "\t/*\n" 10385 "\n" 10386 "\t*/\n" 10387 "}", 10388 Tab)); 10389 EXPECT_EQ("{\n" 10390 "\t/*\n" 10391 " asdf\n" 10392 "\t*/\n" 10393 "}", 10394 format("{\n" 10395 "\t/*\n" 10396 " asdf\n" 10397 "\t*/\n" 10398 "}", 10399 Tab)); 10400 EXPECT_EQ("/* some\n" 10401 " comment */", 10402 format(" \t \t /* some\n" 10403 " \t \t comment */", 10404 Tab)); 10405 EXPECT_EQ("int a; /* some\n" 10406 " comment */", 10407 format(" \t \t int a; /* some\n" 10408 " \t \t comment */", 10409 Tab)); 10410 EXPECT_EQ("int a; /* some\n" 10411 "comment */", 10412 format(" \t \t int\ta; /* some\n" 10413 " \t \t comment */", 10414 Tab)); 10415 EXPECT_EQ("f(\"\t\t\"); /* some\n" 10416 " comment */", 10417 format(" \t \t f(\"\t\t\"); /* some\n" 10418 " \t \t comment */", 10419 Tab)); 10420 EXPECT_EQ("{\n" 10421 "\t/*\n" 10422 "\t * Comment\n" 10423 "\t */\n" 10424 "\tint i;\n" 10425 "}", 10426 format("{\n" 10427 "\t/*\n" 10428 "\t * Comment\n" 10429 "\t */\n" 10430 "\t int i;\n" 10431 "}", 10432 Tab)); 10433 Tab.TabWidth = 2; 10434 Tab.IndentWidth = 2; 10435 EXPECT_EQ("{\n" 10436 "\t/* aaaa\n" 10437 "\t\t bbbb */\n" 10438 "}", 10439 format("{\n" 10440 "/* aaaa\n" 10441 "\t bbbb */\n" 10442 "}", 10443 Tab)); 10444 EXPECT_EQ("{\n" 10445 "\t/*\n" 10446 "\t\taaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10447 "\t\tbbbbbbbbbbbbb\n" 10448 "\t*/\n" 10449 "}", 10450 format("{\n" 10451 "/*\n" 10452 "\taaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10453 "*/\n" 10454 "}", 10455 Tab)); 10456 Tab.AlignConsecutiveAssignments = true; 10457 Tab.AlignConsecutiveDeclarations = true; 10458 Tab.TabWidth = 4; 10459 Tab.IndentWidth = 4; 10460 verifyFormat("class Assign {\n" 10461 "\tvoid f() {\n" 10462 "\t\tint x = 123;\n" 10463 "\t\tint random = 4;\n" 10464 "\t\tstd::string alphabet =\n" 10465 "\t\t\t\"abcdefghijklmnopqrstuvwxyz\";\n" 10466 "\t}\n" 10467 "};", 10468 Tab); 10469 10470 Tab.UseTab = FormatStyle::UT_AlignWithSpaces; 10471 Tab.TabWidth = 8; 10472 Tab.IndentWidth = 8; 10473 EXPECT_EQ("if (aaaaaaaa && // q\n" 10474 " bb) // w\n" 10475 "\t;", 10476 format("if (aaaaaaaa &&// q\n" 10477 "bb)// w\n" 10478 ";", 10479 Tab)); 10480 EXPECT_EQ("if (aaa && bbb) // w\n" 10481 "\t;", 10482 format("if(aaa&&bbb)// w\n" 10483 ";", 10484 Tab)); 10485 verifyFormat("class X {\n" 10486 "\tvoid f() {\n" 10487 "\t\tsomeFunction(parameter1,\n" 10488 "\t\t parameter2);\n" 10489 "\t}\n" 10490 "};", 10491 Tab); 10492 verifyFormat("#define A \\\n" 10493 "\tvoid f() { \\\n" 10494 "\t\tsomeFunction( \\\n" 10495 "\t\t parameter1, \\\n" 10496 "\t\t parameter2); \\\n" 10497 "\t}", 10498 Tab); 10499 Tab.TabWidth = 4; 10500 Tab.IndentWidth = 8; 10501 verifyFormat("class TabWidth4Indent8 {\n" 10502 "\t\tvoid f() {\n" 10503 "\t\t\t\tsomeFunction(parameter1,\n" 10504 "\t\t\t\t parameter2);\n" 10505 "\t\t}\n" 10506 "};", 10507 Tab); 10508 Tab.TabWidth = 4; 10509 Tab.IndentWidth = 4; 10510 verifyFormat("class TabWidth4Indent4 {\n" 10511 "\tvoid f() {\n" 10512 "\t\tsomeFunction(parameter1,\n" 10513 "\t\t parameter2);\n" 10514 "\t}\n" 10515 "};", 10516 Tab); 10517 Tab.TabWidth = 8; 10518 Tab.IndentWidth = 4; 10519 verifyFormat("class TabWidth8Indent4 {\n" 10520 " void f() {\n" 10521 "\tsomeFunction(parameter1,\n" 10522 "\t parameter2);\n" 10523 " }\n" 10524 "};", 10525 Tab); 10526 Tab.TabWidth = 8; 10527 Tab.IndentWidth = 8; 10528 EXPECT_EQ("/*\n" 10529 " a\t\tcomment\n" 10530 " in multiple lines\n" 10531 " */", 10532 format(" /*\t \t \n" 10533 " \t \t a\t\tcomment\t \t\n" 10534 " \t \t in multiple lines\t\n" 10535 " \t */", 10536 Tab)); 10537 verifyFormat("{\n" 10538 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10539 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10540 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10541 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10542 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10543 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10544 "};", 10545 Tab); 10546 verifyFormat("enum AA {\n" 10547 "\ta1, // Force multiple lines\n" 10548 "\ta2,\n" 10549 "\ta3\n" 10550 "};", 10551 Tab); 10552 EXPECT_EQ("if (aaaaaaaa && // q\n" 10553 " bb) // w\n" 10554 "\t;", 10555 format("if (aaaaaaaa &&// q\n" 10556 "bb)// w\n" 10557 ";", 10558 Tab)); 10559 verifyFormat("class X {\n" 10560 "\tvoid f() {\n" 10561 "\t\tsomeFunction(parameter1,\n" 10562 "\t\t parameter2);\n" 10563 "\t}\n" 10564 "};", 10565 Tab); 10566 verifyFormat("{\n" 10567 "\tQ(\n" 10568 "\t {\n" 10569 "\t\t int a;\n" 10570 "\t\t someFunction(aaaaaaaa,\n" 10571 "\t\t bbbbbbb);\n" 10572 "\t },\n" 10573 "\t p);\n" 10574 "}", 10575 Tab); 10576 EXPECT_EQ("{\n" 10577 "\t/* aaaa\n" 10578 "\t bbbb */\n" 10579 "}", 10580 format("{\n" 10581 "/* aaaa\n" 10582 " bbbb */\n" 10583 "}", 10584 Tab)); 10585 EXPECT_EQ("{\n" 10586 "\t/*\n" 10587 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10588 "\t bbbbbbbbbbbbb\n" 10589 "\t*/\n" 10590 "}", 10591 format("{\n" 10592 "/*\n" 10593 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10594 "*/\n" 10595 "}", 10596 Tab)); 10597 EXPECT_EQ("{\n" 10598 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10599 "\t// bbbbbbbbbbbbb\n" 10600 "}", 10601 format("{\n" 10602 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10603 "}", 10604 Tab)); 10605 EXPECT_EQ("{\n" 10606 "\t/*\n" 10607 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10608 "\t bbbbbbbbbbbbb\n" 10609 "\t*/\n" 10610 "}", 10611 format("{\n" 10612 "\t/*\n" 10613 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10614 "\t*/\n" 10615 "}", 10616 Tab)); 10617 EXPECT_EQ("{\n" 10618 "\t/*\n" 10619 "\n" 10620 "\t*/\n" 10621 "}", 10622 format("{\n" 10623 "\t/*\n" 10624 "\n" 10625 "\t*/\n" 10626 "}", 10627 Tab)); 10628 EXPECT_EQ("{\n" 10629 "\t/*\n" 10630 " asdf\n" 10631 "\t*/\n" 10632 "}", 10633 format("{\n" 10634 "\t/*\n" 10635 " asdf\n" 10636 "\t*/\n" 10637 "}", 10638 Tab)); 10639 EXPECT_EQ("/* some\n" 10640 " comment */", 10641 format(" \t \t /* some\n" 10642 " \t \t comment */", 10643 Tab)); 10644 EXPECT_EQ("int a; /* some\n" 10645 " comment */", 10646 format(" \t \t int a; /* some\n" 10647 " \t \t comment */", 10648 Tab)); 10649 EXPECT_EQ("int a; /* some\n" 10650 "comment */", 10651 format(" \t \t int\ta; /* some\n" 10652 " \t \t comment */", 10653 Tab)); 10654 EXPECT_EQ("f(\"\t\t\"); /* some\n" 10655 " comment */", 10656 format(" \t \t f(\"\t\t\"); /* some\n" 10657 " \t \t comment */", 10658 Tab)); 10659 EXPECT_EQ("{\n" 10660 "\t/*\n" 10661 "\t * Comment\n" 10662 "\t */\n" 10663 "\tint i;\n" 10664 "}", 10665 format("{\n" 10666 "\t/*\n" 10667 "\t * Comment\n" 10668 "\t */\n" 10669 "\t int i;\n" 10670 "}", 10671 Tab)); 10672 Tab.TabWidth = 2; 10673 Tab.IndentWidth = 2; 10674 EXPECT_EQ("{\n" 10675 "\t/* aaaa\n" 10676 "\t bbbb */\n" 10677 "}", 10678 format("{\n" 10679 "/* aaaa\n" 10680 " bbbb */\n" 10681 "}", 10682 Tab)); 10683 EXPECT_EQ("{\n" 10684 "\t/*\n" 10685 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10686 "\t bbbbbbbbbbbbb\n" 10687 "\t*/\n" 10688 "}", 10689 format("{\n" 10690 "/*\n" 10691 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10692 "*/\n" 10693 "}", 10694 Tab)); 10695 Tab.AlignConsecutiveAssignments = true; 10696 Tab.AlignConsecutiveDeclarations = true; 10697 Tab.TabWidth = 4; 10698 Tab.IndentWidth = 4; 10699 verifyFormat("class Assign {\n" 10700 "\tvoid f() {\n" 10701 "\t\tint x = 123;\n" 10702 "\t\tint random = 4;\n" 10703 "\t\tstd::string alphabet =\n" 10704 "\t\t\t\"abcdefghijklmnopqrstuvwxyz\";\n" 10705 "\t}\n" 10706 "};", 10707 Tab); 10708 } 10709 10710 TEST_F(FormatTest, ZeroTabWidth) { 10711 FormatStyle Tab = getLLVMStyleWithColumns(42); 10712 Tab.IndentWidth = 8; 10713 Tab.UseTab = FormatStyle::UT_Never; 10714 Tab.TabWidth = 0; 10715 EXPECT_EQ("void a(){\n" 10716 " // line starts with '\t'\n" 10717 "};", 10718 format("void a(){\n" 10719 "\t// line starts with '\t'\n" 10720 "};", 10721 Tab)); 10722 10723 EXPECT_EQ("void a(){\n" 10724 " // line starts with '\t'\n" 10725 "};", 10726 format("void a(){\n" 10727 "\t\t// line starts with '\t'\n" 10728 "};", 10729 Tab)); 10730 10731 Tab.UseTab = FormatStyle::UT_ForIndentation; 10732 EXPECT_EQ("void a(){\n" 10733 " // line starts with '\t'\n" 10734 "};", 10735 format("void a(){\n" 10736 "\t// line starts with '\t'\n" 10737 "};", 10738 Tab)); 10739 10740 EXPECT_EQ("void a(){\n" 10741 " // line starts with '\t'\n" 10742 "};", 10743 format("void a(){\n" 10744 "\t\t// line starts with '\t'\n" 10745 "};", 10746 Tab)); 10747 10748 Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation; 10749 EXPECT_EQ("void a(){\n" 10750 " // line starts with '\t'\n" 10751 "};", 10752 format("void a(){\n" 10753 "\t// line starts with '\t'\n" 10754 "};", 10755 Tab)); 10756 10757 EXPECT_EQ("void a(){\n" 10758 " // line starts with '\t'\n" 10759 "};", 10760 format("void a(){\n" 10761 "\t\t// line starts with '\t'\n" 10762 "};", 10763 Tab)); 10764 10765 Tab.UseTab = FormatStyle::UT_AlignWithSpaces; 10766 EXPECT_EQ("void a(){\n" 10767 " // line starts with '\t'\n" 10768 "};", 10769 format("void a(){\n" 10770 "\t// line starts with '\t'\n" 10771 "};", 10772 Tab)); 10773 10774 EXPECT_EQ("void a(){\n" 10775 " // line starts with '\t'\n" 10776 "};", 10777 format("void a(){\n" 10778 "\t\t// line starts with '\t'\n" 10779 "};", 10780 Tab)); 10781 10782 Tab.UseTab = FormatStyle::UT_Always; 10783 EXPECT_EQ("void a(){\n" 10784 "// line starts with '\t'\n" 10785 "};", 10786 format("void a(){\n" 10787 "\t// line starts with '\t'\n" 10788 "};", 10789 Tab)); 10790 10791 EXPECT_EQ("void a(){\n" 10792 "// line starts with '\t'\n" 10793 "};", 10794 format("void a(){\n" 10795 "\t\t// line starts with '\t'\n" 10796 "};", 10797 Tab)); 10798 } 10799 10800 TEST_F(FormatTest, CalculatesOriginalColumn) { 10801 EXPECT_EQ("\"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 10802 "q\"; /* some\n" 10803 " comment */", 10804 format(" \"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 10805 "q\"; /* some\n" 10806 " comment */", 10807 getLLVMStyle())); 10808 EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n" 10809 "/* some\n" 10810 " comment */", 10811 format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n" 10812 " /* some\n" 10813 " comment */", 10814 getLLVMStyle())); 10815 EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 10816 "qqq\n" 10817 "/* some\n" 10818 " comment */", 10819 format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 10820 "qqq\n" 10821 " /* some\n" 10822 " comment */", 10823 getLLVMStyle())); 10824 EXPECT_EQ("inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 10825 "wwww; /* some\n" 10826 " comment */", 10827 format(" inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 10828 "wwww; /* some\n" 10829 " comment */", 10830 getLLVMStyle())); 10831 } 10832 10833 TEST_F(FormatTest, ConfigurableSpaceBeforeParens) { 10834 FormatStyle NoSpace = getLLVMStyle(); 10835 NoSpace.SpaceBeforeParens = FormatStyle::SBPO_Never; 10836 10837 verifyFormat("while(true)\n" 10838 " continue;", 10839 NoSpace); 10840 verifyFormat("for(;;)\n" 10841 " continue;", 10842 NoSpace); 10843 verifyFormat("if(true)\n" 10844 " f();\n" 10845 "else if(true)\n" 10846 " f();", 10847 NoSpace); 10848 verifyFormat("do {\n" 10849 " do_something();\n" 10850 "} while(something());", 10851 NoSpace); 10852 verifyFormat("switch(x) {\n" 10853 "default:\n" 10854 " break;\n" 10855 "}", 10856 NoSpace); 10857 verifyFormat("auto i = std::make_unique<int>(5);", NoSpace); 10858 verifyFormat("size_t x = sizeof(x);", NoSpace); 10859 verifyFormat("auto f(int x) -> decltype(x);", NoSpace); 10860 verifyFormat("int f(T x) noexcept(x.create());", NoSpace); 10861 verifyFormat("alignas(128) char a[128];", NoSpace); 10862 verifyFormat("size_t x = alignof(MyType);", NoSpace); 10863 verifyFormat("static_assert(sizeof(char) == 1, \"Impossible!\");", NoSpace); 10864 verifyFormat("int f() throw(Deprecated);", NoSpace); 10865 verifyFormat("typedef void (*cb)(int);", NoSpace); 10866 verifyFormat("T A::operator()();", NoSpace); 10867 verifyFormat("X A::operator++(T);", NoSpace); 10868 verifyFormat("auto lambda = []() { return 0; };", NoSpace); 10869 10870 FormatStyle Space = getLLVMStyle(); 10871 Space.SpaceBeforeParens = FormatStyle::SBPO_Always; 10872 10873 verifyFormat("int f ();", Space); 10874 verifyFormat("void f (int a, T b) {\n" 10875 " while (true)\n" 10876 " continue;\n" 10877 "}", 10878 Space); 10879 verifyFormat("if (true)\n" 10880 " f ();\n" 10881 "else if (true)\n" 10882 " f ();", 10883 Space); 10884 verifyFormat("do {\n" 10885 " do_something ();\n" 10886 "} while (something ());", 10887 Space); 10888 verifyFormat("switch (x) {\n" 10889 "default:\n" 10890 " break;\n" 10891 "}", 10892 Space); 10893 verifyFormat("A::A () : a (1) {}", Space); 10894 verifyFormat("void f () __attribute__ ((asdf));", Space); 10895 verifyFormat("*(&a + 1);\n" 10896 "&((&a)[1]);\n" 10897 "a[(b + c) * d];\n" 10898 "(((a + 1) * 2) + 3) * 4;", 10899 Space); 10900 verifyFormat("#define A(x) x", Space); 10901 verifyFormat("#define A (x) x", Space); 10902 verifyFormat("#if defined(x)\n" 10903 "#endif", 10904 Space); 10905 verifyFormat("auto i = std::make_unique<int> (5);", Space); 10906 verifyFormat("size_t x = sizeof (x);", Space); 10907 verifyFormat("auto f (int x) -> decltype (x);", Space); 10908 verifyFormat("int f (T x) noexcept (x.create ());", Space); 10909 verifyFormat("alignas (128) char a[128];", Space); 10910 verifyFormat("size_t x = alignof (MyType);", Space); 10911 verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");", Space); 10912 verifyFormat("int f () throw (Deprecated);", Space); 10913 verifyFormat("typedef void (*cb) (int);", Space); 10914 verifyFormat("T A::operator() ();", Space); 10915 verifyFormat("X A::operator++ (T);", Space); 10916 verifyFormat("auto lambda = [] () { return 0; };", Space); 10917 verifyFormat("int x = int (y);", Space); 10918 10919 FormatStyle SomeSpace = getLLVMStyle(); 10920 SomeSpace.SpaceBeforeParens = FormatStyle::SBPO_NonEmptyParentheses; 10921 10922 verifyFormat("[]() -> float {}", SomeSpace); 10923 verifyFormat("[] (auto foo) {}", SomeSpace); 10924 verifyFormat("[foo]() -> int {}", SomeSpace); 10925 verifyFormat("int f();", SomeSpace); 10926 verifyFormat("void f (int a, T b) {\n" 10927 " while (true)\n" 10928 " continue;\n" 10929 "}", 10930 SomeSpace); 10931 verifyFormat("if (true)\n" 10932 " f();\n" 10933 "else if (true)\n" 10934 " f();", 10935 SomeSpace); 10936 verifyFormat("do {\n" 10937 " do_something();\n" 10938 "} while (something());", 10939 SomeSpace); 10940 verifyFormat("switch (x) {\n" 10941 "default:\n" 10942 " break;\n" 10943 "}", 10944 SomeSpace); 10945 verifyFormat("A::A() : a (1) {}", SomeSpace); 10946 verifyFormat("void f() __attribute__ ((asdf));", SomeSpace); 10947 verifyFormat("*(&a + 1);\n" 10948 "&((&a)[1]);\n" 10949 "a[(b + c) * d];\n" 10950 "(((a + 1) * 2) + 3) * 4;", 10951 SomeSpace); 10952 verifyFormat("#define A(x) x", SomeSpace); 10953 verifyFormat("#define A (x) x", SomeSpace); 10954 verifyFormat("#if defined(x)\n" 10955 "#endif", 10956 SomeSpace); 10957 verifyFormat("auto i = std::make_unique<int> (5);", SomeSpace); 10958 verifyFormat("size_t x = sizeof (x);", SomeSpace); 10959 verifyFormat("auto f (int x) -> decltype (x);", SomeSpace); 10960 verifyFormat("int f (T x) noexcept (x.create());", SomeSpace); 10961 verifyFormat("alignas (128) char a[128];", SomeSpace); 10962 verifyFormat("size_t x = alignof (MyType);", SomeSpace); 10963 verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");", 10964 SomeSpace); 10965 verifyFormat("int f() throw (Deprecated);", SomeSpace); 10966 verifyFormat("typedef void (*cb) (int);", SomeSpace); 10967 verifyFormat("T A::operator()();", SomeSpace); 10968 verifyFormat("X A::operator++ (T);", SomeSpace); 10969 verifyFormat("int x = int (y);", SomeSpace); 10970 verifyFormat("auto lambda = []() { return 0; };", SomeSpace); 10971 } 10972 10973 TEST_F(FormatTest, SpaceAfterLogicalNot) { 10974 FormatStyle Spaces = getLLVMStyle(); 10975 Spaces.SpaceAfterLogicalNot = true; 10976 10977 verifyFormat("bool x = ! y", Spaces); 10978 verifyFormat("if (! isFailure())", Spaces); 10979 verifyFormat("if (! (a && b))", Spaces); 10980 verifyFormat("\"Error!\"", Spaces); 10981 verifyFormat("! ! x", Spaces); 10982 } 10983 10984 TEST_F(FormatTest, ConfigurableSpacesInParentheses) { 10985 FormatStyle Spaces = getLLVMStyle(); 10986 10987 Spaces.SpacesInParentheses = true; 10988 verifyFormat("do_something( ::globalVar );", Spaces); 10989 verifyFormat("call( x, y, z );", Spaces); 10990 verifyFormat("call();", Spaces); 10991 verifyFormat("std::function<void( int, int )> callback;", Spaces); 10992 verifyFormat("void inFunction() { std::function<void( int, int )> fct; }", 10993 Spaces); 10994 verifyFormat("while ( (bool)1 )\n" 10995 " continue;", 10996 Spaces); 10997 verifyFormat("for ( ;; )\n" 10998 " continue;", 10999 Spaces); 11000 verifyFormat("if ( true )\n" 11001 " f();\n" 11002 "else if ( true )\n" 11003 " f();", 11004 Spaces); 11005 verifyFormat("do {\n" 11006 " do_something( (int)i );\n" 11007 "} while ( something() );", 11008 Spaces); 11009 verifyFormat("switch ( x ) {\n" 11010 "default:\n" 11011 " break;\n" 11012 "}", 11013 Spaces); 11014 11015 Spaces.SpacesInParentheses = false; 11016 Spaces.SpacesInCStyleCastParentheses = true; 11017 verifyFormat("Type *A = ( Type * )P;", Spaces); 11018 verifyFormat("Type *A = ( vector<Type *, int *> )P;", Spaces); 11019 verifyFormat("x = ( int32 )y;", Spaces); 11020 verifyFormat("int a = ( int )(2.0f);", Spaces); 11021 verifyFormat("#define AA(X) sizeof((( X * )NULL)->a)", Spaces); 11022 verifyFormat("my_int a = ( my_int )sizeof(int);", Spaces); 11023 verifyFormat("#define x (( int )-1)", Spaces); 11024 11025 // Run the first set of tests again with: 11026 Spaces.SpacesInParentheses = false; 11027 Spaces.SpaceInEmptyParentheses = true; 11028 Spaces.SpacesInCStyleCastParentheses = true; 11029 verifyFormat("call(x, y, z);", Spaces); 11030 verifyFormat("call( );", Spaces); 11031 verifyFormat("std::function<void(int, int)> callback;", Spaces); 11032 verifyFormat("while (( bool )1)\n" 11033 " continue;", 11034 Spaces); 11035 verifyFormat("for (;;)\n" 11036 " continue;", 11037 Spaces); 11038 verifyFormat("if (true)\n" 11039 " f( );\n" 11040 "else if (true)\n" 11041 " f( );", 11042 Spaces); 11043 verifyFormat("do {\n" 11044 " do_something(( int )i);\n" 11045 "} while (something( ));", 11046 Spaces); 11047 verifyFormat("switch (x) {\n" 11048 "default:\n" 11049 " break;\n" 11050 "}", 11051 Spaces); 11052 11053 // Run the first set of tests again with: 11054 Spaces.SpaceAfterCStyleCast = true; 11055 verifyFormat("call(x, y, z);", Spaces); 11056 verifyFormat("call( );", Spaces); 11057 verifyFormat("std::function<void(int, int)> callback;", Spaces); 11058 verifyFormat("while (( bool ) 1)\n" 11059 " continue;", 11060 Spaces); 11061 verifyFormat("for (;;)\n" 11062 " continue;", 11063 Spaces); 11064 verifyFormat("if (true)\n" 11065 " f( );\n" 11066 "else if (true)\n" 11067 " f( );", 11068 Spaces); 11069 verifyFormat("do {\n" 11070 " do_something(( int ) i);\n" 11071 "} while (something( ));", 11072 Spaces); 11073 verifyFormat("switch (x) {\n" 11074 "default:\n" 11075 " break;\n" 11076 "}", 11077 Spaces); 11078 11079 // Run subset of tests again with: 11080 Spaces.SpacesInCStyleCastParentheses = false; 11081 Spaces.SpaceAfterCStyleCast = true; 11082 verifyFormat("while ((bool) 1)\n" 11083 " continue;", 11084 Spaces); 11085 verifyFormat("do {\n" 11086 " do_something((int) i);\n" 11087 "} while (something( ));", 11088 Spaces); 11089 } 11090 11091 TEST_F(FormatTest, ConfigurableSpacesInSquareBrackets) { 11092 verifyFormat("int a[5];"); 11093 verifyFormat("a[3] += 42;"); 11094 11095 FormatStyle Spaces = getLLVMStyle(); 11096 Spaces.SpacesInSquareBrackets = true; 11097 // Not lambdas. 11098 verifyFormat("int a[ 5 ];", Spaces); 11099 verifyFormat("a[ 3 ] += 42;", Spaces); 11100 verifyFormat("constexpr char hello[]{\"hello\"};", Spaces); 11101 verifyFormat("double &operator[](int i) { return 0; }\n" 11102 "int i;", 11103 Spaces); 11104 verifyFormat("std::unique_ptr<int[]> foo() {}", Spaces); 11105 verifyFormat("int i = a[ a ][ a ]->f();", Spaces); 11106 verifyFormat("int i = (*b)[ a ]->f();", Spaces); 11107 // Lambdas. 11108 verifyFormat("int c = []() -> int { return 2; }();\n", Spaces); 11109 verifyFormat("return [ i, args... ] {};", Spaces); 11110 verifyFormat("int foo = [ &bar ]() {};", Spaces); 11111 verifyFormat("int foo = [ = ]() {};", Spaces); 11112 verifyFormat("int foo = [ & ]() {};", Spaces); 11113 verifyFormat("int foo = [ =, &bar ]() {};", Spaces); 11114 verifyFormat("int foo = [ &bar, = ]() {};", Spaces); 11115 } 11116 11117 TEST_F(FormatTest, ConfigurableSpaceBeforeBrackets) { 11118 FormatStyle NoSpaceStyle = getLLVMStyle(); 11119 verifyFormat("int a[5];", NoSpaceStyle); 11120 verifyFormat("a[3] += 42;", NoSpaceStyle); 11121 11122 verifyFormat("int a[1];", NoSpaceStyle); 11123 verifyFormat("int 1 [a];", NoSpaceStyle); 11124 verifyFormat("int a[1][2];", NoSpaceStyle); 11125 verifyFormat("a[7] = 5;", NoSpaceStyle); 11126 verifyFormat("int a = (f())[23];", NoSpaceStyle); 11127 verifyFormat("f([] {})", NoSpaceStyle); 11128 11129 FormatStyle Space = getLLVMStyle(); 11130 Space.SpaceBeforeSquareBrackets = true; 11131 verifyFormat("int c = []() -> int { return 2; }();\n", Space); 11132 verifyFormat("return [i, args...] {};", Space); 11133 11134 verifyFormat("int a [5];", Space); 11135 verifyFormat("a [3] += 42;", Space); 11136 verifyFormat("constexpr char hello []{\"hello\"};", Space); 11137 verifyFormat("double &operator[](int i) { return 0; }\n" 11138 "int i;", 11139 Space); 11140 verifyFormat("std::unique_ptr<int []> foo() {}", Space); 11141 verifyFormat("int i = a [a][a]->f();", Space); 11142 verifyFormat("int i = (*b) [a]->f();", Space); 11143 11144 verifyFormat("int a [1];", Space); 11145 verifyFormat("int 1 [a];", Space); 11146 verifyFormat("int a [1][2];", Space); 11147 verifyFormat("a [7] = 5;", Space); 11148 verifyFormat("int a = (f()) [23];", Space); 11149 verifyFormat("f([] {})", Space); 11150 } 11151 11152 TEST_F(FormatTest, ConfigurableSpaceBeforeAssignmentOperators) { 11153 verifyFormat("int a = 5;"); 11154 verifyFormat("a += 42;"); 11155 verifyFormat("a or_eq 8;"); 11156 11157 FormatStyle Spaces = getLLVMStyle(); 11158 Spaces.SpaceBeforeAssignmentOperators = false; 11159 verifyFormat("int a= 5;", Spaces); 11160 verifyFormat("a+= 42;", Spaces); 11161 verifyFormat("a or_eq 8;", Spaces); 11162 } 11163 11164 TEST_F(FormatTest, ConfigurableSpaceBeforeColon) { 11165 verifyFormat("class Foo : public Bar {};"); 11166 verifyFormat("Foo::Foo() : foo(1) {}"); 11167 verifyFormat("for (auto a : b) {\n}"); 11168 verifyFormat("int x = a ? b : c;"); 11169 verifyFormat("{\n" 11170 "label0:\n" 11171 " int x = 0;\n" 11172 "}"); 11173 verifyFormat("switch (x) {\n" 11174 "case 1:\n" 11175 "default:\n" 11176 "}"); 11177 11178 FormatStyle CtorInitializerStyle = getLLVMStyleWithColumns(30); 11179 CtorInitializerStyle.SpaceBeforeCtorInitializerColon = false; 11180 verifyFormat("class Foo : public Bar {};", CtorInitializerStyle); 11181 verifyFormat("Foo::Foo(): foo(1) {}", CtorInitializerStyle); 11182 verifyFormat("for (auto a : b) {\n}", CtorInitializerStyle); 11183 verifyFormat("int x = a ? b : c;", CtorInitializerStyle); 11184 verifyFormat("{\n" 11185 "label1:\n" 11186 " int x = 0;\n" 11187 "}", 11188 CtorInitializerStyle); 11189 verifyFormat("switch (x) {\n" 11190 "case 1:\n" 11191 "default:\n" 11192 "}", 11193 CtorInitializerStyle); 11194 CtorInitializerStyle.BreakConstructorInitializers = 11195 FormatStyle::BCIS_AfterColon; 11196 verifyFormat("Fooooooooooo::Fooooooooooo():\n" 11197 " aaaaaaaaaaaaaaaa(1),\n" 11198 " bbbbbbbbbbbbbbbb(2) {}", 11199 CtorInitializerStyle); 11200 CtorInitializerStyle.BreakConstructorInitializers = 11201 FormatStyle::BCIS_BeforeComma; 11202 verifyFormat("Fooooooooooo::Fooooooooooo()\n" 11203 " : aaaaaaaaaaaaaaaa(1)\n" 11204 " , bbbbbbbbbbbbbbbb(2) {}", 11205 CtorInitializerStyle); 11206 CtorInitializerStyle.BreakConstructorInitializers = 11207 FormatStyle::BCIS_BeforeColon; 11208 verifyFormat("Fooooooooooo::Fooooooooooo()\n" 11209 " : aaaaaaaaaaaaaaaa(1),\n" 11210 " bbbbbbbbbbbbbbbb(2) {}", 11211 CtorInitializerStyle); 11212 CtorInitializerStyle.ConstructorInitializerIndentWidth = 0; 11213 verifyFormat("Fooooooooooo::Fooooooooooo()\n" 11214 ": aaaaaaaaaaaaaaaa(1),\n" 11215 " bbbbbbbbbbbbbbbb(2) {}", 11216 CtorInitializerStyle); 11217 11218 FormatStyle InheritanceStyle = getLLVMStyleWithColumns(30); 11219 InheritanceStyle.SpaceBeforeInheritanceColon = false; 11220 verifyFormat("class Foo: public Bar {};", InheritanceStyle); 11221 verifyFormat("Foo::Foo() : foo(1) {}", InheritanceStyle); 11222 verifyFormat("for (auto a : b) {\n}", InheritanceStyle); 11223 verifyFormat("int x = a ? b : c;", InheritanceStyle); 11224 verifyFormat("{\n" 11225 "label2:\n" 11226 " int x = 0;\n" 11227 "}", 11228 InheritanceStyle); 11229 verifyFormat("switch (x) {\n" 11230 "case 1:\n" 11231 "default:\n" 11232 "}", 11233 InheritanceStyle); 11234 InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_AfterColon; 11235 verifyFormat("class Foooooooooooooooooooooo:\n" 11236 " public aaaaaaaaaaaaaaaaaa,\n" 11237 " public bbbbbbbbbbbbbbbbbb {\n" 11238 "}", 11239 InheritanceStyle); 11240 InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeComma; 11241 verifyFormat("class Foooooooooooooooooooooo\n" 11242 " : public aaaaaaaaaaaaaaaaaa\n" 11243 " , public bbbbbbbbbbbbbbbbbb {\n" 11244 "}", 11245 InheritanceStyle); 11246 InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeColon; 11247 verifyFormat("class Foooooooooooooooooooooo\n" 11248 " : public aaaaaaaaaaaaaaaaaa,\n" 11249 " public bbbbbbbbbbbbbbbbbb {\n" 11250 "}", 11251 InheritanceStyle); 11252 InheritanceStyle.ConstructorInitializerIndentWidth = 0; 11253 verifyFormat("class Foooooooooooooooooooooo\n" 11254 ": public aaaaaaaaaaaaaaaaaa,\n" 11255 " public bbbbbbbbbbbbbbbbbb {}", 11256 InheritanceStyle); 11257 11258 FormatStyle ForLoopStyle = getLLVMStyle(); 11259 ForLoopStyle.SpaceBeforeRangeBasedForLoopColon = false; 11260 verifyFormat("class Foo : public Bar {};", ForLoopStyle); 11261 verifyFormat("Foo::Foo() : foo(1) {}", ForLoopStyle); 11262 verifyFormat("for (auto a: b) {\n}", ForLoopStyle); 11263 verifyFormat("int x = a ? b : c;", ForLoopStyle); 11264 verifyFormat("{\n" 11265 "label2:\n" 11266 " int x = 0;\n" 11267 "}", 11268 ForLoopStyle); 11269 verifyFormat("switch (x) {\n" 11270 "case 1:\n" 11271 "default:\n" 11272 "}", 11273 ForLoopStyle); 11274 11275 FormatStyle NoSpaceStyle = getLLVMStyle(); 11276 NoSpaceStyle.SpaceBeforeCtorInitializerColon = false; 11277 NoSpaceStyle.SpaceBeforeInheritanceColon = false; 11278 NoSpaceStyle.SpaceBeforeRangeBasedForLoopColon = false; 11279 verifyFormat("class Foo: public Bar {};", NoSpaceStyle); 11280 verifyFormat("Foo::Foo(): foo(1) {}", NoSpaceStyle); 11281 verifyFormat("for (auto a: b) {\n}", NoSpaceStyle); 11282 verifyFormat("int x = a ? b : c;", NoSpaceStyle); 11283 verifyFormat("{\n" 11284 "label3:\n" 11285 " int x = 0;\n" 11286 "}", 11287 NoSpaceStyle); 11288 verifyFormat("switch (x) {\n" 11289 "case 1:\n" 11290 "default:\n" 11291 "}", 11292 NoSpaceStyle); 11293 } 11294 11295 TEST_F(FormatTest, AlignConsecutiveMacros) { 11296 FormatStyle Style = getLLVMStyle(); 11297 Style.AlignConsecutiveAssignments = true; 11298 Style.AlignConsecutiveDeclarations = true; 11299 Style.AlignConsecutiveMacros = false; 11300 11301 verifyFormat("#define a 3\n" 11302 "#define bbbb 4\n" 11303 "#define ccc (5)", 11304 Style); 11305 11306 verifyFormat("#define f(x) (x * x)\n" 11307 "#define fff(x, y, z) (x * y + z)\n" 11308 "#define ffff(x, y) (x - y)", 11309 Style); 11310 11311 verifyFormat("#define foo(x, y) (x + y)\n" 11312 "#define bar (5, 6)(2 + 2)", 11313 Style); 11314 11315 verifyFormat("#define a 3\n" 11316 "#define bbbb 4\n" 11317 "#define ccc (5)\n" 11318 "#define f(x) (x * x)\n" 11319 "#define fff(x, y, z) (x * y + z)\n" 11320 "#define ffff(x, y) (x - y)", 11321 Style); 11322 11323 Style.AlignConsecutiveMacros = true; 11324 verifyFormat("#define a 3\n" 11325 "#define bbbb 4\n" 11326 "#define ccc (5)", 11327 Style); 11328 11329 verifyFormat("#define f(x) (x * x)\n" 11330 "#define fff(x, y, z) (x * y + z)\n" 11331 "#define ffff(x, y) (x - y)", 11332 Style); 11333 11334 verifyFormat("#define foo(x, y) (x + y)\n" 11335 "#define bar (5, 6)(2 + 2)", 11336 Style); 11337 11338 verifyFormat("#define a 3\n" 11339 "#define bbbb 4\n" 11340 "#define ccc (5)\n" 11341 "#define f(x) (x * x)\n" 11342 "#define fff(x, y, z) (x * y + z)\n" 11343 "#define ffff(x, y) (x - y)", 11344 Style); 11345 11346 verifyFormat("#define a 5\n" 11347 "#define foo(x, y) (x + y)\n" 11348 "#define CCC (6)\n" 11349 "auto lambda = []() {\n" 11350 " auto ii = 0;\n" 11351 " float j = 0;\n" 11352 " return 0;\n" 11353 "};\n" 11354 "int i = 0;\n" 11355 "float i2 = 0;\n" 11356 "auto v = type{\n" 11357 " i = 1, //\n" 11358 " (i = 2), //\n" 11359 " i = 3 //\n" 11360 "};", 11361 Style); 11362 11363 Style.AlignConsecutiveMacros = false; 11364 Style.ColumnLimit = 20; 11365 11366 verifyFormat("#define a \\\n" 11367 " \"aabbbbbbbbbbbb\"\n" 11368 "#define D \\\n" 11369 " \"aabbbbbbbbbbbb\" \\\n" 11370 " \"ccddeeeeeeeee\"\n" 11371 "#define B \\\n" 11372 " \"QQQQQQQQQQQQQ\" \\\n" 11373 " \"FFFFFFFFFFFFF\" \\\n" 11374 " \"LLLLLLLL\"\n", 11375 Style); 11376 11377 Style.AlignConsecutiveMacros = true; 11378 verifyFormat("#define a \\\n" 11379 " \"aabbbbbbbbbbbb\"\n" 11380 "#define D \\\n" 11381 " \"aabbbbbbbbbbbb\" \\\n" 11382 " \"ccddeeeeeeeee\"\n" 11383 "#define B \\\n" 11384 " \"QQQQQQQQQQQQQ\" \\\n" 11385 " \"FFFFFFFFFFFFF\" \\\n" 11386 " \"LLLLLLLL\"\n", 11387 Style); 11388 } 11389 11390 TEST_F(FormatTest, AlignConsecutiveAssignments) { 11391 FormatStyle Alignment = getLLVMStyle(); 11392 Alignment.AlignConsecutiveMacros = true; 11393 Alignment.AlignConsecutiveAssignments = false; 11394 verifyFormat("int a = 5;\n" 11395 "int oneTwoThree = 123;", 11396 Alignment); 11397 verifyFormat("int a = 5;\n" 11398 "int oneTwoThree = 123;", 11399 Alignment); 11400 11401 Alignment.AlignConsecutiveAssignments = true; 11402 verifyFormat("int a = 5;\n" 11403 "int oneTwoThree = 123;", 11404 Alignment); 11405 verifyFormat("int a = method();\n" 11406 "int oneTwoThree = 133;", 11407 Alignment); 11408 verifyFormat("a &= 5;\n" 11409 "bcd *= 5;\n" 11410 "ghtyf += 5;\n" 11411 "dvfvdb -= 5;\n" 11412 "a /= 5;\n" 11413 "vdsvsv %= 5;\n" 11414 "sfdbddfbdfbb ^= 5;\n" 11415 "dvsdsv |= 5;\n" 11416 "int dsvvdvsdvvv = 123;", 11417 Alignment); 11418 verifyFormat("int i = 1, j = 10;\n" 11419 "something = 2000;", 11420 Alignment); 11421 verifyFormat("something = 2000;\n" 11422 "int i = 1, j = 10;\n", 11423 Alignment); 11424 verifyFormat("something = 2000;\n" 11425 "another = 911;\n" 11426 "int i = 1, j = 10;\n" 11427 "oneMore = 1;\n" 11428 "i = 2;", 11429 Alignment); 11430 verifyFormat("int a = 5;\n" 11431 "int one = 1;\n" 11432 "method();\n" 11433 "int oneTwoThree = 123;\n" 11434 "int oneTwo = 12;", 11435 Alignment); 11436 verifyFormat("int oneTwoThree = 123;\n" 11437 "int oneTwo = 12;\n" 11438 "method();\n", 11439 Alignment); 11440 verifyFormat("int oneTwoThree = 123; // comment\n" 11441 "int oneTwo = 12; // comment", 11442 Alignment); 11443 EXPECT_EQ("int a = 5;\n" 11444 "\n" 11445 "int oneTwoThree = 123;", 11446 format("int a = 5;\n" 11447 "\n" 11448 "int oneTwoThree= 123;", 11449 Alignment)); 11450 EXPECT_EQ("int a = 5;\n" 11451 "int one = 1;\n" 11452 "\n" 11453 "int oneTwoThree = 123;", 11454 format("int a = 5;\n" 11455 "int one = 1;\n" 11456 "\n" 11457 "int oneTwoThree = 123;", 11458 Alignment)); 11459 EXPECT_EQ("int a = 5;\n" 11460 "int one = 1;\n" 11461 "\n" 11462 "int oneTwoThree = 123;\n" 11463 "int oneTwo = 12;", 11464 format("int a = 5;\n" 11465 "int one = 1;\n" 11466 "\n" 11467 "int oneTwoThree = 123;\n" 11468 "int oneTwo = 12;", 11469 Alignment)); 11470 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign; 11471 verifyFormat("#define A \\\n" 11472 " int aaaa = 12; \\\n" 11473 " int b = 23; \\\n" 11474 " int ccc = 234; \\\n" 11475 " int dddddddddd = 2345;", 11476 Alignment); 11477 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left; 11478 verifyFormat("#define A \\\n" 11479 " int aaaa = 12; \\\n" 11480 " int b = 23; \\\n" 11481 " int ccc = 234; \\\n" 11482 " int dddddddddd = 2345;", 11483 Alignment); 11484 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right; 11485 verifyFormat("#define A " 11486 " \\\n" 11487 " int aaaa = 12; " 11488 " \\\n" 11489 " int b = 23; " 11490 " \\\n" 11491 " int ccc = 234; " 11492 " \\\n" 11493 " int dddddddddd = 2345;", 11494 Alignment); 11495 verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int " 11496 "k = 4, int l = 5,\n" 11497 " int m = 6) {\n" 11498 " int j = 10;\n" 11499 " otherThing = 1;\n" 11500 "}", 11501 Alignment); 11502 verifyFormat("void SomeFunction(int parameter = 0) {\n" 11503 " int i = 1;\n" 11504 " int j = 2;\n" 11505 " int big = 10000;\n" 11506 "}", 11507 Alignment); 11508 verifyFormat("class C {\n" 11509 "public:\n" 11510 " int i = 1;\n" 11511 " virtual void f() = 0;\n" 11512 "};", 11513 Alignment); 11514 verifyFormat("int i = 1;\n" 11515 "if (SomeType t = getSomething()) {\n" 11516 "}\n" 11517 "int j = 2;\n" 11518 "int big = 10000;", 11519 Alignment); 11520 verifyFormat("int j = 7;\n" 11521 "for (int k = 0; k < N; ++k) {\n" 11522 "}\n" 11523 "int j = 2;\n" 11524 "int big = 10000;\n" 11525 "}", 11526 Alignment); 11527 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 11528 verifyFormat("int i = 1;\n" 11529 "LooooooooooongType loooooooooooooooooooooongVariable\n" 11530 " = someLooooooooooooooooongFunction();\n" 11531 "int j = 2;", 11532 Alignment); 11533 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 11534 verifyFormat("int i = 1;\n" 11535 "LooooooooooongType loooooooooooooooooooooongVariable =\n" 11536 " someLooooooooooooooooongFunction();\n" 11537 "int j = 2;", 11538 Alignment); 11539 11540 verifyFormat("auto lambda = []() {\n" 11541 " auto i = 0;\n" 11542 " return 0;\n" 11543 "};\n" 11544 "int i = 0;\n" 11545 "auto v = type{\n" 11546 " i = 1, //\n" 11547 " (i = 2), //\n" 11548 " i = 3 //\n" 11549 "};", 11550 Alignment); 11551 11552 verifyFormat( 11553 "int i = 1;\n" 11554 "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n" 11555 " loooooooooooooooooooooongParameterB);\n" 11556 "int j = 2;", 11557 Alignment); 11558 11559 verifyFormat("template <typename T, typename T_0 = very_long_type_name_0,\n" 11560 " typename B = very_long_type_name_1,\n" 11561 " typename T_2 = very_long_type_name_2>\n" 11562 "auto foo() {}\n", 11563 Alignment); 11564 verifyFormat("int a, b = 1;\n" 11565 "int c = 2;\n" 11566 "int dd = 3;\n", 11567 Alignment); 11568 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n" 11569 "float b[1][] = {{3.f}};\n", 11570 Alignment); 11571 verifyFormat("for (int i = 0; i < 1; i++)\n" 11572 " int x = 1;\n", 11573 Alignment); 11574 verifyFormat("for (i = 0; i < 1; i++)\n" 11575 " x = 1;\n" 11576 "y = 1;\n", 11577 Alignment); 11578 } 11579 11580 TEST_F(FormatTest, AlignConsecutiveDeclarations) { 11581 FormatStyle Alignment = getLLVMStyle(); 11582 Alignment.AlignConsecutiveMacros = true; 11583 Alignment.AlignConsecutiveDeclarations = false; 11584 verifyFormat("float const a = 5;\n" 11585 "int oneTwoThree = 123;", 11586 Alignment); 11587 verifyFormat("int a = 5;\n" 11588 "float const oneTwoThree = 123;", 11589 Alignment); 11590 11591 Alignment.AlignConsecutiveDeclarations = true; 11592 verifyFormat("float const a = 5;\n" 11593 "int oneTwoThree = 123;", 11594 Alignment); 11595 verifyFormat("int a = method();\n" 11596 "float const oneTwoThree = 133;", 11597 Alignment); 11598 verifyFormat("int i = 1, j = 10;\n" 11599 "something = 2000;", 11600 Alignment); 11601 verifyFormat("something = 2000;\n" 11602 "int i = 1, j = 10;\n", 11603 Alignment); 11604 verifyFormat("float something = 2000;\n" 11605 "double another = 911;\n" 11606 "int i = 1, j = 10;\n" 11607 "const int *oneMore = 1;\n" 11608 "unsigned i = 2;", 11609 Alignment); 11610 verifyFormat("float a = 5;\n" 11611 "int one = 1;\n" 11612 "method();\n" 11613 "const double oneTwoThree = 123;\n" 11614 "const unsigned int oneTwo = 12;", 11615 Alignment); 11616 verifyFormat("int oneTwoThree{0}; // comment\n" 11617 "unsigned oneTwo; // comment", 11618 Alignment); 11619 EXPECT_EQ("float const a = 5;\n" 11620 "\n" 11621 "int oneTwoThree = 123;", 11622 format("float const a = 5;\n" 11623 "\n" 11624 "int oneTwoThree= 123;", 11625 Alignment)); 11626 EXPECT_EQ("float a = 5;\n" 11627 "int one = 1;\n" 11628 "\n" 11629 "unsigned oneTwoThree = 123;", 11630 format("float a = 5;\n" 11631 "int one = 1;\n" 11632 "\n" 11633 "unsigned oneTwoThree = 123;", 11634 Alignment)); 11635 EXPECT_EQ("float a = 5;\n" 11636 "int one = 1;\n" 11637 "\n" 11638 "unsigned oneTwoThree = 123;\n" 11639 "int oneTwo = 12;", 11640 format("float a = 5;\n" 11641 "int one = 1;\n" 11642 "\n" 11643 "unsigned oneTwoThree = 123;\n" 11644 "int oneTwo = 12;", 11645 Alignment)); 11646 // Function prototype alignment 11647 verifyFormat("int a();\n" 11648 "double b();", 11649 Alignment); 11650 verifyFormat("int a(int x);\n" 11651 "double b();", 11652 Alignment); 11653 unsigned OldColumnLimit = Alignment.ColumnLimit; 11654 // We need to set ColumnLimit to zero, in order to stress nested alignments, 11655 // otherwise the function parameters will be re-flowed onto a single line. 11656 Alignment.ColumnLimit = 0; 11657 EXPECT_EQ("int a(int x,\n" 11658 " float y);\n" 11659 "double b(int x,\n" 11660 " double y);", 11661 format("int a(int x,\n" 11662 " float y);\n" 11663 "double b(int x,\n" 11664 " double y);", 11665 Alignment)); 11666 // This ensures that function parameters of function declarations are 11667 // correctly indented when their owning functions are indented. 11668 // The failure case here is for 'double y' to not be indented enough. 11669 EXPECT_EQ("double a(int x);\n" 11670 "int b(int y,\n" 11671 " double z);", 11672 format("double a(int x);\n" 11673 "int b(int y,\n" 11674 " double z);", 11675 Alignment)); 11676 // Set ColumnLimit low so that we induce wrapping immediately after 11677 // the function name and opening paren. 11678 Alignment.ColumnLimit = 13; 11679 verifyFormat("int function(\n" 11680 " int x,\n" 11681 " bool y);", 11682 Alignment); 11683 Alignment.ColumnLimit = OldColumnLimit; 11684 // Ensure function pointers don't screw up recursive alignment 11685 verifyFormat("int a(int x, void (*fp)(int y));\n" 11686 "double b();", 11687 Alignment); 11688 Alignment.AlignConsecutiveAssignments = true; 11689 // Ensure recursive alignment is broken by function braces, so that the 11690 // "a = 1" does not align with subsequent assignments inside the function 11691 // body. 11692 verifyFormat("int func(int a = 1) {\n" 11693 " int b = 2;\n" 11694 " int cc = 3;\n" 11695 "}", 11696 Alignment); 11697 verifyFormat("float something = 2000;\n" 11698 "double another = 911;\n" 11699 "int i = 1, j = 10;\n" 11700 "const int *oneMore = 1;\n" 11701 "unsigned i = 2;", 11702 Alignment); 11703 verifyFormat("int oneTwoThree = {0}; // comment\n" 11704 "unsigned oneTwo = 0; // comment", 11705 Alignment); 11706 // Make sure that scope is correctly tracked, in the absence of braces 11707 verifyFormat("for (int i = 0; i < n; i++)\n" 11708 " j = i;\n" 11709 "double x = 1;\n", 11710 Alignment); 11711 verifyFormat("if (int i = 0)\n" 11712 " j = i;\n" 11713 "double x = 1;\n", 11714 Alignment); 11715 // Ensure operator[] and operator() are comprehended 11716 verifyFormat("struct test {\n" 11717 " long long int foo();\n" 11718 " int operator[](int a);\n" 11719 " double bar();\n" 11720 "};\n", 11721 Alignment); 11722 verifyFormat("struct test {\n" 11723 " long long int foo();\n" 11724 " int operator()(int a);\n" 11725 " double bar();\n" 11726 "};\n", 11727 Alignment); 11728 EXPECT_EQ("void SomeFunction(int parameter = 0) {\n" 11729 " int const i = 1;\n" 11730 " int * j = 2;\n" 11731 " int big = 10000;\n" 11732 "\n" 11733 " unsigned oneTwoThree = 123;\n" 11734 " int oneTwo = 12;\n" 11735 " method();\n" 11736 " float k = 2;\n" 11737 " int ll = 10000;\n" 11738 "}", 11739 format("void SomeFunction(int parameter= 0) {\n" 11740 " int const i= 1;\n" 11741 " int *j=2;\n" 11742 " int big = 10000;\n" 11743 "\n" 11744 "unsigned oneTwoThree =123;\n" 11745 "int oneTwo = 12;\n" 11746 " method();\n" 11747 "float k= 2;\n" 11748 "int ll=10000;\n" 11749 "}", 11750 Alignment)); 11751 Alignment.AlignConsecutiveAssignments = false; 11752 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign; 11753 verifyFormat("#define A \\\n" 11754 " int aaaa = 12; \\\n" 11755 " float b = 23; \\\n" 11756 " const int ccc = 234; \\\n" 11757 " unsigned dddddddddd = 2345;", 11758 Alignment); 11759 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left; 11760 verifyFormat("#define A \\\n" 11761 " int aaaa = 12; \\\n" 11762 " float b = 23; \\\n" 11763 " const int ccc = 234; \\\n" 11764 " unsigned dddddddddd = 2345;", 11765 Alignment); 11766 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right; 11767 Alignment.ColumnLimit = 30; 11768 verifyFormat("#define A \\\n" 11769 " int aaaa = 12; \\\n" 11770 " float b = 23; \\\n" 11771 " const int ccc = 234; \\\n" 11772 " int dddddddddd = 2345;", 11773 Alignment); 11774 Alignment.ColumnLimit = 80; 11775 verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int " 11776 "k = 4, int l = 5,\n" 11777 " int m = 6) {\n" 11778 " const int j = 10;\n" 11779 " otherThing = 1;\n" 11780 "}", 11781 Alignment); 11782 verifyFormat("void SomeFunction(int parameter = 0) {\n" 11783 " int const i = 1;\n" 11784 " int * j = 2;\n" 11785 " int big = 10000;\n" 11786 "}", 11787 Alignment); 11788 verifyFormat("class C {\n" 11789 "public:\n" 11790 " int i = 1;\n" 11791 " virtual void f() = 0;\n" 11792 "};", 11793 Alignment); 11794 verifyFormat("float i = 1;\n" 11795 "if (SomeType t = getSomething()) {\n" 11796 "}\n" 11797 "const unsigned j = 2;\n" 11798 "int big = 10000;", 11799 Alignment); 11800 verifyFormat("float j = 7;\n" 11801 "for (int k = 0; k < N; ++k) {\n" 11802 "}\n" 11803 "unsigned j = 2;\n" 11804 "int big = 10000;\n" 11805 "}", 11806 Alignment); 11807 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 11808 verifyFormat("float i = 1;\n" 11809 "LooooooooooongType loooooooooooooooooooooongVariable\n" 11810 " = someLooooooooooooooooongFunction();\n" 11811 "int j = 2;", 11812 Alignment); 11813 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 11814 verifyFormat("int i = 1;\n" 11815 "LooooooooooongType loooooooooooooooooooooongVariable =\n" 11816 " someLooooooooooooooooongFunction();\n" 11817 "int j = 2;", 11818 Alignment); 11819 11820 Alignment.AlignConsecutiveAssignments = true; 11821 verifyFormat("auto lambda = []() {\n" 11822 " auto ii = 0;\n" 11823 " float j = 0;\n" 11824 " return 0;\n" 11825 "};\n" 11826 "int i = 0;\n" 11827 "float i2 = 0;\n" 11828 "auto v = type{\n" 11829 " i = 1, //\n" 11830 " (i = 2), //\n" 11831 " i = 3 //\n" 11832 "};", 11833 Alignment); 11834 Alignment.AlignConsecutiveAssignments = false; 11835 11836 verifyFormat( 11837 "int i = 1;\n" 11838 "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n" 11839 " loooooooooooooooooooooongParameterB);\n" 11840 "int j = 2;", 11841 Alignment); 11842 11843 // Test interactions with ColumnLimit and AlignConsecutiveAssignments: 11844 // We expect declarations and assignments to align, as long as it doesn't 11845 // exceed the column limit, starting a new alignment sequence whenever it 11846 // happens. 11847 Alignment.AlignConsecutiveAssignments = true; 11848 Alignment.ColumnLimit = 30; 11849 verifyFormat("float ii = 1;\n" 11850 "unsigned j = 2;\n" 11851 "int someVerylongVariable = 1;\n" 11852 "AnotherLongType ll = 123456;\n" 11853 "VeryVeryLongType k = 2;\n" 11854 "int myvar = 1;", 11855 Alignment); 11856 Alignment.ColumnLimit = 80; 11857 Alignment.AlignConsecutiveAssignments = false; 11858 11859 verifyFormat( 11860 "template <typename LongTemplate, typename VeryLongTemplateTypeName,\n" 11861 " typename LongType, typename B>\n" 11862 "auto foo() {}\n", 11863 Alignment); 11864 verifyFormat("float a, b = 1;\n" 11865 "int c = 2;\n" 11866 "int dd = 3;\n", 11867 Alignment); 11868 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n" 11869 "float b[1][] = {{3.f}};\n", 11870 Alignment); 11871 Alignment.AlignConsecutiveAssignments = true; 11872 verifyFormat("float a, b = 1;\n" 11873 "int c = 2;\n" 11874 "int dd = 3;\n", 11875 Alignment); 11876 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n" 11877 "float b[1][] = {{3.f}};\n", 11878 Alignment); 11879 Alignment.AlignConsecutiveAssignments = false; 11880 11881 Alignment.ColumnLimit = 30; 11882 Alignment.BinPackParameters = false; 11883 verifyFormat("void foo(float a,\n" 11884 " float b,\n" 11885 " int c,\n" 11886 " uint32_t *d) {\n" 11887 " int * e = 0;\n" 11888 " float f = 0;\n" 11889 " double g = 0;\n" 11890 "}\n" 11891 "void bar(ino_t a,\n" 11892 " int b,\n" 11893 " uint32_t *c,\n" 11894 " bool d) {}\n", 11895 Alignment); 11896 Alignment.BinPackParameters = true; 11897 Alignment.ColumnLimit = 80; 11898 11899 // Bug 33507 11900 Alignment.PointerAlignment = FormatStyle::PAS_Middle; 11901 verifyFormat( 11902 "auto found = range::find_if(vsProducts, [&](auto * aProduct) {\n" 11903 " static const Version verVs2017;\n" 11904 " return true;\n" 11905 "});\n", 11906 Alignment); 11907 Alignment.PointerAlignment = FormatStyle::PAS_Right; 11908 11909 // See llvm.org/PR35641 11910 Alignment.AlignConsecutiveDeclarations = true; 11911 verifyFormat("int func() { //\n" 11912 " int b;\n" 11913 " unsigned c;\n" 11914 "}", 11915 Alignment); 11916 11917 // See PR37175 11918 FormatStyle Style = getMozillaStyle(); 11919 Style.AlignConsecutiveDeclarations = true; 11920 EXPECT_EQ("DECOR1 /**/ int8_t /**/ DECOR2 /**/\n" 11921 "foo(int a);", 11922 format("DECOR1 /**/ int8_t /**/ DECOR2 /**/ foo (int a);", Style)); 11923 } 11924 11925 TEST_F(FormatTest, LinuxBraceBreaking) { 11926 FormatStyle LinuxBraceStyle = getLLVMStyle(); 11927 LinuxBraceStyle.BreakBeforeBraces = FormatStyle::BS_Linux; 11928 verifyFormat("namespace a\n" 11929 "{\n" 11930 "class A\n" 11931 "{\n" 11932 " void f()\n" 11933 " {\n" 11934 " if (true) {\n" 11935 " a();\n" 11936 " b();\n" 11937 " } else {\n" 11938 " a();\n" 11939 " }\n" 11940 " }\n" 11941 " void g() { return; }\n" 11942 "};\n" 11943 "struct B {\n" 11944 " int x;\n" 11945 "};\n" 11946 "} // namespace a\n", 11947 LinuxBraceStyle); 11948 verifyFormat("enum X {\n" 11949 " Y = 0,\n" 11950 "}\n", 11951 LinuxBraceStyle); 11952 verifyFormat("struct S {\n" 11953 " int Type;\n" 11954 " union {\n" 11955 " int x;\n" 11956 " double y;\n" 11957 " } Value;\n" 11958 " class C\n" 11959 " {\n" 11960 " MyFavoriteType Value;\n" 11961 " } Class;\n" 11962 "}\n", 11963 LinuxBraceStyle); 11964 } 11965 11966 TEST_F(FormatTest, MozillaBraceBreaking) { 11967 FormatStyle MozillaBraceStyle = getLLVMStyle(); 11968 MozillaBraceStyle.BreakBeforeBraces = FormatStyle::BS_Mozilla; 11969 MozillaBraceStyle.FixNamespaceComments = false; 11970 verifyFormat("namespace a {\n" 11971 "class A\n" 11972 "{\n" 11973 " void f()\n" 11974 " {\n" 11975 " if (true) {\n" 11976 " a();\n" 11977 " b();\n" 11978 " }\n" 11979 " }\n" 11980 " void g() { return; }\n" 11981 "};\n" 11982 "enum E\n" 11983 "{\n" 11984 " A,\n" 11985 " // foo\n" 11986 " B,\n" 11987 " C\n" 11988 "};\n" 11989 "struct B\n" 11990 "{\n" 11991 " int x;\n" 11992 "};\n" 11993 "}\n", 11994 MozillaBraceStyle); 11995 verifyFormat("struct S\n" 11996 "{\n" 11997 " int Type;\n" 11998 " union\n" 11999 " {\n" 12000 " int x;\n" 12001 " double y;\n" 12002 " } Value;\n" 12003 " class C\n" 12004 " {\n" 12005 " MyFavoriteType Value;\n" 12006 " } Class;\n" 12007 "}\n", 12008 MozillaBraceStyle); 12009 } 12010 12011 TEST_F(FormatTest, StroustrupBraceBreaking) { 12012 FormatStyle StroustrupBraceStyle = getLLVMStyle(); 12013 StroustrupBraceStyle.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 12014 verifyFormat("namespace a {\n" 12015 "class A {\n" 12016 " void f()\n" 12017 " {\n" 12018 " if (true) {\n" 12019 " a();\n" 12020 " b();\n" 12021 " }\n" 12022 " }\n" 12023 " void g() { return; }\n" 12024 "};\n" 12025 "struct B {\n" 12026 " int x;\n" 12027 "};\n" 12028 "} // namespace a\n", 12029 StroustrupBraceStyle); 12030 12031 verifyFormat("void foo()\n" 12032 "{\n" 12033 " if (a) {\n" 12034 " a();\n" 12035 " }\n" 12036 " else {\n" 12037 " b();\n" 12038 " }\n" 12039 "}\n", 12040 StroustrupBraceStyle); 12041 12042 verifyFormat("#ifdef _DEBUG\n" 12043 "int foo(int i = 0)\n" 12044 "#else\n" 12045 "int foo(int i = 5)\n" 12046 "#endif\n" 12047 "{\n" 12048 " return i;\n" 12049 "}", 12050 StroustrupBraceStyle); 12051 12052 verifyFormat("void foo() {}\n" 12053 "void bar()\n" 12054 "#ifdef _DEBUG\n" 12055 "{\n" 12056 " foo();\n" 12057 "}\n" 12058 "#else\n" 12059 "{\n" 12060 "}\n" 12061 "#endif", 12062 StroustrupBraceStyle); 12063 12064 verifyFormat("void foobar() { int i = 5; }\n" 12065 "#ifdef _DEBUG\n" 12066 "void bar() {}\n" 12067 "#else\n" 12068 "void bar() { foobar(); }\n" 12069 "#endif", 12070 StroustrupBraceStyle); 12071 } 12072 12073 TEST_F(FormatTest, AllmanBraceBreaking) { 12074 FormatStyle AllmanBraceStyle = getLLVMStyle(); 12075 AllmanBraceStyle.BreakBeforeBraces = FormatStyle::BS_Allman; 12076 12077 EXPECT_EQ("namespace a\n" 12078 "{\n" 12079 "void f();\n" 12080 "void g();\n" 12081 "} // namespace a\n", 12082 format("namespace a\n" 12083 "{\n" 12084 "void f();\n" 12085 "void g();\n" 12086 "}\n", 12087 AllmanBraceStyle)); 12088 12089 verifyFormat("namespace a\n" 12090 "{\n" 12091 "class A\n" 12092 "{\n" 12093 " void f()\n" 12094 " {\n" 12095 " if (true)\n" 12096 " {\n" 12097 " a();\n" 12098 " b();\n" 12099 " }\n" 12100 " }\n" 12101 " void g() { return; }\n" 12102 "};\n" 12103 "struct B\n" 12104 "{\n" 12105 " int x;\n" 12106 "};\n" 12107 "union C\n" 12108 "{\n" 12109 "};\n" 12110 "} // namespace a", 12111 AllmanBraceStyle); 12112 12113 verifyFormat("void f()\n" 12114 "{\n" 12115 " if (true)\n" 12116 " {\n" 12117 " a();\n" 12118 " }\n" 12119 " else if (false)\n" 12120 " {\n" 12121 " b();\n" 12122 " }\n" 12123 " else\n" 12124 " {\n" 12125 " c();\n" 12126 " }\n" 12127 "}\n", 12128 AllmanBraceStyle); 12129 12130 verifyFormat("void f()\n" 12131 "{\n" 12132 " for (int i = 0; i < 10; ++i)\n" 12133 " {\n" 12134 " a();\n" 12135 " }\n" 12136 " while (false)\n" 12137 " {\n" 12138 " b();\n" 12139 " }\n" 12140 " do\n" 12141 " {\n" 12142 " c();\n" 12143 " } while (false)\n" 12144 "}\n", 12145 AllmanBraceStyle); 12146 12147 verifyFormat("void f(int a)\n" 12148 "{\n" 12149 " switch (a)\n" 12150 " {\n" 12151 " case 0:\n" 12152 " break;\n" 12153 " case 1:\n" 12154 " {\n" 12155 " break;\n" 12156 " }\n" 12157 " case 2:\n" 12158 " {\n" 12159 " }\n" 12160 " break;\n" 12161 " default:\n" 12162 " break;\n" 12163 " }\n" 12164 "}\n", 12165 AllmanBraceStyle); 12166 12167 verifyFormat("enum X\n" 12168 "{\n" 12169 " Y = 0,\n" 12170 "}\n", 12171 AllmanBraceStyle); 12172 verifyFormat("enum X\n" 12173 "{\n" 12174 " Y = 0\n" 12175 "}\n", 12176 AllmanBraceStyle); 12177 12178 verifyFormat("@interface BSApplicationController ()\n" 12179 "{\n" 12180 "@private\n" 12181 " id _extraIvar;\n" 12182 "}\n" 12183 "@end\n", 12184 AllmanBraceStyle); 12185 12186 verifyFormat("#ifdef _DEBUG\n" 12187 "int foo(int i = 0)\n" 12188 "#else\n" 12189 "int foo(int i = 5)\n" 12190 "#endif\n" 12191 "{\n" 12192 " return i;\n" 12193 "}", 12194 AllmanBraceStyle); 12195 12196 verifyFormat("void foo() {}\n" 12197 "void bar()\n" 12198 "#ifdef _DEBUG\n" 12199 "{\n" 12200 " foo();\n" 12201 "}\n" 12202 "#else\n" 12203 "{\n" 12204 "}\n" 12205 "#endif", 12206 AllmanBraceStyle); 12207 12208 verifyFormat("void foobar() { int i = 5; }\n" 12209 "#ifdef _DEBUG\n" 12210 "void bar() {}\n" 12211 "#else\n" 12212 "void bar() { foobar(); }\n" 12213 "#endif", 12214 AllmanBraceStyle); 12215 12216 // This shouldn't affect ObjC blocks.. 12217 verifyFormat("[self doSomeThingWithACompletionHandler:^{\n" 12218 " // ...\n" 12219 " int i;\n" 12220 "}];", 12221 AllmanBraceStyle); 12222 verifyFormat("void (^block)(void) = ^{\n" 12223 " // ...\n" 12224 " int i;\n" 12225 "};", 12226 AllmanBraceStyle); 12227 // .. or dict literals. 12228 verifyFormat("void f()\n" 12229 "{\n" 12230 " // ...\n" 12231 " [object someMethod:@{@\"a\" : @\"b\"}];\n" 12232 "}", 12233 AllmanBraceStyle); 12234 verifyFormat("void f()\n" 12235 "{\n" 12236 " // ...\n" 12237 " [object someMethod:@{a : @\"b\"}];\n" 12238 "}", 12239 AllmanBraceStyle); 12240 verifyFormat("int f()\n" 12241 "{ // comment\n" 12242 " return 42;\n" 12243 "}", 12244 AllmanBraceStyle); 12245 12246 AllmanBraceStyle.ColumnLimit = 19; 12247 verifyFormat("void f() { int i; }", AllmanBraceStyle); 12248 AllmanBraceStyle.ColumnLimit = 18; 12249 verifyFormat("void f()\n" 12250 "{\n" 12251 " int i;\n" 12252 "}", 12253 AllmanBraceStyle); 12254 AllmanBraceStyle.ColumnLimit = 80; 12255 12256 FormatStyle BreakBeforeBraceShortIfs = AllmanBraceStyle; 12257 BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine = 12258 FormatStyle::SIS_WithoutElse; 12259 BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true; 12260 verifyFormat("void f(bool b)\n" 12261 "{\n" 12262 " if (b)\n" 12263 " {\n" 12264 " return;\n" 12265 " }\n" 12266 "}\n", 12267 BreakBeforeBraceShortIfs); 12268 verifyFormat("void f(bool b)\n" 12269 "{\n" 12270 " if constexpr (b)\n" 12271 " {\n" 12272 " return;\n" 12273 " }\n" 12274 "}\n", 12275 BreakBeforeBraceShortIfs); 12276 verifyFormat("void f(bool b)\n" 12277 "{\n" 12278 " if CONSTEXPR (b)\n" 12279 " {\n" 12280 " return;\n" 12281 " }\n" 12282 "}\n", 12283 BreakBeforeBraceShortIfs); 12284 verifyFormat("void f(bool b)\n" 12285 "{\n" 12286 " if (b) return;\n" 12287 "}\n", 12288 BreakBeforeBraceShortIfs); 12289 verifyFormat("void f(bool b)\n" 12290 "{\n" 12291 " if constexpr (b) return;\n" 12292 "}\n", 12293 BreakBeforeBraceShortIfs); 12294 verifyFormat("void f(bool b)\n" 12295 "{\n" 12296 " if CONSTEXPR (b) return;\n" 12297 "}\n", 12298 BreakBeforeBraceShortIfs); 12299 verifyFormat("void f(bool b)\n" 12300 "{\n" 12301 " while (b)\n" 12302 " {\n" 12303 " return;\n" 12304 " }\n" 12305 "}\n", 12306 BreakBeforeBraceShortIfs); 12307 } 12308 12309 TEST_F(FormatTest, WhitesmithsBraceBreaking) { 12310 FormatStyle WhitesmithsBraceStyle = getLLVMStyle(); 12311 WhitesmithsBraceStyle.BreakBeforeBraces = FormatStyle::BS_Whitesmiths; 12312 12313 // Make a few changes to the style for testing purposes 12314 WhitesmithsBraceStyle.AllowShortFunctionsOnASingleLine = 12315 FormatStyle::SFS_Empty; 12316 WhitesmithsBraceStyle.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None; 12317 WhitesmithsBraceStyle.ColumnLimit = 0; 12318 12319 // FIXME: this test case can't decide whether there should be a blank line 12320 // after the ~D() line or not. It adds one if one doesn't exist in the test 12321 // and it removes the line if one exists. 12322 /* 12323 verifyFormat("class A;\n" 12324 "namespace B\n" 12325 " {\n" 12326 "class C;\n" 12327 "// Comment\n" 12328 "class D\n" 12329 " {\n" 12330 "public:\n" 12331 " D();\n" 12332 " ~D() {}\n" 12333 "private:\n" 12334 " enum E\n" 12335 " {\n" 12336 " F\n" 12337 " }\n" 12338 " };\n" 12339 " } // namespace B\n", 12340 WhitesmithsBraceStyle); 12341 */ 12342 12343 verifyFormat("namespace a\n" 12344 " {\n" 12345 "class A\n" 12346 " {\n" 12347 " void f()\n" 12348 " {\n" 12349 " if (true)\n" 12350 " {\n" 12351 " a();\n" 12352 " b();\n" 12353 " }\n" 12354 " }\n" 12355 " void g()\n" 12356 " {\n" 12357 " return;\n" 12358 " }\n" 12359 " };\n" 12360 "struct B\n" 12361 " {\n" 12362 " int x;\n" 12363 " };\n" 12364 " } // namespace a", 12365 WhitesmithsBraceStyle); 12366 12367 verifyFormat("void f()\n" 12368 " {\n" 12369 " if (true)\n" 12370 " {\n" 12371 " a();\n" 12372 " }\n" 12373 " else if (false)\n" 12374 " {\n" 12375 " b();\n" 12376 " }\n" 12377 " else\n" 12378 " {\n" 12379 " c();\n" 12380 " }\n" 12381 " }\n", 12382 WhitesmithsBraceStyle); 12383 12384 verifyFormat("void f()\n" 12385 " {\n" 12386 " for (int i = 0; i < 10; ++i)\n" 12387 " {\n" 12388 " a();\n" 12389 " }\n" 12390 " while (false)\n" 12391 " {\n" 12392 " b();\n" 12393 " }\n" 12394 " do\n" 12395 " {\n" 12396 " c();\n" 12397 " } while (false)\n" 12398 " }\n", 12399 WhitesmithsBraceStyle); 12400 12401 // FIXME: the block and the break under case 2 in this test don't get indented 12402 // correctly 12403 /* 12404 verifyFormat("void switchTest1(int a)\n" 12405 " {\n" 12406 " switch (a)\n" 12407 " {\n" 12408 " case 2:\n" 12409 " {\n" 12410 " }\n" 12411 " break;\n" 12412 " }\n" 12413 " }\n", 12414 WhitesmithsBraceStyle); 12415 */ 12416 12417 // FIXME: the block and the break under case 2 in this test don't get indented 12418 // correctly 12419 /* 12420 verifyFormat("void switchTest2(int a)\n" 12421 " {\n" 12422 " switch (a)\n" 12423 " {\n" 12424 " case 0:\n" 12425 " break;\n" 12426 " case 1:\n" 12427 " {\n" 12428 " break;\n" 12429 " }\n" 12430 " case 2:\n" 12431 " {\n" 12432 " }\n" 12433 " break;\n" 12434 " default:\n" 12435 " break;\n" 12436 " }\n" 12437 " }\n", 12438 WhitesmithsBraceStyle); 12439 */ 12440 12441 verifyFormat("enum X\n" 12442 " {\n" 12443 " Y = 0, // testing\n" 12444 " }\n", 12445 WhitesmithsBraceStyle); 12446 12447 verifyFormat("enum X\n" 12448 " {\n" 12449 " Y = 0\n" 12450 " }\n", 12451 WhitesmithsBraceStyle); 12452 verifyFormat("enum X\n" 12453 " {\n" 12454 " Y = 0,\n" 12455 " Z = 1\n" 12456 " };\n", 12457 WhitesmithsBraceStyle); 12458 12459 verifyFormat("@interface BSApplicationController ()\n" 12460 " {\n" 12461 "@private\n" 12462 " id _extraIvar;\n" 12463 " }\n" 12464 "@end\n", 12465 WhitesmithsBraceStyle); 12466 12467 verifyFormat("#ifdef _DEBUG\n" 12468 "int foo(int i = 0)\n" 12469 "#else\n" 12470 "int foo(int i = 5)\n" 12471 "#endif\n" 12472 " {\n" 12473 " return i;\n" 12474 " }", 12475 WhitesmithsBraceStyle); 12476 12477 verifyFormat("void foo() {}\n" 12478 "void bar()\n" 12479 "#ifdef _DEBUG\n" 12480 " {\n" 12481 " foo();\n" 12482 " }\n" 12483 "#else\n" 12484 " {\n" 12485 " }\n" 12486 "#endif", 12487 WhitesmithsBraceStyle); 12488 12489 verifyFormat("void foobar()\n" 12490 " {\n" 12491 " int i = 5;\n" 12492 " }\n" 12493 "#ifdef _DEBUG\n" 12494 "void bar()\n" 12495 " {\n" 12496 " }\n" 12497 "#else\n" 12498 "void bar()\n" 12499 " {\n" 12500 " foobar();\n" 12501 " }\n" 12502 "#endif", 12503 WhitesmithsBraceStyle); 12504 12505 // This shouldn't affect ObjC blocks.. 12506 verifyFormat("[self doSomeThingWithACompletionHandler:^{\n" 12507 " // ...\n" 12508 " int i;\n" 12509 "}];", 12510 WhitesmithsBraceStyle); 12511 verifyFormat("void (^block)(void) = ^{\n" 12512 " // ...\n" 12513 " int i;\n" 12514 "};", 12515 WhitesmithsBraceStyle); 12516 // .. or dict literals. 12517 verifyFormat("void f()\n" 12518 " {\n" 12519 " [object someMethod:@{@\"a\" : @\"b\"}];\n" 12520 " }", 12521 WhitesmithsBraceStyle); 12522 12523 verifyFormat("int f()\n" 12524 " { // comment\n" 12525 " return 42;\n" 12526 " }", 12527 WhitesmithsBraceStyle); 12528 12529 FormatStyle BreakBeforeBraceShortIfs = WhitesmithsBraceStyle; 12530 BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine = 12531 FormatStyle::SIS_Always; 12532 BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true; 12533 verifyFormat("void f(bool b)\n" 12534 " {\n" 12535 " if (b)\n" 12536 " {\n" 12537 " return;\n" 12538 " }\n" 12539 " }\n", 12540 BreakBeforeBraceShortIfs); 12541 verifyFormat("void f(bool b)\n" 12542 " {\n" 12543 " if (b) return;\n" 12544 " }\n", 12545 BreakBeforeBraceShortIfs); 12546 verifyFormat("void f(bool b)\n" 12547 " {\n" 12548 " while (b)\n" 12549 " {\n" 12550 " return;\n" 12551 " }\n" 12552 " }\n", 12553 BreakBeforeBraceShortIfs); 12554 } 12555 12556 TEST_F(FormatTest, GNUBraceBreaking) { 12557 FormatStyle GNUBraceStyle = getLLVMStyle(); 12558 GNUBraceStyle.BreakBeforeBraces = FormatStyle::BS_GNU; 12559 verifyFormat("namespace a\n" 12560 "{\n" 12561 "class A\n" 12562 "{\n" 12563 " void f()\n" 12564 " {\n" 12565 " int a;\n" 12566 " {\n" 12567 " int b;\n" 12568 " }\n" 12569 " if (true)\n" 12570 " {\n" 12571 " a();\n" 12572 " b();\n" 12573 " }\n" 12574 " }\n" 12575 " void g() { return; }\n" 12576 "}\n" 12577 "} // namespace a", 12578 GNUBraceStyle); 12579 12580 verifyFormat("void f()\n" 12581 "{\n" 12582 " if (true)\n" 12583 " {\n" 12584 " a();\n" 12585 " }\n" 12586 " else if (false)\n" 12587 " {\n" 12588 " b();\n" 12589 " }\n" 12590 " else\n" 12591 " {\n" 12592 " c();\n" 12593 " }\n" 12594 "}\n", 12595 GNUBraceStyle); 12596 12597 verifyFormat("void f()\n" 12598 "{\n" 12599 " for (int i = 0; i < 10; ++i)\n" 12600 " {\n" 12601 " a();\n" 12602 " }\n" 12603 " while (false)\n" 12604 " {\n" 12605 " b();\n" 12606 " }\n" 12607 " do\n" 12608 " {\n" 12609 " c();\n" 12610 " }\n" 12611 " while (false);\n" 12612 "}\n", 12613 GNUBraceStyle); 12614 12615 verifyFormat("void f(int a)\n" 12616 "{\n" 12617 " switch (a)\n" 12618 " {\n" 12619 " case 0:\n" 12620 " break;\n" 12621 " case 1:\n" 12622 " {\n" 12623 " break;\n" 12624 " }\n" 12625 " case 2:\n" 12626 " {\n" 12627 " }\n" 12628 " break;\n" 12629 " default:\n" 12630 " break;\n" 12631 " }\n" 12632 "}\n", 12633 GNUBraceStyle); 12634 12635 verifyFormat("enum X\n" 12636 "{\n" 12637 " Y = 0,\n" 12638 "}\n", 12639 GNUBraceStyle); 12640 12641 verifyFormat("@interface BSApplicationController ()\n" 12642 "{\n" 12643 "@private\n" 12644 " id _extraIvar;\n" 12645 "}\n" 12646 "@end\n", 12647 GNUBraceStyle); 12648 12649 verifyFormat("#ifdef _DEBUG\n" 12650 "int foo(int i = 0)\n" 12651 "#else\n" 12652 "int foo(int i = 5)\n" 12653 "#endif\n" 12654 "{\n" 12655 " return i;\n" 12656 "}", 12657 GNUBraceStyle); 12658 12659 verifyFormat("void foo() {}\n" 12660 "void bar()\n" 12661 "#ifdef _DEBUG\n" 12662 "{\n" 12663 " foo();\n" 12664 "}\n" 12665 "#else\n" 12666 "{\n" 12667 "}\n" 12668 "#endif", 12669 GNUBraceStyle); 12670 12671 verifyFormat("void foobar() { int i = 5; }\n" 12672 "#ifdef _DEBUG\n" 12673 "void bar() {}\n" 12674 "#else\n" 12675 "void bar() { foobar(); }\n" 12676 "#endif", 12677 GNUBraceStyle); 12678 } 12679 12680 TEST_F(FormatTest, WebKitBraceBreaking) { 12681 FormatStyle WebKitBraceStyle = getLLVMStyle(); 12682 WebKitBraceStyle.BreakBeforeBraces = FormatStyle::BS_WebKit; 12683 WebKitBraceStyle.FixNamespaceComments = false; 12684 verifyFormat("namespace a {\n" 12685 "class A {\n" 12686 " void f()\n" 12687 " {\n" 12688 " if (true) {\n" 12689 " a();\n" 12690 " b();\n" 12691 " }\n" 12692 " }\n" 12693 " void g() { return; }\n" 12694 "};\n" 12695 "enum E {\n" 12696 " A,\n" 12697 " // foo\n" 12698 " B,\n" 12699 " C\n" 12700 "};\n" 12701 "struct B {\n" 12702 " int x;\n" 12703 "};\n" 12704 "}\n", 12705 WebKitBraceStyle); 12706 verifyFormat("struct S {\n" 12707 " int Type;\n" 12708 " union {\n" 12709 " int x;\n" 12710 " double y;\n" 12711 " } Value;\n" 12712 " class C {\n" 12713 " MyFavoriteType Value;\n" 12714 " } Class;\n" 12715 "};\n", 12716 WebKitBraceStyle); 12717 } 12718 12719 TEST_F(FormatTest, CatchExceptionReferenceBinding) { 12720 verifyFormat("void f() {\n" 12721 " try {\n" 12722 " } catch (const Exception &e) {\n" 12723 " }\n" 12724 "}\n", 12725 getLLVMStyle()); 12726 } 12727 12728 TEST_F(FormatTest, UnderstandsPragmas) { 12729 verifyFormat("#pragma omp reduction(| : var)"); 12730 verifyFormat("#pragma omp reduction(+ : var)"); 12731 12732 EXPECT_EQ("#pragma mark Any non-hyphenated or hyphenated string " 12733 "(including parentheses).", 12734 format("#pragma mark Any non-hyphenated or hyphenated string " 12735 "(including parentheses).")); 12736 } 12737 12738 TEST_F(FormatTest, UnderstandPragmaOption) { 12739 verifyFormat("#pragma option -C -A"); 12740 12741 EXPECT_EQ("#pragma option -C -A", format("#pragma option -C -A")); 12742 } 12743 12744 TEST_F(FormatTest, OptimizeBreakPenaltyVsExcess) { 12745 FormatStyle Style = getLLVMStyle(); 12746 Style.ColumnLimit = 20; 12747 12748 // See PR41213 12749 EXPECT_EQ("/*\n" 12750 " *\t9012345\n" 12751 " * /8901\n" 12752 " */", 12753 format("/*\n" 12754 " *\t9012345 /8901\n" 12755 " */", 12756 Style)); 12757 EXPECT_EQ("/*\n" 12758 " *345678\n" 12759 " *\t/8901\n" 12760 " */", 12761 format("/*\n" 12762 " *345678\t/8901\n" 12763 " */", 12764 Style)); 12765 12766 verifyFormat("int a; // the\n" 12767 " // comment", 12768 Style); 12769 EXPECT_EQ("int a; /* first line\n" 12770 " * second\n" 12771 " * line third\n" 12772 " * line\n" 12773 " */", 12774 format("int a; /* first line\n" 12775 " * second\n" 12776 " * line third\n" 12777 " * line\n" 12778 " */", 12779 Style)); 12780 EXPECT_EQ("int a; // first line\n" 12781 " // second\n" 12782 " // line third\n" 12783 " // line", 12784 format("int a; // first line\n" 12785 " // second line\n" 12786 " // third line", 12787 Style)); 12788 12789 Style.PenaltyExcessCharacter = 90; 12790 verifyFormat("int a; // the comment", Style); 12791 EXPECT_EQ("int a; // the comment\n" 12792 " // aaa", 12793 format("int a; // the comment aaa", Style)); 12794 EXPECT_EQ("int a; /* first line\n" 12795 " * second line\n" 12796 " * third line\n" 12797 " */", 12798 format("int a; /* first line\n" 12799 " * second line\n" 12800 " * third line\n" 12801 " */", 12802 Style)); 12803 EXPECT_EQ("int a; // first line\n" 12804 " // second line\n" 12805 " // third line", 12806 format("int a; // first line\n" 12807 " // second line\n" 12808 " // third line", 12809 Style)); 12810 // FIXME: Investigate why this is not getting the same layout as the test 12811 // above. 12812 EXPECT_EQ("int a; /* first line\n" 12813 " * second line\n" 12814 " * third line\n" 12815 " */", 12816 format("int a; /* first line second line third line" 12817 "\n*/", 12818 Style)); 12819 12820 EXPECT_EQ("// foo bar baz bazfoo\n" 12821 "// foo bar foo bar\n", 12822 format("// foo bar baz bazfoo\n" 12823 "// foo bar foo bar\n", 12824 Style)); 12825 EXPECT_EQ("// foo bar baz bazfoo\n" 12826 "// foo bar foo bar\n", 12827 format("// foo bar baz bazfoo\n" 12828 "// foo bar foo bar\n", 12829 Style)); 12830 12831 // FIXME: Optimally, we'd keep bazfoo on the first line and reflow bar to the 12832 // next one. 12833 EXPECT_EQ("// foo bar baz bazfoo\n" 12834 "// bar foo bar\n", 12835 format("// foo bar baz bazfoo bar\n" 12836 "// foo bar\n", 12837 Style)); 12838 12839 EXPECT_EQ("// foo bar baz bazfoo\n" 12840 "// foo bar baz bazfoo\n" 12841 "// bar foo bar\n", 12842 format("// foo bar baz bazfoo\n" 12843 "// foo bar baz bazfoo bar\n" 12844 "// foo bar\n", 12845 Style)); 12846 12847 EXPECT_EQ("// foo bar baz bazfoo\n" 12848 "// foo bar baz bazfoo\n" 12849 "// bar foo bar\n", 12850 format("// foo bar baz bazfoo\n" 12851 "// foo bar baz bazfoo bar\n" 12852 "// foo bar\n", 12853 Style)); 12854 12855 // Make sure we do not keep protruding characters if strict mode reflow is 12856 // cheaper than keeping protruding characters. 12857 Style.ColumnLimit = 21; 12858 EXPECT_EQ( 12859 "// foo foo foo foo\n" 12860 "// foo foo foo foo\n" 12861 "// foo foo foo foo\n", 12862 format("// foo foo foo foo foo foo foo foo foo foo foo foo\n", Style)); 12863 12864 EXPECT_EQ("int a = /* long block\n" 12865 " comment */\n" 12866 " 42;", 12867 format("int a = /* long block comment */ 42;", Style)); 12868 } 12869 12870 #define EXPECT_ALL_STYLES_EQUAL(Styles) \ 12871 for (size_t i = 1; i < Styles.size(); ++i) \ 12872 EXPECT_EQ(Styles[0], Styles[i]) \ 12873 << "Style #" << i << " of " << Styles.size() << " differs from Style #0" 12874 12875 TEST_F(FormatTest, GetsPredefinedStyleByName) { 12876 SmallVector<FormatStyle, 3> Styles; 12877 Styles.resize(3); 12878 12879 Styles[0] = getLLVMStyle(); 12880 EXPECT_TRUE(getPredefinedStyle("LLVM", FormatStyle::LK_Cpp, &Styles[1])); 12881 EXPECT_TRUE(getPredefinedStyle("lLvM", FormatStyle::LK_Cpp, &Styles[2])); 12882 EXPECT_ALL_STYLES_EQUAL(Styles); 12883 12884 Styles[0] = getGoogleStyle(); 12885 EXPECT_TRUE(getPredefinedStyle("Google", FormatStyle::LK_Cpp, &Styles[1])); 12886 EXPECT_TRUE(getPredefinedStyle("gOOgle", FormatStyle::LK_Cpp, &Styles[2])); 12887 EXPECT_ALL_STYLES_EQUAL(Styles); 12888 12889 Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript); 12890 EXPECT_TRUE( 12891 getPredefinedStyle("Google", FormatStyle::LK_JavaScript, &Styles[1])); 12892 EXPECT_TRUE( 12893 getPredefinedStyle("gOOgle", FormatStyle::LK_JavaScript, &Styles[2])); 12894 EXPECT_ALL_STYLES_EQUAL(Styles); 12895 12896 Styles[0] = getChromiumStyle(FormatStyle::LK_Cpp); 12897 EXPECT_TRUE(getPredefinedStyle("Chromium", FormatStyle::LK_Cpp, &Styles[1])); 12898 EXPECT_TRUE(getPredefinedStyle("cHRoMiUM", FormatStyle::LK_Cpp, &Styles[2])); 12899 EXPECT_ALL_STYLES_EQUAL(Styles); 12900 12901 Styles[0] = getMozillaStyle(); 12902 EXPECT_TRUE(getPredefinedStyle("Mozilla", FormatStyle::LK_Cpp, &Styles[1])); 12903 EXPECT_TRUE(getPredefinedStyle("moZILla", FormatStyle::LK_Cpp, &Styles[2])); 12904 EXPECT_ALL_STYLES_EQUAL(Styles); 12905 12906 Styles[0] = getWebKitStyle(); 12907 EXPECT_TRUE(getPredefinedStyle("WebKit", FormatStyle::LK_Cpp, &Styles[1])); 12908 EXPECT_TRUE(getPredefinedStyle("wEbKit", FormatStyle::LK_Cpp, &Styles[2])); 12909 EXPECT_ALL_STYLES_EQUAL(Styles); 12910 12911 Styles[0] = getGNUStyle(); 12912 EXPECT_TRUE(getPredefinedStyle("GNU", FormatStyle::LK_Cpp, &Styles[1])); 12913 EXPECT_TRUE(getPredefinedStyle("gnU", FormatStyle::LK_Cpp, &Styles[2])); 12914 EXPECT_ALL_STYLES_EQUAL(Styles); 12915 12916 EXPECT_FALSE(getPredefinedStyle("qwerty", FormatStyle::LK_Cpp, &Styles[0])); 12917 } 12918 12919 TEST_F(FormatTest, GetsCorrectBasedOnStyle) { 12920 SmallVector<FormatStyle, 8> Styles; 12921 Styles.resize(2); 12922 12923 Styles[0] = getGoogleStyle(); 12924 Styles[1] = getLLVMStyle(); 12925 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value()); 12926 EXPECT_ALL_STYLES_EQUAL(Styles); 12927 12928 Styles.resize(5); 12929 Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript); 12930 Styles[1] = getLLVMStyle(); 12931 Styles[1].Language = FormatStyle::LK_JavaScript; 12932 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value()); 12933 12934 Styles[2] = getLLVMStyle(); 12935 Styles[2].Language = FormatStyle::LK_JavaScript; 12936 EXPECT_EQ(0, parseConfiguration("Language: JavaScript\n" 12937 "BasedOnStyle: Google", 12938 &Styles[2]) 12939 .value()); 12940 12941 Styles[3] = getLLVMStyle(); 12942 Styles[3].Language = FormatStyle::LK_JavaScript; 12943 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google\n" 12944 "Language: JavaScript", 12945 &Styles[3]) 12946 .value()); 12947 12948 Styles[4] = getLLVMStyle(); 12949 Styles[4].Language = FormatStyle::LK_JavaScript; 12950 EXPECT_EQ(0, parseConfiguration("---\n" 12951 "BasedOnStyle: LLVM\n" 12952 "IndentWidth: 123\n" 12953 "---\n" 12954 "BasedOnStyle: Google\n" 12955 "Language: JavaScript", 12956 &Styles[4]) 12957 .value()); 12958 EXPECT_ALL_STYLES_EQUAL(Styles); 12959 } 12960 12961 #define CHECK_PARSE_BOOL_FIELD(FIELD, CONFIG_NAME) \ 12962 Style.FIELD = false; \ 12963 EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": true", &Style).value()); \ 12964 EXPECT_TRUE(Style.FIELD); \ 12965 EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": false", &Style).value()); \ 12966 EXPECT_FALSE(Style.FIELD); 12967 12968 #define CHECK_PARSE_BOOL(FIELD) CHECK_PARSE_BOOL_FIELD(FIELD, #FIELD) 12969 12970 #define CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, CONFIG_NAME) \ 12971 Style.STRUCT.FIELD = false; \ 12972 EXPECT_EQ(0, \ 12973 parseConfiguration(#STRUCT ":\n " CONFIG_NAME ": true", &Style) \ 12974 .value()); \ 12975 EXPECT_TRUE(Style.STRUCT.FIELD); \ 12976 EXPECT_EQ(0, \ 12977 parseConfiguration(#STRUCT ":\n " CONFIG_NAME ": false", &Style) \ 12978 .value()); \ 12979 EXPECT_FALSE(Style.STRUCT.FIELD); 12980 12981 #define CHECK_PARSE_NESTED_BOOL(STRUCT, FIELD) \ 12982 CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, #FIELD) 12983 12984 #define CHECK_PARSE(TEXT, FIELD, VALUE) \ 12985 EXPECT_NE(VALUE, Style.FIELD); \ 12986 EXPECT_EQ(0, parseConfiguration(TEXT, &Style).value()); \ 12987 EXPECT_EQ(VALUE, Style.FIELD) 12988 12989 TEST_F(FormatTest, ParsesConfigurationBools) { 12990 FormatStyle Style = {}; 12991 Style.Language = FormatStyle::LK_Cpp; 12992 CHECK_PARSE_BOOL(AlignOperands); 12993 CHECK_PARSE_BOOL(AlignTrailingComments); 12994 CHECK_PARSE_BOOL(AlignConsecutiveAssignments); 12995 CHECK_PARSE_BOOL(AlignConsecutiveDeclarations); 12996 CHECK_PARSE_BOOL(AlignConsecutiveMacros); 12997 CHECK_PARSE_BOOL(AllowAllArgumentsOnNextLine); 12998 CHECK_PARSE_BOOL(AllowAllConstructorInitializersOnNextLine); 12999 CHECK_PARSE_BOOL(AllowAllParametersOfDeclarationOnNextLine); 13000 CHECK_PARSE_BOOL(AllowShortCaseLabelsOnASingleLine); 13001 CHECK_PARSE_BOOL(AllowShortEnumsOnASingleLine); 13002 CHECK_PARSE_BOOL(AllowShortLoopsOnASingleLine); 13003 CHECK_PARSE_BOOL(BinPackArguments); 13004 CHECK_PARSE_BOOL(BinPackParameters); 13005 CHECK_PARSE_BOOL(BreakAfterJavaFieldAnnotations); 13006 CHECK_PARSE_BOOL(BreakBeforeTernaryOperators); 13007 CHECK_PARSE_BOOL(BreakStringLiterals); 13008 CHECK_PARSE_BOOL(CompactNamespaces); 13009 CHECK_PARSE_BOOL(ConstructorInitializerAllOnOneLineOrOnePerLine); 13010 CHECK_PARSE_BOOL(DeriveLineEnding); 13011 CHECK_PARSE_BOOL(DerivePointerAlignment); 13012 CHECK_PARSE_BOOL_FIELD(DerivePointerAlignment, "DerivePointerBinding"); 13013 CHECK_PARSE_BOOL(DisableFormat); 13014 CHECK_PARSE_BOOL(IndentCaseLabels); 13015 CHECK_PARSE_BOOL(IndentCaseBlocks); 13016 CHECK_PARSE_BOOL(IndentGotoLabels); 13017 CHECK_PARSE_BOOL(IndentWrappedFunctionNames); 13018 CHECK_PARSE_BOOL(KeepEmptyLinesAtTheStartOfBlocks); 13019 CHECK_PARSE_BOOL(ObjCSpaceAfterProperty); 13020 CHECK_PARSE_BOOL(ObjCSpaceBeforeProtocolList); 13021 CHECK_PARSE_BOOL(Cpp11BracedListStyle); 13022 CHECK_PARSE_BOOL(ReflowComments); 13023 CHECK_PARSE_BOOL(SortIncludes); 13024 CHECK_PARSE_BOOL(SortUsingDeclarations); 13025 CHECK_PARSE_BOOL(SpacesInParentheses); 13026 CHECK_PARSE_BOOL(SpacesInSquareBrackets); 13027 CHECK_PARSE_BOOL(SpacesInAngles); 13028 CHECK_PARSE_BOOL(SpacesInConditionalStatement); 13029 CHECK_PARSE_BOOL(SpaceInEmptyBlock); 13030 CHECK_PARSE_BOOL(SpaceInEmptyParentheses); 13031 CHECK_PARSE_BOOL(SpacesInContainerLiterals); 13032 CHECK_PARSE_BOOL(SpacesInCStyleCastParentheses); 13033 CHECK_PARSE_BOOL(SpaceAfterCStyleCast); 13034 CHECK_PARSE_BOOL(SpaceAfterTemplateKeyword); 13035 CHECK_PARSE_BOOL(SpaceAfterLogicalNot); 13036 CHECK_PARSE_BOOL(SpaceBeforeAssignmentOperators); 13037 CHECK_PARSE_BOOL(SpaceBeforeCpp11BracedList); 13038 CHECK_PARSE_BOOL(SpaceBeforeCtorInitializerColon); 13039 CHECK_PARSE_BOOL(SpaceBeforeInheritanceColon); 13040 CHECK_PARSE_BOOL(SpaceBeforeRangeBasedForLoopColon); 13041 CHECK_PARSE_BOOL(SpaceBeforeSquareBrackets); 13042 CHECK_PARSE_BOOL(UseCRLF); 13043 13044 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterCaseLabel); 13045 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterClass); 13046 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterEnum); 13047 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterFunction); 13048 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterNamespace); 13049 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterObjCDeclaration); 13050 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterStruct); 13051 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterUnion); 13052 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterExternBlock); 13053 CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeCatch); 13054 CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeElse); 13055 CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeLambdaBody); 13056 CHECK_PARSE_NESTED_BOOL(BraceWrapping, IndentBraces); 13057 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyFunction); 13058 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyRecord); 13059 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyNamespace); 13060 } 13061 13062 #undef CHECK_PARSE_BOOL 13063 13064 TEST_F(FormatTest, ParsesConfiguration) { 13065 FormatStyle Style = {}; 13066 Style.Language = FormatStyle::LK_Cpp; 13067 CHECK_PARSE("AccessModifierOffset: -1234", AccessModifierOffset, -1234); 13068 CHECK_PARSE("ConstructorInitializerIndentWidth: 1234", 13069 ConstructorInitializerIndentWidth, 1234u); 13070 CHECK_PARSE("ObjCBlockIndentWidth: 1234", ObjCBlockIndentWidth, 1234u); 13071 CHECK_PARSE("ColumnLimit: 1234", ColumnLimit, 1234u); 13072 CHECK_PARSE("MaxEmptyLinesToKeep: 1234", MaxEmptyLinesToKeep, 1234u); 13073 CHECK_PARSE("PenaltyBreakAssignment: 1234", PenaltyBreakAssignment, 1234u); 13074 CHECK_PARSE("PenaltyBreakBeforeFirstCallParameter: 1234", 13075 PenaltyBreakBeforeFirstCallParameter, 1234u); 13076 CHECK_PARSE("PenaltyBreakTemplateDeclaration: 1234", 13077 PenaltyBreakTemplateDeclaration, 1234u); 13078 CHECK_PARSE("PenaltyExcessCharacter: 1234", PenaltyExcessCharacter, 1234u); 13079 CHECK_PARSE("PenaltyReturnTypeOnItsOwnLine: 1234", 13080 PenaltyReturnTypeOnItsOwnLine, 1234u); 13081 CHECK_PARSE("SpacesBeforeTrailingComments: 1234", 13082 SpacesBeforeTrailingComments, 1234u); 13083 CHECK_PARSE("IndentWidth: 32", IndentWidth, 32u); 13084 CHECK_PARSE("ContinuationIndentWidth: 11", ContinuationIndentWidth, 11u); 13085 CHECK_PARSE("CommentPragmas: '// abc$'", CommentPragmas, "// abc$"); 13086 13087 Style.PointerAlignment = FormatStyle::PAS_Middle; 13088 CHECK_PARSE("PointerAlignment: Left", PointerAlignment, 13089 FormatStyle::PAS_Left); 13090 CHECK_PARSE("PointerAlignment: Right", PointerAlignment, 13091 FormatStyle::PAS_Right); 13092 CHECK_PARSE("PointerAlignment: Middle", PointerAlignment, 13093 FormatStyle::PAS_Middle); 13094 // For backward compatibility: 13095 CHECK_PARSE("PointerBindsToType: Left", PointerAlignment, 13096 FormatStyle::PAS_Left); 13097 CHECK_PARSE("PointerBindsToType: Right", PointerAlignment, 13098 FormatStyle::PAS_Right); 13099 CHECK_PARSE("PointerBindsToType: Middle", PointerAlignment, 13100 FormatStyle::PAS_Middle); 13101 13102 Style.Standard = FormatStyle::LS_Auto; 13103 CHECK_PARSE("Standard: c++03", Standard, FormatStyle::LS_Cpp03); 13104 CHECK_PARSE("Standard: c++11", Standard, FormatStyle::LS_Cpp11); 13105 CHECK_PARSE("Standard: c++14", Standard, FormatStyle::LS_Cpp14); 13106 CHECK_PARSE("Standard: c++17", Standard, FormatStyle::LS_Cpp17); 13107 CHECK_PARSE("Standard: c++20", Standard, FormatStyle::LS_Cpp20); 13108 CHECK_PARSE("Standard: Auto", Standard, FormatStyle::LS_Auto); 13109 CHECK_PARSE("Standard: Latest", Standard, FormatStyle::LS_Latest); 13110 // Legacy aliases: 13111 CHECK_PARSE("Standard: Cpp03", Standard, FormatStyle::LS_Cpp03); 13112 CHECK_PARSE("Standard: Cpp11", Standard, FormatStyle::LS_Latest); 13113 CHECK_PARSE("Standard: C++03", Standard, FormatStyle::LS_Cpp03); 13114 CHECK_PARSE("Standard: C++11", Standard, FormatStyle::LS_Cpp11); 13115 13116 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 13117 CHECK_PARSE("BreakBeforeBinaryOperators: NonAssignment", 13118 BreakBeforeBinaryOperators, FormatStyle::BOS_NonAssignment); 13119 CHECK_PARSE("BreakBeforeBinaryOperators: None", BreakBeforeBinaryOperators, 13120 FormatStyle::BOS_None); 13121 CHECK_PARSE("BreakBeforeBinaryOperators: All", BreakBeforeBinaryOperators, 13122 FormatStyle::BOS_All); 13123 // For backward compatibility: 13124 CHECK_PARSE("BreakBeforeBinaryOperators: false", BreakBeforeBinaryOperators, 13125 FormatStyle::BOS_None); 13126 CHECK_PARSE("BreakBeforeBinaryOperators: true", BreakBeforeBinaryOperators, 13127 FormatStyle::BOS_All); 13128 13129 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon; 13130 CHECK_PARSE("BreakConstructorInitializers: BeforeComma", 13131 BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma); 13132 CHECK_PARSE("BreakConstructorInitializers: AfterColon", 13133 BreakConstructorInitializers, FormatStyle::BCIS_AfterColon); 13134 CHECK_PARSE("BreakConstructorInitializers: BeforeColon", 13135 BreakConstructorInitializers, FormatStyle::BCIS_BeforeColon); 13136 // For backward compatibility: 13137 CHECK_PARSE("BreakConstructorInitializersBeforeComma: true", 13138 BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma); 13139 13140 Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon; 13141 CHECK_PARSE("BreakInheritanceList: BeforeComma", BreakInheritanceList, 13142 FormatStyle::BILS_BeforeComma); 13143 CHECK_PARSE("BreakInheritanceList: AfterColon", BreakInheritanceList, 13144 FormatStyle::BILS_AfterColon); 13145 CHECK_PARSE("BreakInheritanceList: BeforeColon", BreakInheritanceList, 13146 FormatStyle::BILS_BeforeColon); 13147 // For backward compatibility: 13148 CHECK_PARSE("BreakBeforeInheritanceComma: true", BreakInheritanceList, 13149 FormatStyle::BILS_BeforeComma); 13150 13151 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 13152 CHECK_PARSE("AlignAfterOpenBracket: Align", AlignAfterOpenBracket, 13153 FormatStyle::BAS_Align); 13154 CHECK_PARSE("AlignAfterOpenBracket: DontAlign", AlignAfterOpenBracket, 13155 FormatStyle::BAS_DontAlign); 13156 CHECK_PARSE("AlignAfterOpenBracket: AlwaysBreak", AlignAfterOpenBracket, 13157 FormatStyle::BAS_AlwaysBreak); 13158 // For backward compatibility: 13159 CHECK_PARSE("AlignAfterOpenBracket: false", AlignAfterOpenBracket, 13160 FormatStyle::BAS_DontAlign); 13161 CHECK_PARSE("AlignAfterOpenBracket: true", AlignAfterOpenBracket, 13162 FormatStyle::BAS_Align); 13163 13164 Style.AlignEscapedNewlines = FormatStyle::ENAS_Left; 13165 CHECK_PARSE("AlignEscapedNewlines: DontAlign", AlignEscapedNewlines, 13166 FormatStyle::ENAS_DontAlign); 13167 CHECK_PARSE("AlignEscapedNewlines: Left", AlignEscapedNewlines, 13168 FormatStyle::ENAS_Left); 13169 CHECK_PARSE("AlignEscapedNewlines: Right", AlignEscapedNewlines, 13170 FormatStyle::ENAS_Right); 13171 // For backward compatibility: 13172 CHECK_PARSE("AlignEscapedNewlinesLeft: true", AlignEscapedNewlines, 13173 FormatStyle::ENAS_Left); 13174 CHECK_PARSE("AlignEscapedNewlinesLeft: false", AlignEscapedNewlines, 13175 FormatStyle::ENAS_Right); 13176 13177 Style.UseTab = FormatStyle::UT_ForIndentation; 13178 CHECK_PARSE("UseTab: Never", UseTab, FormatStyle::UT_Never); 13179 CHECK_PARSE("UseTab: ForIndentation", UseTab, FormatStyle::UT_ForIndentation); 13180 CHECK_PARSE("UseTab: Always", UseTab, FormatStyle::UT_Always); 13181 CHECK_PARSE("UseTab: ForContinuationAndIndentation", UseTab, 13182 FormatStyle::UT_ForContinuationAndIndentation); 13183 CHECK_PARSE("UseTab: AlignWithSpaces", UseTab, 13184 FormatStyle::UT_AlignWithSpaces); 13185 // For backward compatibility: 13186 CHECK_PARSE("UseTab: false", UseTab, FormatStyle::UT_Never); 13187 CHECK_PARSE("UseTab: true", UseTab, FormatStyle::UT_Always); 13188 13189 Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty; 13190 CHECK_PARSE("AllowShortBlocksOnASingleLine: Never", 13191 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never); 13192 CHECK_PARSE("AllowShortBlocksOnASingleLine: Empty", 13193 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Empty); 13194 CHECK_PARSE("AllowShortBlocksOnASingleLine: Always", 13195 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always); 13196 // For backward compatibility: 13197 CHECK_PARSE("AllowShortBlocksOnASingleLine: false", 13198 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never); 13199 CHECK_PARSE("AllowShortBlocksOnASingleLine: true", 13200 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always); 13201 13202 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; 13203 CHECK_PARSE("AllowShortFunctionsOnASingleLine: None", 13204 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None); 13205 CHECK_PARSE("AllowShortFunctionsOnASingleLine: Inline", 13206 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Inline); 13207 CHECK_PARSE("AllowShortFunctionsOnASingleLine: Empty", 13208 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Empty); 13209 CHECK_PARSE("AllowShortFunctionsOnASingleLine: All", 13210 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All); 13211 // For backward compatibility: 13212 CHECK_PARSE("AllowShortFunctionsOnASingleLine: false", 13213 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None); 13214 CHECK_PARSE("AllowShortFunctionsOnASingleLine: true", 13215 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All); 13216 13217 Style.SpaceBeforeParens = FormatStyle::SBPO_Always; 13218 CHECK_PARSE("SpaceBeforeParens: Never", SpaceBeforeParens, 13219 FormatStyle::SBPO_Never); 13220 CHECK_PARSE("SpaceBeforeParens: Always", SpaceBeforeParens, 13221 FormatStyle::SBPO_Always); 13222 CHECK_PARSE("SpaceBeforeParens: ControlStatements", SpaceBeforeParens, 13223 FormatStyle::SBPO_ControlStatements); 13224 CHECK_PARSE("SpaceBeforeParens: NonEmptyParentheses", SpaceBeforeParens, 13225 FormatStyle::SBPO_NonEmptyParentheses); 13226 // For backward compatibility: 13227 CHECK_PARSE("SpaceAfterControlStatementKeyword: false", SpaceBeforeParens, 13228 FormatStyle::SBPO_Never); 13229 CHECK_PARSE("SpaceAfterControlStatementKeyword: true", SpaceBeforeParens, 13230 FormatStyle::SBPO_ControlStatements); 13231 13232 Style.ColumnLimit = 123; 13233 FormatStyle BaseStyle = getLLVMStyle(); 13234 CHECK_PARSE("BasedOnStyle: LLVM", ColumnLimit, BaseStyle.ColumnLimit); 13235 CHECK_PARSE("BasedOnStyle: LLVM\nColumnLimit: 1234", ColumnLimit, 1234u); 13236 13237 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 13238 CHECK_PARSE("BreakBeforeBraces: Attach", BreakBeforeBraces, 13239 FormatStyle::BS_Attach); 13240 CHECK_PARSE("BreakBeforeBraces: Linux", BreakBeforeBraces, 13241 FormatStyle::BS_Linux); 13242 CHECK_PARSE("BreakBeforeBraces: Mozilla", BreakBeforeBraces, 13243 FormatStyle::BS_Mozilla); 13244 CHECK_PARSE("BreakBeforeBraces: Stroustrup", BreakBeforeBraces, 13245 FormatStyle::BS_Stroustrup); 13246 CHECK_PARSE("BreakBeforeBraces: Allman", BreakBeforeBraces, 13247 FormatStyle::BS_Allman); 13248 CHECK_PARSE("BreakBeforeBraces: Whitesmiths", BreakBeforeBraces, 13249 FormatStyle::BS_Whitesmiths); 13250 CHECK_PARSE("BreakBeforeBraces: GNU", BreakBeforeBraces, FormatStyle::BS_GNU); 13251 CHECK_PARSE("BreakBeforeBraces: WebKit", BreakBeforeBraces, 13252 FormatStyle::BS_WebKit); 13253 CHECK_PARSE("BreakBeforeBraces: Custom", BreakBeforeBraces, 13254 FormatStyle::BS_Custom); 13255 13256 Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Never; 13257 CHECK_PARSE("BraceWrapping:\n" 13258 " AfterControlStatement: MultiLine", 13259 BraceWrapping.AfterControlStatement, 13260 FormatStyle::BWACS_MultiLine); 13261 CHECK_PARSE("BraceWrapping:\n" 13262 " AfterControlStatement: Always", 13263 BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Always); 13264 CHECK_PARSE("BraceWrapping:\n" 13265 " AfterControlStatement: Never", 13266 BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Never); 13267 // For backward compatibility: 13268 CHECK_PARSE("BraceWrapping:\n" 13269 " AfterControlStatement: true", 13270 BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Always); 13271 CHECK_PARSE("BraceWrapping:\n" 13272 " AfterControlStatement: false", 13273 BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Never); 13274 13275 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All; 13276 CHECK_PARSE("AlwaysBreakAfterReturnType: None", AlwaysBreakAfterReturnType, 13277 FormatStyle::RTBS_None); 13278 CHECK_PARSE("AlwaysBreakAfterReturnType: All", AlwaysBreakAfterReturnType, 13279 FormatStyle::RTBS_All); 13280 CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevel", 13281 AlwaysBreakAfterReturnType, FormatStyle::RTBS_TopLevel); 13282 CHECK_PARSE("AlwaysBreakAfterReturnType: AllDefinitions", 13283 AlwaysBreakAfterReturnType, FormatStyle::RTBS_AllDefinitions); 13284 CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevelDefinitions", 13285 AlwaysBreakAfterReturnType, 13286 FormatStyle::RTBS_TopLevelDefinitions); 13287 13288 Style.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes; 13289 CHECK_PARSE("AlwaysBreakTemplateDeclarations: No", 13290 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_No); 13291 CHECK_PARSE("AlwaysBreakTemplateDeclarations: MultiLine", 13292 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_MultiLine); 13293 CHECK_PARSE("AlwaysBreakTemplateDeclarations: Yes", 13294 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_Yes); 13295 CHECK_PARSE("AlwaysBreakTemplateDeclarations: false", 13296 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_MultiLine); 13297 CHECK_PARSE("AlwaysBreakTemplateDeclarations: true", 13298 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_Yes); 13299 13300 Style.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_All; 13301 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: None", 13302 AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_None); 13303 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: All", 13304 AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_All); 13305 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: TopLevel", 13306 AlwaysBreakAfterDefinitionReturnType, 13307 FormatStyle::DRTBS_TopLevel); 13308 13309 Style.NamespaceIndentation = FormatStyle::NI_All; 13310 CHECK_PARSE("NamespaceIndentation: None", NamespaceIndentation, 13311 FormatStyle::NI_None); 13312 CHECK_PARSE("NamespaceIndentation: Inner", NamespaceIndentation, 13313 FormatStyle::NI_Inner); 13314 CHECK_PARSE("NamespaceIndentation: All", NamespaceIndentation, 13315 FormatStyle::NI_All); 13316 13317 Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Always; 13318 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Never", 13319 AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never); 13320 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: WithoutElse", 13321 AllowShortIfStatementsOnASingleLine, 13322 FormatStyle::SIS_WithoutElse); 13323 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Always", 13324 AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Always); 13325 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: false", 13326 AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never); 13327 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: true", 13328 AllowShortIfStatementsOnASingleLine, 13329 FormatStyle::SIS_WithoutElse); 13330 13331 // FIXME: This is required because parsing a configuration simply overwrites 13332 // the first N elements of the list instead of resetting it. 13333 Style.ForEachMacros.clear(); 13334 std::vector<std::string> BoostForeach; 13335 BoostForeach.push_back("BOOST_FOREACH"); 13336 CHECK_PARSE("ForEachMacros: [BOOST_FOREACH]", ForEachMacros, BoostForeach); 13337 std::vector<std::string> BoostAndQForeach; 13338 BoostAndQForeach.push_back("BOOST_FOREACH"); 13339 BoostAndQForeach.push_back("Q_FOREACH"); 13340 CHECK_PARSE("ForEachMacros: [BOOST_FOREACH, Q_FOREACH]", ForEachMacros, 13341 BoostAndQForeach); 13342 13343 Style.StatementMacros.clear(); 13344 CHECK_PARSE("StatementMacros: [QUNUSED]", StatementMacros, 13345 std::vector<std::string>{"QUNUSED"}); 13346 CHECK_PARSE("StatementMacros: [QUNUSED, QT_REQUIRE_VERSION]", StatementMacros, 13347 std::vector<std::string>({"QUNUSED", "QT_REQUIRE_VERSION"})); 13348 13349 Style.NamespaceMacros.clear(); 13350 CHECK_PARSE("NamespaceMacros: [TESTSUITE]", NamespaceMacros, 13351 std::vector<std::string>{"TESTSUITE"}); 13352 CHECK_PARSE("NamespaceMacros: [TESTSUITE, SUITE]", NamespaceMacros, 13353 std::vector<std::string>({"TESTSUITE", "SUITE"})); 13354 13355 Style.IncludeStyle.IncludeCategories.clear(); 13356 std::vector<tooling::IncludeStyle::IncludeCategory> ExpectedCategories = { 13357 {"abc/.*", 2, 0}, {".*", 1, 0}}; 13358 CHECK_PARSE("IncludeCategories:\n" 13359 " - Regex: abc/.*\n" 13360 " Priority: 2\n" 13361 " - Regex: .*\n" 13362 " Priority: 1", 13363 IncludeStyle.IncludeCategories, ExpectedCategories); 13364 CHECK_PARSE("IncludeIsMainRegex: 'abc$'", IncludeStyle.IncludeIsMainRegex, 13365 "abc$"); 13366 CHECK_PARSE("IncludeIsMainSourceRegex: 'abc$'", 13367 IncludeStyle.IncludeIsMainSourceRegex, "abc$"); 13368 13369 Style.RawStringFormats.clear(); 13370 std::vector<FormatStyle::RawStringFormat> ExpectedRawStringFormats = { 13371 { 13372 FormatStyle::LK_TextProto, 13373 {"pb", "proto"}, 13374 {"PARSE_TEXT_PROTO"}, 13375 /*CanonicalDelimiter=*/"", 13376 "llvm", 13377 }, 13378 { 13379 FormatStyle::LK_Cpp, 13380 {"cc", "cpp"}, 13381 {"C_CODEBLOCK", "CPPEVAL"}, 13382 /*CanonicalDelimiter=*/"cc", 13383 /*BasedOnStyle=*/"", 13384 }, 13385 }; 13386 13387 CHECK_PARSE("RawStringFormats:\n" 13388 " - Language: TextProto\n" 13389 " Delimiters:\n" 13390 " - 'pb'\n" 13391 " - 'proto'\n" 13392 " EnclosingFunctions:\n" 13393 " - 'PARSE_TEXT_PROTO'\n" 13394 " BasedOnStyle: llvm\n" 13395 " - Language: Cpp\n" 13396 " Delimiters:\n" 13397 " - 'cc'\n" 13398 " - 'cpp'\n" 13399 " EnclosingFunctions:\n" 13400 " - 'C_CODEBLOCK'\n" 13401 " - 'CPPEVAL'\n" 13402 " CanonicalDelimiter: 'cc'", 13403 RawStringFormats, ExpectedRawStringFormats); 13404 } 13405 13406 TEST_F(FormatTest, ParsesConfigurationWithLanguages) { 13407 FormatStyle Style = {}; 13408 Style.Language = FormatStyle::LK_Cpp; 13409 CHECK_PARSE("Language: Cpp\n" 13410 "IndentWidth: 12", 13411 IndentWidth, 12u); 13412 EXPECT_EQ(parseConfiguration("Language: JavaScript\n" 13413 "IndentWidth: 34", 13414 &Style), 13415 ParseError::Unsuitable); 13416 FormatStyle BinPackedTCS = {}; 13417 BinPackedTCS.Language = FormatStyle::LK_JavaScript; 13418 EXPECT_EQ(parseConfiguration("BinPackArguments: true\n" 13419 "InsertTrailingCommas: Wrapped", 13420 &BinPackedTCS), 13421 ParseError::BinPackTrailingCommaConflict); 13422 EXPECT_EQ(12u, Style.IndentWidth); 13423 CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u); 13424 EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language); 13425 13426 Style.Language = FormatStyle::LK_JavaScript; 13427 CHECK_PARSE("Language: JavaScript\n" 13428 "IndentWidth: 12", 13429 IndentWidth, 12u); 13430 CHECK_PARSE("IndentWidth: 23", IndentWidth, 23u); 13431 EXPECT_EQ(parseConfiguration("Language: Cpp\n" 13432 "IndentWidth: 34", 13433 &Style), 13434 ParseError::Unsuitable); 13435 EXPECT_EQ(23u, Style.IndentWidth); 13436 CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u); 13437 EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language); 13438 13439 CHECK_PARSE("BasedOnStyle: LLVM\n" 13440 "IndentWidth: 67", 13441 IndentWidth, 67u); 13442 13443 CHECK_PARSE("---\n" 13444 "Language: JavaScript\n" 13445 "IndentWidth: 12\n" 13446 "---\n" 13447 "Language: Cpp\n" 13448 "IndentWidth: 34\n" 13449 "...\n", 13450 IndentWidth, 12u); 13451 13452 Style.Language = FormatStyle::LK_Cpp; 13453 CHECK_PARSE("---\n" 13454 "Language: JavaScript\n" 13455 "IndentWidth: 12\n" 13456 "---\n" 13457 "Language: Cpp\n" 13458 "IndentWidth: 34\n" 13459 "...\n", 13460 IndentWidth, 34u); 13461 CHECK_PARSE("---\n" 13462 "IndentWidth: 78\n" 13463 "---\n" 13464 "Language: JavaScript\n" 13465 "IndentWidth: 56\n" 13466 "...\n", 13467 IndentWidth, 78u); 13468 13469 Style.ColumnLimit = 123; 13470 Style.IndentWidth = 234; 13471 Style.BreakBeforeBraces = FormatStyle::BS_Linux; 13472 Style.TabWidth = 345; 13473 EXPECT_FALSE(parseConfiguration("---\n" 13474 "IndentWidth: 456\n" 13475 "BreakBeforeBraces: Allman\n" 13476 "---\n" 13477 "Language: JavaScript\n" 13478 "IndentWidth: 111\n" 13479 "TabWidth: 111\n" 13480 "---\n" 13481 "Language: Cpp\n" 13482 "BreakBeforeBraces: Stroustrup\n" 13483 "TabWidth: 789\n" 13484 "...\n", 13485 &Style)); 13486 EXPECT_EQ(123u, Style.ColumnLimit); 13487 EXPECT_EQ(456u, Style.IndentWidth); 13488 EXPECT_EQ(FormatStyle::BS_Stroustrup, Style.BreakBeforeBraces); 13489 EXPECT_EQ(789u, Style.TabWidth); 13490 13491 EXPECT_EQ(parseConfiguration("---\n" 13492 "Language: JavaScript\n" 13493 "IndentWidth: 56\n" 13494 "---\n" 13495 "IndentWidth: 78\n" 13496 "...\n", 13497 &Style), 13498 ParseError::Error); 13499 EXPECT_EQ(parseConfiguration("---\n" 13500 "Language: JavaScript\n" 13501 "IndentWidth: 56\n" 13502 "---\n" 13503 "Language: JavaScript\n" 13504 "IndentWidth: 78\n" 13505 "...\n", 13506 &Style), 13507 ParseError::Error); 13508 13509 EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language); 13510 } 13511 13512 #undef CHECK_PARSE 13513 13514 TEST_F(FormatTest, UsesLanguageForBasedOnStyle) { 13515 FormatStyle Style = {}; 13516 Style.Language = FormatStyle::LK_JavaScript; 13517 Style.BreakBeforeTernaryOperators = true; 13518 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Style).value()); 13519 EXPECT_FALSE(Style.BreakBeforeTernaryOperators); 13520 13521 Style.BreakBeforeTernaryOperators = true; 13522 EXPECT_EQ(0, parseConfiguration("---\n" 13523 "BasedOnStyle: Google\n" 13524 "---\n" 13525 "Language: JavaScript\n" 13526 "IndentWidth: 76\n" 13527 "...\n", 13528 &Style) 13529 .value()); 13530 EXPECT_FALSE(Style.BreakBeforeTernaryOperators); 13531 EXPECT_EQ(76u, Style.IndentWidth); 13532 EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language); 13533 } 13534 13535 TEST_F(FormatTest, ConfigurationRoundTripTest) { 13536 FormatStyle Style = getLLVMStyle(); 13537 std::string YAML = configurationAsText(Style); 13538 FormatStyle ParsedStyle = {}; 13539 ParsedStyle.Language = FormatStyle::LK_Cpp; 13540 EXPECT_EQ(0, parseConfiguration(YAML, &ParsedStyle).value()); 13541 EXPECT_EQ(Style, ParsedStyle); 13542 } 13543 13544 TEST_F(FormatTest, WorksFor8bitEncodings) { 13545 EXPECT_EQ("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 \"\n" 13546 "\"\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \"\n" 13547 "\"\xe7\xe8\xec\xed\xfe\xfe \"\n" 13548 "\"\xef\xee\xf0\xf3...\"", 13549 format("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 " 13550 "\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \xe7\xe8\xec\xed\xfe\xfe " 13551 "\xef\xee\xf0\xf3...\"", 13552 getLLVMStyleWithColumns(12))); 13553 } 13554 13555 TEST_F(FormatTest, HandlesUTF8BOM) { 13556 EXPECT_EQ("\xef\xbb\xbf", format("\xef\xbb\xbf")); 13557 EXPECT_EQ("\xef\xbb\xbf#include <iostream>", 13558 format("\xef\xbb\xbf#include <iostream>")); 13559 EXPECT_EQ("\xef\xbb\xbf\n#include <iostream>", 13560 format("\xef\xbb\xbf\n#include <iostream>")); 13561 } 13562 13563 // FIXME: Encode Cyrillic and CJK characters below to appease MS compilers. 13564 #if !defined(_MSC_VER) 13565 13566 TEST_F(FormatTest, CountsUTF8CharactersProperly) { 13567 verifyFormat("\"Однажды в студёную зимнюю пору...\"", 13568 getLLVMStyleWithColumns(35)); 13569 verifyFormat("\"一 二 三 四 五 六 七 八 九 十\"", 13570 getLLVMStyleWithColumns(31)); 13571 verifyFormat("// Однажды в студёную зимнюю пору...", 13572 getLLVMStyleWithColumns(36)); 13573 verifyFormat("// 一 二 三 四 五 六 七 八 九 十", getLLVMStyleWithColumns(32)); 13574 verifyFormat("/* Однажды в студёную зимнюю пору... */", 13575 getLLVMStyleWithColumns(39)); 13576 verifyFormat("/* 一 二 三 四 五 六 七 八 九 十 */", 13577 getLLVMStyleWithColumns(35)); 13578 } 13579 13580 TEST_F(FormatTest, SplitsUTF8Strings) { 13581 // Non-printable characters' width is currently considered to be the length in 13582 // bytes in UTF8. The characters can be displayed in very different manner 13583 // (zero-width, single width with a substitution glyph, expanded to their code 13584 // (e.g. "<8d>"), so there's no single correct way to handle them. 13585 EXPECT_EQ("\"aaaaÄ\"\n" 13586 "\"\xc2\x8d\";", 13587 format("\"aaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10))); 13588 EXPECT_EQ("\"aaaaaaaÄ\"\n" 13589 "\"\xc2\x8d\";", 13590 format("\"aaaaaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10))); 13591 EXPECT_EQ("\"Однажды, в \"\n" 13592 "\"студёную \"\n" 13593 "\"зимнюю \"\n" 13594 "\"пору,\"", 13595 format("\"Однажды, в студёную зимнюю пору,\"", 13596 getLLVMStyleWithColumns(13))); 13597 EXPECT_EQ( 13598 "\"一 二 三 \"\n" 13599 "\"四 五六 \"\n" 13600 "\"七 八 九 \"\n" 13601 "\"十\"", 13602 format("\"一 二 三 四 五六 七 八 九 十\"", getLLVMStyleWithColumns(11))); 13603 EXPECT_EQ("\"一\t\"\n" 13604 "\"二 \t\"\n" 13605 "\"三 四 \"\n" 13606 "\"五\t\"\n" 13607 "\"六 \t\"\n" 13608 "\"七 \"\n" 13609 "\"八九十\tqq\"", 13610 format("\"一\t二 \t三 四 五\t六 \t七 八九十\tqq\"", 13611 getLLVMStyleWithColumns(11))); 13612 13613 // UTF8 character in an escape sequence. 13614 EXPECT_EQ("\"aaaaaa\"\n" 13615 "\"\\\xC2\x8D\"", 13616 format("\"aaaaaa\\\xC2\x8D\"", getLLVMStyleWithColumns(10))); 13617 } 13618 13619 TEST_F(FormatTest, HandlesDoubleWidthCharsInMultiLineStrings) { 13620 EXPECT_EQ("const char *sssss =\n" 13621 " \"一二三四五六七八\\\n" 13622 " 九 十\";", 13623 format("const char *sssss = \"一二三四五六七八\\\n" 13624 " 九 十\";", 13625 getLLVMStyleWithColumns(30))); 13626 } 13627 13628 TEST_F(FormatTest, SplitsUTF8LineComments) { 13629 EXPECT_EQ("// aaaaÄ\xc2\x8d", 13630 format("// aaaaÄ\xc2\x8d", getLLVMStyleWithColumns(10))); 13631 EXPECT_EQ("// Я из лесу\n" 13632 "// вышел; был\n" 13633 "// сильный\n" 13634 "// мороз.", 13635 format("// Я из лесу вышел; был сильный мороз.", 13636 getLLVMStyleWithColumns(13))); 13637 EXPECT_EQ("// 一二三\n" 13638 "// 四五六七\n" 13639 "// 八 九\n" 13640 "// 十", 13641 format("// 一二三 四五六七 八 九 十", getLLVMStyleWithColumns(9))); 13642 } 13643 13644 TEST_F(FormatTest, SplitsUTF8BlockComments) { 13645 EXPECT_EQ("/* Гляжу,\n" 13646 " * поднимается\n" 13647 " * медленно в\n" 13648 " * гору\n" 13649 " * Лошадка,\n" 13650 " * везущая\n" 13651 " * хворосту\n" 13652 " * воз. */", 13653 format("/* Гляжу, поднимается медленно в гору\n" 13654 " * Лошадка, везущая хворосту воз. */", 13655 getLLVMStyleWithColumns(13))); 13656 EXPECT_EQ( 13657 "/* 一二三\n" 13658 " * 四五六七\n" 13659 " * 八 九\n" 13660 " * 十 */", 13661 format("/* 一二三 四五六七 八 九 十 */", getLLVMStyleWithColumns(9))); 13662 EXPECT_EQ("/* �������� ��������\n" 13663 " * ��������\n" 13664 " * ������-�� */", 13665 format("/* �������� �������� �������� ������-�� */", getLLVMStyleWithColumns(12))); 13666 } 13667 13668 #endif // _MSC_VER 13669 13670 TEST_F(FormatTest, ConstructorInitializerIndentWidth) { 13671 FormatStyle Style = getLLVMStyle(); 13672 13673 Style.ConstructorInitializerIndentWidth = 4; 13674 verifyFormat( 13675 "SomeClass::Constructor()\n" 13676 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 13677 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 13678 Style); 13679 13680 Style.ConstructorInitializerIndentWidth = 2; 13681 verifyFormat( 13682 "SomeClass::Constructor()\n" 13683 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 13684 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 13685 Style); 13686 13687 Style.ConstructorInitializerIndentWidth = 0; 13688 verifyFormat( 13689 "SomeClass::Constructor()\n" 13690 ": aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 13691 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 13692 Style); 13693 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 13694 verifyFormat( 13695 "SomeLongTemplateVariableName<\n" 13696 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>", 13697 Style); 13698 verifyFormat("bool smaller = 1 < " 13699 "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 13700 " " 13701 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 13702 Style); 13703 13704 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 13705 verifyFormat("SomeClass::Constructor() :\n" 13706 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa),\n" 13707 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa) {}", 13708 Style); 13709 } 13710 13711 TEST_F(FormatTest, BreakConstructorInitializersBeforeComma) { 13712 FormatStyle Style = getLLVMStyle(); 13713 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 13714 Style.ConstructorInitializerIndentWidth = 4; 13715 verifyFormat("SomeClass::Constructor()\n" 13716 " : a(a)\n" 13717 " , b(b)\n" 13718 " , c(c) {}", 13719 Style); 13720 verifyFormat("SomeClass::Constructor()\n" 13721 " : a(a) {}", 13722 Style); 13723 13724 Style.ColumnLimit = 0; 13725 verifyFormat("SomeClass::Constructor()\n" 13726 " : a(a) {}", 13727 Style); 13728 verifyFormat("SomeClass::Constructor() noexcept\n" 13729 " : a(a) {}", 13730 Style); 13731 verifyFormat("SomeClass::Constructor()\n" 13732 " : a(a)\n" 13733 " , b(b)\n" 13734 " , c(c) {}", 13735 Style); 13736 verifyFormat("SomeClass::Constructor()\n" 13737 " : a(a) {\n" 13738 " foo();\n" 13739 " bar();\n" 13740 "}", 13741 Style); 13742 13743 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 13744 verifyFormat("SomeClass::Constructor()\n" 13745 " : a(a)\n" 13746 " , b(b)\n" 13747 " , c(c) {\n}", 13748 Style); 13749 verifyFormat("SomeClass::Constructor()\n" 13750 " : a(a) {\n}", 13751 Style); 13752 13753 Style.ColumnLimit = 80; 13754 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 13755 Style.ConstructorInitializerIndentWidth = 2; 13756 verifyFormat("SomeClass::Constructor()\n" 13757 " : a(a)\n" 13758 " , b(b)\n" 13759 " , c(c) {}", 13760 Style); 13761 13762 Style.ConstructorInitializerIndentWidth = 0; 13763 verifyFormat("SomeClass::Constructor()\n" 13764 ": a(a)\n" 13765 ", b(b)\n" 13766 ", c(c) {}", 13767 Style); 13768 13769 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 13770 Style.ConstructorInitializerIndentWidth = 4; 13771 verifyFormat("SomeClass::Constructor() : aaaaaaaa(aaaaaaaa) {}", Style); 13772 verifyFormat( 13773 "SomeClass::Constructor() : aaaaa(aaaaa), aaaaa(aaaaa), aaaaa(aaaaa)\n", 13774 Style); 13775 verifyFormat( 13776 "SomeClass::Constructor()\n" 13777 " : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa) {}", 13778 Style); 13779 Style.ConstructorInitializerIndentWidth = 4; 13780 Style.ColumnLimit = 60; 13781 verifyFormat("SomeClass::Constructor()\n" 13782 " : aaaaaaaa(aaaaaaaa)\n" 13783 " , aaaaaaaa(aaaaaaaa)\n" 13784 " , aaaaaaaa(aaaaaaaa) {}", 13785 Style); 13786 } 13787 13788 TEST_F(FormatTest, Destructors) { 13789 verifyFormat("void F(int &i) { i.~int(); }"); 13790 verifyFormat("void F(int &i) { i->~int(); }"); 13791 } 13792 13793 TEST_F(FormatTest, FormatsWithWebKitStyle) { 13794 FormatStyle Style = getWebKitStyle(); 13795 13796 // Don't indent in outer namespaces. 13797 verifyFormat("namespace outer {\n" 13798 "int i;\n" 13799 "namespace inner {\n" 13800 " int i;\n" 13801 "} // namespace inner\n" 13802 "} // namespace outer\n" 13803 "namespace other_outer {\n" 13804 "int i;\n" 13805 "}", 13806 Style); 13807 13808 // Don't indent case labels. 13809 verifyFormat("switch (variable) {\n" 13810 "case 1:\n" 13811 "case 2:\n" 13812 " doSomething();\n" 13813 " break;\n" 13814 "default:\n" 13815 " ++variable;\n" 13816 "}", 13817 Style); 13818 13819 // Wrap before binary operators. 13820 EXPECT_EQ("void f()\n" 13821 "{\n" 13822 " if (aaaaaaaaaaaaaaaa\n" 13823 " && bbbbbbbbbbbbbbbbbbbbbbbb\n" 13824 " && (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n" 13825 " return;\n" 13826 "}", 13827 format("void f() {\n" 13828 "if (aaaaaaaaaaaaaaaa\n" 13829 "&& bbbbbbbbbbbbbbbbbbbbbbbb\n" 13830 "&& (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n" 13831 "return;\n" 13832 "}", 13833 Style)); 13834 13835 // Allow functions on a single line. 13836 verifyFormat("void f() { return; }", Style); 13837 13838 // Allow empty blocks on a single line and insert a space in empty blocks. 13839 EXPECT_EQ("void f() { }", format("void f() {}", Style)); 13840 EXPECT_EQ("while (true) { }", format("while (true) {}", Style)); 13841 // However, don't merge non-empty short loops. 13842 EXPECT_EQ("while (true) {\n" 13843 " continue;\n" 13844 "}", 13845 format("while (true) { continue; }", Style)); 13846 13847 // Constructor initializers are formatted one per line with the "," on the 13848 // new line. 13849 verifyFormat("Constructor()\n" 13850 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 13851 " , aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaa, // break\n" 13852 " aaaaaaaaaaaaaa)\n" 13853 " , aaaaaaaaaaaaaaaaaaaaaaa()\n" 13854 "{\n" 13855 "}", 13856 Style); 13857 verifyFormat("SomeClass::Constructor()\n" 13858 " : a(a)\n" 13859 "{\n" 13860 "}", 13861 Style); 13862 EXPECT_EQ("SomeClass::Constructor()\n" 13863 " : a(a)\n" 13864 "{\n" 13865 "}", 13866 format("SomeClass::Constructor():a(a){}", Style)); 13867 verifyFormat("SomeClass::Constructor()\n" 13868 " : a(a)\n" 13869 " , b(b)\n" 13870 " , c(c)\n" 13871 "{\n" 13872 "}", 13873 Style); 13874 verifyFormat("SomeClass::Constructor()\n" 13875 " : a(a)\n" 13876 "{\n" 13877 " foo();\n" 13878 " bar();\n" 13879 "}", 13880 Style); 13881 13882 // Access specifiers should be aligned left. 13883 verifyFormat("class C {\n" 13884 "public:\n" 13885 " int i;\n" 13886 "};", 13887 Style); 13888 13889 // Do not align comments. 13890 verifyFormat("int a; // Do not\n" 13891 "double b; // align comments.", 13892 Style); 13893 13894 // Do not align operands. 13895 EXPECT_EQ("ASSERT(aaaa\n" 13896 " || bbbb);", 13897 format("ASSERT ( aaaa\n||bbbb);", Style)); 13898 13899 // Accept input's line breaks. 13900 EXPECT_EQ("if (aaaaaaaaaaaaaaa\n" 13901 " || bbbbbbbbbbbbbbb) {\n" 13902 " i++;\n" 13903 "}", 13904 format("if (aaaaaaaaaaaaaaa\n" 13905 "|| bbbbbbbbbbbbbbb) { i++; }", 13906 Style)); 13907 EXPECT_EQ("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) {\n" 13908 " i++;\n" 13909 "}", 13910 format("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) { i++; }", Style)); 13911 13912 // Don't automatically break all macro definitions (llvm.org/PR17842). 13913 verifyFormat("#define aNumber 10", Style); 13914 // However, generally keep the line breaks that the user authored. 13915 EXPECT_EQ("#define aNumber \\\n" 13916 " 10", 13917 format("#define aNumber \\\n" 13918 " 10", 13919 Style)); 13920 13921 // Keep empty and one-element array literals on a single line. 13922 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[]\n" 13923 " copyItems:YES];", 13924 format("NSArray*a=[[NSArray alloc] initWithArray:@[]\n" 13925 "copyItems:YES];", 13926 Style)); 13927 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\" ]\n" 13928 " copyItems:YES];", 13929 format("NSArray*a=[[NSArray alloc]initWithArray:@[ @\"a\" ]\n" 13930 " copyItems:YES];", 13931 Style)); 13932 // FIXME: This does not seem right, there should be more indentation before 13933 // the array literal's entries. Nested blocks have the same problem. 13934 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[\n" 13935 " @\"a\",\n" 13936 " @\"a\"\n" 13937 "]\n" 13938 " copyItems:YES];", 13939 format("NSArray* a = [[NSArray alloc] initWithArray:@[\n" 13940 " @\"a\",\n" 13941 " @\"a\"\n" 13942 " ]\n" 13943 " copyItems:YES];", 13944 Style)); 13945 EXPECT_EQ( 13946 "NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n" 13947 " copyItems:YES];", 13948 format("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n" 13949 " copyItems:YES];", 13950 Style)); 13951 13952 verifyFormat("[self.a b:c c:d];", Style); 13953 EXPECT_EQ("[self.a b:c\n" 13954 " c:d];", 13955 format("[self.a b:c\n" 13956 "c:d];", 13957 Style)); 13958 } 13959 13960 TEST_F(FormatTest, FormatsLambdas) { 13961 verifyFormat("int c = [b]() mutable { return [&b] { return b++; }(); }();\n"); 13962 verifyFormat( 13963 "int c = [b]() mutable noexcept { return [&b] { return b++; }(); }();\n"); 13964 verifyFormat("int c = [&] { [=] { return b++; }(); }();\n"); 13965 verifyFormat("int c = [&, &a, a] { [=, c, &d] { return b++; }(); }();\n"); 13966 verifyFormat("int c = [&a, &a, a] { [=, a, b, &c] { return b++; }(); }();\n"); 13967 verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] { return b++; }(); }}\n"); 13968 verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] {}(); }}\n"); 13969 verifyFormat("auto c = [a = [b = 42] {}] {};\n"); 13970 verifyFormat("auto c = [a = &i + 10, b = [] {}] {};\n"); 13971 verifyFormat("int x = f(*+[] {});"); 13972 verifyFormat("void f() {\n" 13973 " other(x.begin(), x.end(), [&](int, int) { return 1; });\n" 13974 "}\n"); 13975 verifyFormat("void f() {\n" 13976 " other(x.begin(), //\n" 13977 " x.end(), //\n" 13978 " [&](int, int) { return 1; });\n" 13979 "}\n"); 13980 verifyFormat("void f() {\n" 13981 " other.other.other.other.other(\n" 13982 " x.begin(), x.end(),\n" 13983 " [something, rather](int, int, int, int, int, int, int) { " 13984 "return 1; });\n" 13985 "}\n"); 13986 verifyFormat( 13987 "void f() {\n" 13988 " other.other.other.other.other(\n" 13989 " x.begin(), x.end(),\n" 13990 " [something, rather](int, int, int, int, int, int, int) {\n" 13991 " //\n" 13992 " });\n" 13993 "}\n"); 13994 verifyFormat("SomeFunction([]() { // A cool function...\n" 13995 " return 43;\n" 13996 "});"); 13997 EXPECT_EQ("SomeFunction([]() {\n" 13998 "#define A a\n" 13999 " return 43;\n" 14000 "});", 14001 format("SomeFunction([](){\n" 14002 "#define A a\n" 14003 "return 43;\n" 14004 "});")); 14005 verifyFormat("void f() {\n" 14006 " SomeFunction([](decltype(x), A *a) {});\n" 14007 "}"); 14008 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 14009 " [](const aaaaaaaaaa &a) { return a; });"); 14010 verifyFormat("string abc = SomeFunction(aaaaaaaaaaaaa, aaaaa, []() {\n" 14011 " SomeOtherFunctioooooooooooooooooooooooooon();\n" 14012 "});"); 14013 verifyFormat("Constructor()\n" 14014 " : Field([] { // comment\n" 14015 " int i;\n" 14016 " }) {}"); 14017 verifyFormat("auto my_lambda = [](const string &some_parameter) {\n" 14018 " return some_parameter.size();\n" 14019 "};"); 14020 verifyFormat("std::function<std::string(const std::string &)> my_lambda =\n" 14021 " [](const string &s) { return s; };"); 14022 verifyFormat("int i = aaaaaa ? 1 //\n" 14023 " : [] {\n" 14024 " return 2; //\n" 14025 " }();"); 14026 verifyFormat("llvm::errs() << \"number of twos is \"\n" 14027 " << std::count_if(v.begin(), v.end(), [](int x) {\n" 14028 " return x == 2; // force break\n" 14029 " });"); 14030 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 14031 " [=](int iiiiiiiiiiii) {\n" 14032 " return aaaaaaaaaaaaaaaaaaaaaaa !=\n" 14033 " aaaaaaaaaaaaaaaaaaaaaaa;\n" 14034 " });", 14035 getLLVMStyleWithColumns(60)); 14036 verifyFormat("SomeFunction({[&] {\n" 14037 " // comment\n" 14038 " },\n" 14039 " [&] {\n" 14040 " // comment\n" 14041 " }});"); 14042 verifyFormat("SomeFunction({[&] {\n" 14043 " // comment\n" 14044 "}});"); 14045 verifyFormat( 14046 "virtual aaaaaaaaaaaaaaaa(\n" 14047 " std::function<bool()> bbbbbbbbbbbb = [&]() { return true; },\n" 14048 " aaaaa aaaaaaaaa);"); 14049 14050 // Lambdas with return types. 14051 verifyFormat("int c = []() -> int { return 2; }();\n"); 14052 verifyFormat("int c = []() -> int * { return 2; }();\n"); 14053 verifyFormat("int c = []() -> vector<int> { return {2}; }();\n"); 14054 verifyFormat("Foo([]() -> std::vector<int> { return {2}; }());"); 14055 verifyGoogleFormat("auto a = [&b, c](D* d) -> D* {};"); 14056 verifyGoogleFormat("auto a = [&b, c](D* d) -> pair<D*, D*> {};"); 14057 verifyGoogleFormat("auto a = [&b, c](D* d) -> D& {};"); 14058 verifyGoogleFormat("auto a = [&b, c](D* d) -> const D* {};"); 14059 verifyFormat("[a, a]() -> a<1> {};"); 14060 verifyFormat("[]() -> foo<5 + 2> { return {}; };"); 14061 verifyFormat("[]() -> foo<5 - 2> { return {}; };"); 14062 verifyFormat("[]() -> foo<5 / 2> { return {}; };"); 14063 verifyFormat("[]() -> foo<5 * 2> { return {}; };"); 14064 verifyFormat("[]() -> foo<5 % 2> { return {}; };"); 14065 verifyFormat("[]() -> foo<5 << 2> { return {}; };"); 14066 verifyFormat("[]() -> foo<!5> { return {}; };"); 14067 verifyFormat("[]() -> foo<~5> { return {}; };"); 14068 verifyFormat("[]() -> foo<5 | 2> { return {}; };"); 14069 verifyFormat("[]() -> foo<5 || 2> { return {}; };"); 14070 verifyFormat("[]() -> foo<5 & 2> { return {}; };"); 14071 verifyFormat("[]() -> foo<5 && 2> { return {}; };"); 14072 verifyFormat("[]() -> foo<5 == 2> { return {}; };"); 14073 verifyFormat("[]() -> foo<5 != 2> { return {}; };"); 14074 verifyFormat("[]() -> foo<5 >= 2> { return {}; };"); 14075 verifyFormat("[]() -> foo<5 <= 2> { return {}; };"); 14076 verifyFormat("[]() -> foo<5 < 2> { return {}; };"); 14077 verifyFormat("[]() -> foo<2 ? 1 : 0> { return {}; };"); 14078 verifyFormat("namespace bar {\n" 14079 "// broken:\n" 14080 "auto foo{[]() -> foo<5 + 2> { return {}; }};\n" 14081 "} // namespace bar"); 14082 verifyFormat("namespace bar {\n" 14083 "// broken:\n" 14084 "auto foo{[]() -> foo<5 - 2> { return {}; }};\n" 14085 "} // namespace bar"); 14086 verifyFormat("namespace bar {\n" 14087 "// broken:\n" 14088 "auto foo{[]() -> foo<5 / 2> { return {}; }};\n" 14089 "} // namespace bar"); 14090 verifyFormat("namespace bar {\n" 14091 "// broken:\n" 14092 "auto foo{[]() -> foo<5 * 2> { return {}; }};\n" 14093 "} // namespace bar"); 14094 verifyFormat("namespace bar {\n" 14095 "// broken:\n" 14096 "auto foo{[]() -> foo<5 % 2> { return {}; }};\n" 14097 "} // namespace bar"); 14098 verifyFormat("namespace bar {\n" 14099 "// broken:\n" 14100 "auto foo{[]() -> foo<5 << 2> { return {}; }};\n" 14101 "} // namespace bar"); 14102 verifyFormat("namespace bar {\n" 14103 "// broken:\n" 14104 "auto foo{[]() -> foo<!5> { return {}; }};\n" 14105 "} // namespace bar"); 14106 verifyFormat("namespace bar {\n" 14107 "// broken:\n" 14108 "auto foo{[]() -> foo<~5> { return {}; }};\n" 14109 "} // namespace bar"); 14110 verifyFormat("namespace bar {\n" 14111 "// broken:\n" 14112 "auto foo{[]() -> foo<5 | 2> { return {}; }};\n" 14113 "} // namespace bar"); 14114 verifyFormat("namespace bar {\n" 14115 "// broken:\n" 14116 "auto foo{[]() -> foo<5 || 2> { return {}; }};\n" 14117 "} // namespace bar"); 14118 verifyFormat("namespace bar {\n" 14119 "// broken:\n" 14120 "auto foo{[]() -> foo<5 & 2> { return {}; }};\n" 14121 "} // namespace bar"); 14122 verifyFormat("namespace bar {\n" 14123 "// broken:\n" 14124 "auto foo{[]() -> foo<5 && 2> { return {}; }};\n" 14125 "} // namespace bar"); 14126 verifyFormat("namespace bar {\n" 14127 "// broken:\n" 14128 "auto foo{[]() -> foo<5 == 2> { return {}; }};\n" 14129 "} // namespace bar"); 14130 verifyFormat("namespace bar {\n" 14131 "// broken:\n" 14132 "auto foo{[]() -> foo<5 != 2> { return {}; }};\n" 14133 "} // namespace bar"); 14134 verifyFormat("namespace bar {\n" 14135 "// broken:\n" 14136 "auto foo{[]() -> foo<5 >= 2> { return {}; }};\n" 14137 "} // namespace bar"); 14138 verifyFormat("namespace bar {\n" 14139 "// broken:\n" 14140 "auto foo{[]() -> foo<5 <= 2> { return {}; }};\n" 14141 "} // namespace bar"); 14142 verifyFormat("namespace bar {\n" 14143 "// broken:\n" 14144 "auto foo{[]() -> foo<5 < 2> { return {}; }};\n" 14145 "} // namespace bar"); 14146 verifyFormat("namespace bar {\n" 14147 "// broken:\n" 14148 "auto foo{[]() -> foo<2 ? 1 : 0> { return {}; }};\n" 14149 "} // namespace bar"); 14150 verifyFormat("[]() -> a<1> {};"); 14151 verifyFormat("[]() -> a<1> { ; };"); 14152 verifyFormat("[]() -> a<1> { ; }();"); 14153 verifyFormat("[a, a]() -> a<true> {};"); 14154 verifyFormat("[]() -> a<true> {};"); 14155 verifyFormat("[]() -> a<true> { ; };"); 14156 verifyFormat("[]() -> a<true> { ; }();"); 14157 verifyFormat("[a, a]() -> a<false> {};"); 14158 verifyFormat("[]() -> a<false> {};"); 14159 verifyFormat("[]() -> a<false> { ; };"); 14160 verifyFormat("[]() -> a<false> { ; }();"); 14161 verifyFormat("auto foo{[]() -> foo<false> { ; }};"); 14162 verifyFormat("namespace bar {\n" 14163 "auto foo{[]() -> foo<false> { ; }};\n" 14164 "} // namespace bar"); 14165 verifyFormat("auto aaaaaaaa = [](int i, // break for some reason\n" 14166 " int j) -> int {\n" 14167 " return ffffffffffffffffffffffffffffffffffffffffffff(i * j);\n" 14168 "};"); 14169 verifyFormat( 14170 "aaaaaaaaaaaaaaaaaaaaaa(\n" 14171 " [](aaaaaaaaaaaaaaaaaaaaaaaaaaa &aaa) -> aaaaaaaaaaaaaaaa {\n" 14172 " return aaaaaaaaaaaaaaaaa;\n" 14173 " });", 14174 getLLVMStyleWithColumns(70)); 14175 verifyFormat("[]() //\n" 14176 " -> int {\n" 14177 " return 1; //\n" 14178 "};"); 14179 verifyFormat("[]() -> Void<T...> {};"); 14180 verifyFormat("[a, b]() -> Tuple<T...> { return {}; };"); 14181 14182 // Lambdas with explicit template argument lists. 14183 verifyFormat( 14184 "auto L = []<template <typename> class T, class U>(T<U> &&a) {};\n"); 14185 14186 // Multiple lambdas in the same parentheses change indentation rules. These 14187 // lambdas are forced to start on new lines. 14188 verifyFormat("SomeFunction(\n" 14189 " []() {\n" 14190 " //\n" 14191 " },\n" 14192 " []() {\n" 14193 " //\n" 14194 " });"); 14195 14196 // A lambda passed as arg0 is always pushed to the next line. 14197 verifyFormat("SomeFunction(\n" 14198 " [this] {\n" 14199 " //\n" 14200 " },\n" 14201 " 1);\n"); 14202 14203 // A multi-line lambda passed as arg1 forces arg0 to be pushed out, just like 14204 // the arg0 case above. 14205 auto Style = getGoogleStyle(); 14206 Style.BinPackArguments = false; 14207 verifyFormat("SomeFunction(\n" 14208 " a,\n" 14209 " [this] {\n" 14210 " //\n" 14211 " },\n" 14212 " b);\n", 14213 Style); 14214 verifyFormat("SomeFunction(\n" 14215 " a,\n" 14216 " [this] {\n" 14217 " //\n" 14218 " },\n" 14219 " b);\n"); 14220 14221 // A lambda with a very long line forces arg0 to be pushed out irrespective of 14222 // the BinPackArguments value (as long as the code is wide enough). 14223 verifyFormat( 14224 "something->SomeFunction(\n" 14225 " a,\n" 14226 " [this] {\n" 14227 " " 14228 "D0000000000000000000000000000000000000000000000000000000000001();\n" 14229 " },\n" 14230 " b);\n"); 14231 14232 // A multi-line lambda is pulled up as long as the introducer fits on the 14233 // previous line and there are no further args. 14234 verifyFormat("function(1, [this, that] {\n" 14235 " //\n" 14236 "});\n"); 14237 verifyFormat("function([this, that] {\n" 14238 " //\n" 14239 "});\n"); 14240 // FIXME: this format is not ideal and we should consider forcing the first 14241 // arg onto its own line. 14242 verifyFormat("function(a, b, c, //\n" 14243 " d, [this, that] {\n" 14244 " //\n" 14245 " });\n"); 14246 14247 // Multiple lambdas are treated correctly even when there is a short arg0. 14248 verifyFormat("SomeFunction(\n" 14249 " 1,\n" 14250 " [this] {\n" 14251 " //\n" 14252 " },\n" 14253 " [this] {\n" 14254 " //\n" 14255 " },\n" 14256 " 1);\n"); 14257 14258 // More complex introducers. 14259 verifyFormat("return [i, args...] {};"); 14260 14261 // Not lambdas. 14262 verifyFormat("constexpr char hello[]{\"hello\"};"); 14263 verifyFormat("double &operator[](int i) { return 0; }\n" 14264 "int i;"); 14265 verifyFormat("std::unique_ptr<int[]> foo() {}"); 14266 verifyFormat("int i = a[a][a]->f();"); 14267 verifyFormat("int i = (*b)[a]->f();"); 14268 14269 // Other corner cases. 14270 verifyFormat("void f() {\n" 14271 " bar([]() {} // Did not respect SpacesBeforeTrailingComments\n" 14272 " );\n" 14273 "}"); 14274 14275 // Lambdas created through weird macros. 14276 verifyFormat("void f() {\n" 14277 " MACRO((const AA &a) { return 1; });\n" 14278 " MACRO((AA &a) { return 1; });\n" 14279 "}"); 14280 14281 verifyFormat("if (blah_blah(whatever, whatever, [] {\n" 14282 " doo_dah();\n" 14283 " doo_dah();\n" 14284 " })) {\n" 14285 "}"); 14286 verifyFormat("if constexpr (blah_blah(whatever, whatever, [] {\n" 14287 " doo_dah();\n" 14288 " doo_dah();\n" 14289 " })) {\n" 14290 "}"); 14291 verifyFormat("if CONSTEXPR (blah_blah(whatever, whatever, [] {\n" 14292 " doo_dah();\n" 14293 " doo_dah();\n" 14294 " })) {\n" 14295 "}"); 14296 verifyFormat("auto lambda = []() {\n" 14297 " int a = 2\n" 14298 "#if A\n" 14299 " + 2\n" 14300 "#endif\n" 14301 " ;\n" 14302 "};"); 14303 14304 // Lambdas with complex multiline introducers. 14305 verifyFormat( 14306 "aaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 14307 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]()\n" 14308 " -> ::std::unordered_set<\n" 14309 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> {\n" 14310 " //\n" 14311 " });"); 14312 14313 FormatStyle DoNotMerge = getLLVMStyle(); 14314 DoNotMerge.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None; 14315 verifyFormat("auto c = []() {\n" 14316 " return b;\n" 14317 "};", 14318 "auto c = []() { return b; };", DoNotMerge); 14319 verifyFormat("auto c = []() {\n" 14320 "};", 14321 " auto c = []() {};", DoNotMerge); 14322 14323 FormatStyle MergeEmptyOnly = getLLVMStyle(); 14324 MergeEmptyOnly.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Empty; 14325 verifyFormat("auto c = []() {\n" 14326 " return b;\n" 14327 "};", 14328 "auto c = []() {\n" 14329 " return b;\n" 14330 " };", 14331 MergeEmptyOnly); 14332 verifyFormat("auto c = []() {};", 14333 "auto c = []() {\n" 14334 "};", 14335 MergeEmptyOnly); 14336 14337 FormatStyle MergeInline = getLLVMStyle(); 14338 MergeInline.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Inline; 14339 verifyFormat("auto c = []() {\n" 14340 " return b;\n" 14341 "};", 14342 "auto c = []() { return b; };", MergeInline); 14343 verifyFormat("function([]() { return b; })", "function([]() { return b; })", 14344 MergeInline); 14345 verifyFormat("function([]() { return b; }, a)", 14346 "function([]() { return b; }, a)", MergeInline); 14347 verifyFormat("function(a, []() { return b; })", 14348 "function(a, []() { return b; })", MergeInline); 14349 14350 // Check option "BraceWrapping.BeforeLambdaBody" and different state of 14351 // AllowShortLambdasOnASingleLine 14352 FormatStyle LLVMWithBeforeLambdaBody = getLLVMStyle(); 14353 LLVMWithBeforeLambdaBody.BreakBeforeBraces = FormatStyle::BS_Custom; 14354 LLVMWithBeforeLambdaBody.BraceWrapping.BeforeLambdaBody = true; 14355 LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine = 14356 FormatStyle::ShortLambdaStyle::SLS_None; 14357 verifyFormat("FctWithOneNestedLambdaInline_SLS_None(\n" 14358 " []()\n" 14359 " {\n" 14360 " return 17;\n" 14361 " });", 14362 LLVMWithBeforeLambdaBody); 14363 verifyFormat("FctWithOneNestedLambdaEmpty_SLS_None(\n" 14364 " []()\n" 14365 " {\n" 14366 " });", 14367 LLVMWithBeforeLambdaBody); 14368 verifyFormat("auto fct_SLS_None = []()\n" 14369 "{\n" 14370 " return 17;\n" 14371 "};", 14372 LLVMWithBeforeLambdaBody); 14373 verifyFormat("TwoNestedLambdas_SLS_None(\n" 14374 " []()\n" 14375 " {\n" 14376 " return Call(\n" 14377 " []()\n" 14378 " {\n" 14379 " return 17;\n" 14380 " });\n" 14381 " });", 14382 LLVMWithBeforeLambdaBody); 14383 verifyFormat("void Fct()\n" 14384 "{\n" 14385 " return {[]()\n" 14386 " {\n" 14387 " return 17;\n" 14388 " }};\n" 14389 "}", 14390 LLVMWithBeforeLambdaBody); 14391 14392 LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine = 14393 FormatStyle::ShortLambdaStyle::SLS_Empty; 14394 verifyFormat("FctWithOneNestedLambdaInline_SLS_Empty(\n" 14395 " []()\n" 14396 " {\n" 14397 " return 17;\n" 14398 " });", 14399 LLVMWithBeforeLambdaBody); 14400 verifyFormat("FctWithOneNestedLambdaEmpty_SLS_Empty([]() {});", 14401 LLVMWithBeforeLambdaBody); 14402 verifyFormat("FctWithOneNestedLambdaEmptyInsideAVeryVeryVeryVeryVeryVeryVeryL" 14403 "ongFunctionName_SLS_Empty(\n" 14404 " []() {});", 14405 LLVMWithBeforeLambdaBody); 14406 verifyFormat("FctWithMultipleParams_SLS_Empty(A, B,\n" 14407 " []()\n" 14408 " {\n" 14409 " return 17;\n" 14410 " });", 14411 LLVMWithBeforeLambdaBody); 14412 verifyFormat("auto fct_SLS_Empty = []()\n" 14413 "{\n" 14414 " return 17;\n" 14415 "};", 14416 LLVMWithBeforeLambdaBody); 14417 verifyFormat("TwoNestedLambdas_SLS_Empty(\n" 14418 " []()\n" 14419 " {\n" 14420 " return Call([]() {});\n" 14421 " });", 14422 LLVMWithBeforeLambdaBody); 14423 verifyFormat("TwoNestedLambdas_SLS_Empty(A,\n" 14424 " []()\n" 14425 " {\n" 14426 " return Call([]() {});\n" 14427 " });", 14428 LLVMWithBeforeLambdaBody); 14429 verifyFormat( 14430 "FctWithLongLineInLambda_SLS_Empty(\n" 14431 " []()\n" 14432 " {\n" 14433 " return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n" 14434 " AndShouldNotBeConsiderAsInline,\n" 14435 " LambdaBodyMustBeBreak);\n" 14436 " });", 14437 LLVMWithBeforeLambdaBody); 14438 14439 LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine = 14440 FormatStyle::ShortLambdaStyle::SLS_Inline; 14441 verifyFormat("FctWithOneNestedLambdaInline_SLS_Inline([]() { return 17; });", 14442 LLVMWithBeforeLambdaBody); 14443 verifyFormat("FctWithOneNestedLambdaEmpty_SLS_Inline([]() {});", 14444 LLVMWithBeforeLambdaBody); 14445 verifyFormat("auto fct_SLS_Inline = []()\n" 14446 "{\n" 14447 " return 17;\n" 14448 "};", 14449 LLVMWithBeforeLambdaBody); 14450 verifyFormat("TwoNestedLambdas_SLS_Inline([]() { return Call([]() { return " 14451 "17; }); });", 14452 LLVMWithBeforeLambdaBody); 14453 verifyFormat( 14454 "FctWithLongLineInLambda_SLS_Inline(\n" 14455 " []()\n" 14456 " {\n" 14457 " return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n" 14458 " AndShouldNotBeConsiderAsInline,\n" 14459 " LambdaBodyMustBeBreak);\n" 14460 " });", 14461 LLVMWithBeforeLambdaBody); 14462 verifyFormat("FctWithMultipleParams_SLS_Inline(" 14463 "VeryLongParameterThatShouldAskToBeOnMultiLine,\n" 14464 " []() { return 17; });", 14465 LLVMWithBeforeLambdaBody); 14466 verifyFormat( 14467 "FctWithMultipleParams_SLS_Inline(FirstParam, []() { return 17; });", 14468 LLVMWithBeforeLambdaBody); 14469 14470 LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine = 14471 FormatStyle::ShortLambdaStyle::SLS_All; 14472 verifyFormat("FctWithOneNestedLambdaInline_SLS_All([]() { return 17; });", 14473 LLVMWithBeforeLambdaBody); 14474 verifyFormat("FctWithOneNestedLambdaEmpty_SLS_All([]() {});", 14475 LLVMWithBeforeLambdaBody); 14476 verifyFormat("auto fct_SLS_All = []() { return 17; };", 14477 LLVMWithBeforeLambdaBody); 14478 verifyFormat("FctWithOneParam_SLS_All(\n" 14479 " []()\n" 14480 " {\n" 14481 " // A cool function...\n" 14482 " return 43;\n" 14483 " });", 14484 LLVMWithBeforeLambdaBody); 14485 verifyFormat("FctWithMultipleParams_SLS_All(" 14486 "VeryLongParameterThatShouldAskToBeOnMultiLine,\n" 14487 " []() { return 17; });", 14488 LLVMWithBeforeLambdaBody); 14489 verifyFormat("FctWithMultipleParams_SLS_All(A, []() { return 17; });", 14490 LLVMWithBeforeLambdaBody); 14491 verifyFormat("FctWithMultipleParams_SLS_All(A, B, []() { return 17; });", 14492 LLVMWithBeforeLambdaBody); 14493 verifyFormat( 14494 "FctWithLongLineInLambda_SLS_All(\n" 14495 " []()\n" 14496 " {\n" 14497 " return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n" 14498 " AndShouldNotBeConsiderAsInline,\n" 14499 " LambdaBodyMustBeBreak);\n" 14500 " });", 14501 LLVMWithBeforeLambdaBody); 14502 verifyFormat( 14503 "auto fct_SLS_All = []()\n" 14504 "{\n" 14505 " return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n" 14506 " AndShouldNotBeConsiderAsInline,\n" 14507 " LambdaBodyMustBeBreak);\n" 14508 "};", 14509 LLVMWithBeforeLambdaBody); 14510 LLVMWithBeforeLambdaBody.BinPackParameters = false; 14511 verifyFormat("FctAllOnSameLine_SLS_All([]() { return S; }, Fst, Second);", 14512 LLVMWithBeforeLambdaBody); 14513 verifyFormat( 14514 "FctWithLongLineInLambda_SLS_All([]() { return SomeValueNotSoLong; },\n" 14515 " FirstParam,\n" 14516 " SecondParam,\n" 14517 " ThirdParam,\n" 14518 " FourthParam);", 14519 LLVMWithBeforeLambdaBody); 14520 verifyFormat("FctWithLongLineInLambda_SLS_All(\n" 14521 " []() { return " 14522 "SomeValueVeryVeryVeryVeryVeryVeryVeryVeryVeryLong; },\n" 14523 " FirstParam,\n" 14524 " SecondParam,\n" 14525 " ThirdParam,\n" 14526 " FourthParam);", 14527 LLVMWithBeforeLambdaBody); 14528 verifyFormat( 14529 "FctWithLongLineInLambda_SLS_All(FirstParam,\n" 14530 " SecondParam,\n" 14531 " ThirdParam,\n" 14532 " FourthParam,\n" 14533 " []() { return SomeValueNotSoLong; });", 14534 LLVMWithBeforeLambdaBody); 14535 verifyFormat("FctWithLongLineInLambda_SLS_All(\n" 14536 " []()\n" 14537 " {\n" 14538 " return " 14539 "HereAVeryLongLineThatWillBeFormattedOnMultipleLineAndShouldNotB" 14540 "eConsiderAsInline;\n" 14541 " });", 14542 LLVMWithBeforeLambdaBody); 14543 verifyFormat( 14544 "FctWithLongLineInLambda_SLS_All(\n" 14545 " []()\n" 14546 " {\n" 14547 " return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n" 14548 " AndShouldNotBeConsiderAsInline,\n" 14549 " LambdaBodyMustBeBreak);\n" 14550 " });", 14551 LLVMWithBeforeLambdaBody); 14552 verifyFormat("FctWithTwoParams_SLS_All(\n" 14553 " []()\n" 14554 " {\n" 14555 " // A cool function...\n" 14556 " return 43;\n" 14557 " },\n" 14558 " 87);", 14559 LLVMWithBeforeLambdaBody); 14560 verifyFormat("FctWithTwoParams_SLS_All([]() { return 43; }, 87);", 14561 LLVMWithBeforeLambdaBody); 14562 verifyFormat("FctWithOneNestedLambdas_SLS_All([]() { return 17; });", 14563 LLVMWithBeforeLambdaBody); 14564 verifyFormat( 14565 "TwoNestedLambdas_SLS_All([]() { return Call([]() { return 17; }); });", 14566 LLVMWithBeforeLambdaBody); 14567 verifyFormat("TwoNestedLambdas_SLS_All([]() { return Call([]() { return 17; " 14568 "}); }, x);", 14569 LLVMWithBeforeLambdaBody); 14570 verifyFormat("TwoNestedLambdas_SLS_All(\n" 14571 " []()\n" 14572 " {\n" 14573 " // A cool function...\n" 14574 " return Call([]() { return 17; });\n" 14575 " });", 14576 LLVMWithBeforeLambdaBody); 14577 verifyFormat("TwoNestedLambdas_SLS_All(\n" 14578 " []()\n" 14579 " {\n" 14580 " return Call(\n" 14581 " []()\n" 14582 " {\n" 14583 " // A cool function...\n" 14584 " return 17;\n" 14585 " });\n" 14586 " });", 14587 LLVMWithBeforeLambdaBody); 14588 } 14589 14590 TEST_F(FormatTest, EmptyLinesInLambdas) { 14591 verifyFormat("auto lambda = []() {\n" 14592 " x(); //\n" 14593 "};", 14594 "auto lambda = []() {\n" 14595 "\n" 14596 " x(); //\n" 14597 "\n" 14598 "};"); 14599 } 14600 14601 TEST_F(FormatTest, FormatsBlocks) { 14602 FormatStyle ShortBlocks = getLLVMStyle(); 14603 ShortBlocks.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always; 14604 verifyFormat("int (^Block)(int, int);", ShortBlocks); 14605 verifyFormat("int (^Block1)(int, int) = ^(int i, int j)", ShortBlocks); 14606 verifyFormat("void (^block)(int) = ^(id test) { int i; };", ShortBlocks); 14607 verifyFormat("void (^block)(int) = ^(int test) { int i; };", ShortBlocks); 14608 verifyFormat("void (^block)(int) = ^id(int test) { int i; };", ShortBlocks); 14609 verifyFormat("void (^block)(int) = ^int(int test) { int i; };", ShortBlocks); 14610 14611 verifyFormat("foo(^{ bar(); });", ShortBlocks); 14612 verifyFormat("foo(a, ^{ bar(); });", ShortBlocks); 14613 verifyFormat("{ void (^block)(Object *x); }", ShortBlocks); 14614 14615 verifyFormat("[operation setCompletionBlock:^{\n" 14616 " [self onOperationDone];\n" 14617 "}];"); 14618 verifyFormat("int i = {[operation setCompletionBlock:^{\n" 14619 " [self onOperationDone];\n" 14620 "}]};"); 14621 verifyFormat("[operation setCompletionBlock:^(int *i) {\n" 14622 " f();\n" 14623 "}];"); 14624 verifyFormat("int a = [operation block:^int(int *i) {\n" 14625 " return 1;\n" 14626 "}];"); 14627 verifyFormat("[myObject doSomethingWith:arg1\n" 14628 " aaa:^int(int *a) {\n" 14629 " return 1;\n" 14630 " }\n" 14631 " bbb:f(a * bbbbbbbb)];"); 14632 14633 verifyFormat("[operation setCompletionBlock:^{\n" 14634 " [self.delegate newDataAvailable];\n" 14635 "}];", 14636 getLLVMStyleWithColumns(60)); 14637 verifyFormat("dispatch_async(_fileIOQueue, ^{\n" 14638 " NSString *path = [self sessionFilePath];\n" 14639 " if (path) {\n" 14640 " // ...\n" 14641 " }\n" 14642 "});"); 14643 verifyFormat("[[SessionService sharedService]\n" 14644 " loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 14645 " if (window) {\n" 14646 " [self windowDidLoad:window];\n" 14647 " } else {\n" 14648 " [self errorLoadingWindow];\n" 14649 " }\n" 14650 " }];"); 14651 verifyFormat("void (^largeBlock)(void) = ^{\n" 14652 " // ...\n" 14653 "};\n", 14654 getLLVMStyleWithColumns(40)); 14655 verifyFormat("[[SessionService sharedService]\n" 14656 " loadWindowWithCompletionBlock: //\n" 14657 " ^(SessionWindow *window) {\n" 14658 " if (window) {\n" 14659 " [self windowDidLoad:window];\n" 14660 " } else {\n" 14661 " [self errorLoadingWindow];\n" 14662 " }\n" 14663 " }];", 14664 getLLVMStyleWithColumns(60)); 14665 verifyFormat("[myObject doSomethingWith:arg1\n" 14666 " firstBlock:^(Foo *a) {\n" 14667 " // ...\n" 14668 " int i;\n" 14669 " }\n" 14670 " secondBlock:^(Bar *b) {\n" 14671 " // ...\n" 14672 " int i;\n" 14673 " }\n" 14674 " thirdBlock:^Foo(Bar *b) {\n" 14675 " // ...\n" 14676 " int i;\n" 14677 " }];"); 14678 verifyFormat("[myObject doSomethingWith:arg1\n" 14679 " firstBlock:-1\n" 14680 " secondBlock:^(Bar *b) {\n" 14681 " // ...\n" 14682 " int i;\n" 14683 " }];"); 14684 14685 verifyFormat("f(^{\n" 14686 " @autoreleasepool {\n" 14687 " if (a) {\n" 14688 " g();\n" 14689 " }\n" 14690 " }\n" 14691 "});"); 14692 verifyFormat("Block b = ^int *(A *a, B *b) {}"); 14693 verifyFormat("BOOL (^aaa)(void) = ^BOOL {\n" 14694 "};"); 14695 14696 FormatStyle FourIndent = getLLVMStyle(); 14697 FourIndent.ObjCBlockIndentWidth = 4; 14698 verifyFormat("[operation setCompletionBlock:^{\n" 14699 " [self onOperationDone];\n" 14700 "}];", 14701 FourIndent); 14702 } 14703 14704 TEST_F(FormatTest, FormatsBlocksWithZeroColumnWidth) { 14705 FormatStyle ZeroColumn = getLLVMStyle(); 14706 ZeroColumn.ColumnLimit = 0; 14707 14708 verifyFormat("[[SessionService sharedService] " 14709 "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 14710 " if (window) {\n" 14711 " [self windowDidLoad:window];\n" 14712 " } else {\n" 14713 " [self errorLoadingWindow];\n" 14714 " }\n" 14715 "}];", 14716 ZeroColumn); 14717 EXPECT_EQ("[[SessionService sharedService]\n" 14718 " loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 14719 " if (window) {\n" 14720 " [self windowDidLoad:window];\n" 14721 " } else {\n" 14722 " [self errorLoadingWindow];\n" 14723 " }\n" 14724 " }];", 14725 format("[[SessionService sharedService]\n" 14726 "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 14727 " if (window) {\n" 14728 " [self windowDidLoad:window];\n" 14729 " } else {\n" 14730 " [self errorLoadingWindow];\n" 14731 " }\n" 14732 "}];", 14733 ZeroColumn)); 14734 verifyFormat("[myObject doSomethingWith:arg1\n" 14735 " firstBlock:^(Foo *a) {\n" 14736 " // ...\n" 14737 " int i;\n" 14738 " }\n" 14739 " secondBlock:^(Bar *b) {\n" 14740 " // ...\n" 14741 " int i;\n" 14742 " }\n" 14743 " thirdBlock:^Foo(Bar *b) {\n" 14744 " // ...\n" 14745 " int i;\n" 14746 " }];", 14747 ZeroColumn); 14748 verifyFormat("f(^{\n" 14749 " @autoreleasepool {\n" 14750 " if (a) {\n" 14751 " g();\n" 14752 " }\n" 14753 " }\n" 14754 "});", 14755 ZeroColumn); 14756 verifyFormat("void (^largeBlock)(void) = ^{\n" 14757 " // ...\n" 14758 "};", 14759 ZeroColumn); 14760 14761 ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always; 14762 EXPECT_EQ("void (^largeBlock)(void) = ^{ int i; };", 14763 format("void (^largeBlock)(void) = ^{ int i; };", ZeroColumn)); 14764 ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Never; 14765 EXPECT_EQ("void (^largeBlock)(void) = ^{\n" 14766 " int i;\n" 14767 "};", 14768 format("void (^largeBlock)(void) = ^{ int i; };", ZeroColumn)); 14769 } 14770 14771 TEST_F(FormatTest, SupportsCRLF) { 14772 EXPECT_EQ("int a;\r\n" 14773 "int b;\r\n" 14774 "int c;\r\n", 14775 format("int a;\r\n" 14776 " int b;\r\n" 14777 " int c;\r\n", 14778 getLLVMStyle())); 14779 EXPECT_EQ("int a;\r\n" 14780 "int b;\r\n" 14781 "int c;\r\n", 14782 format("int a;\r\n" 14783 " int b;\n" 14784 " int c;\r\n", 14785 getLLVMStyle())); 14786 EXPECT_EQ("int a;\n" 14787 "int b;\n" 14788 "int c;\n", 14789 format("int a;\r\n" 14790 " int b;\n" 14791 " int c;\n", 14792 getLLVMStyle())); 14793 EXPECT_EQ("\"aaaaaaa \"\r\n" 14794 "\"bbbbbbb\";\r\n", 14795 format("\"aaaaaaa bbbbbbb\";\r\n", getLLVMStyleWithColumns(10))); 14796 EXPECT_EQ("#define A \\\r\n" 14797 " b; \\\r\n" 14798 " c; \\\r\n" 14799 " d;\r\n", 14800 format("#define A \\\r\n" 14801 " b; \\\r\n" 14802 " c; d; \r\n", 14803 getGoogleStyle())); 14804 14805 EXPECT_EQ("/*\r\n" 14806 "multi line block comments\r\n" 14807 "should not introduce\r\n" 14808 "an extra carriage return\r\n" 14809 "*/\r\n", 14810 format("/*\r\n" 14811 "multi line block comments\r\n" 14812 "should not introduce\r\n" 14813 "an extra carriage return\r\n" 14814 "*/\r\n")); 14815 EXPECT_EQ("/*\r\n" 14816 "\r\n" 14817 "*/", 14818 format("/*\r\n" 14819 " \r\r\r\n" 14820 "*/")); 14821 14822 FormatStyle style = getLLVMStyle(); 14823 14824 style.DeriveLineEnding = true; 14825 style.UseCRLF = false; 14826 EXPECT_EQ("union FooBarBazQux {\n" 14827 " int foo;\n" 14828 " int bar;\n" 14829 " int baz;\n" 14830 "};", 14831 format("union FooBarBazQux {\r\n" 14832 " int foo;\n" 14833 " int bar;\r\n" 14834 " int baz;\n" 14835 "};", 14836 style)); 14837 style.UseCRLF = true; 14838 EXPECT_EQ("union FooBarBazQux {\r\n" 14839 " int foo;\r\n" 14840 " int bar;\r\n" 14841 " int baz;\r\n" 14842 "};", 14843 format("union FooBarBazQux {\r\n" 14844 " int foo;\n" 14845 " int bar;\r\n" 14846 " int baz;\n" 14847 "};", 14848 style)); 14849 14850 style.DeriveLineEnding = false; 14851 style.UseCRLF = false; 14852 EXPECT_EQ("union FooBarBazQux {\n" 14853 " int foo;\n" 14854 " int bar;\n" 14855 " int baz;\n" 14856 " int qux;\n" 14857 "};", 14858 format("union FooBarBazQux {\r\n" 14859 " int foo;\n" 14860 " int bar;\r\n" 14861 " int baz;\n" 14862 " int qux;\r\n" 14863 "};", 14864 style)); 14865 style.UseCRLF = true; 14866 EXPECT_EQ("union FooBarBazQux {\r\n" 14867 " int foo;\r\n" 14868 " int bar;\r\n" 14869 " int baz;\r\n" 14870 " int qux;\r\n" 14871 "};", 14872 format("union FooBarBazQux {\r\n" 14873 " int foo;\n" 14874 " int bar;\r\n" 14875 " int baz;\n" 14876 " int qux;\n" 14877 "};", 14878 style)); 14879 14880 style.DeriveLineEnding = true; 14881 style.UseCRLF = false; 14882 EXPECT_EQ("union FooBarBazQux {\r\n" 14883 " int foo;\r\n" 14884 " int bar;\r\n" 14885 " int baz;\r\n" 14886 " int qux;\r\n" 14887 "};", 14888 format("union FooBarBazQux {\r\n" 14889 " int foo;\n" 14890 " int bar;\r\n" 14891 " int baz;\n" 14892 " int qux;\r\n" 14893 "};", 14894 style)); 14895 style.UseCRLF = true; 14896 EXPECT_EQ("union FooBarBazQux {\n" 14897 " int foo;\n" 14898 " int bar;\n" 14899 " int baz;\n" 14900 " int qux;\n" 14901 "};", 14902 format("union FooBarBazQux {\r\n" 14903 " int foo;\n" 14904 " int bar;\r\n" 14905 " int baz;\n" 14906 " int qux;\n" 14907 "};", 14908 style)); 14909 } 14910 14911 TEST_F(FormatTest, MunchSemicolonAfterBlocks) { 14912 verifyFormat("MY_CLASS(C) {\n" 14913 " int i;\n" 14914 " int j;\n" 14915 "};"); 14916 } 14917 14918 TEST_F(FormatTest, ConfigurableContinuationIndentWidth) { 14919 FormatStyle TwoIndent = getLLVMStyleWithColumns(15); 14920 TwoIndent.ContinuationIndentWidth = 2; 14921 14922 EXPECT_EQ("int i =\n" 14923 " longFunction(\n" 14924 " arg);", 14925 format("int i = longFunction(arg);", TwoIndent)); 14926 14927 FormatStyle SixIndent = getLLVMStyleWithColumns(20); 14928 SixIndent.ContinuationIndentWidth = 6; 14929 14930 EXPECT_EQ("int i =\n" 14931 " longFunction(\n" 14932 " arg);", 14933 format("int i = longFunction(arg);", SixIndent)); 14934 } 14935 14936 TEST_F(FormatTest, WrappedClosingParenthesisIndent) { 14937 FormatStyle Style = getLLVMStyle(); 14938 verifyFormat("int Foo::getter(\n" 14939 " //\n" 14940 ") const {\n" 14941 " return foo;\n" 14942 "}", 14943 Style); 14944 verifyFormat("void Foo::setter(\n" 14945 " //\n" 14946 ") {\n" 14947 " foo = 1;\n" 14948 "}", 14949 Style); 14950 } 14951 14952 TEST_F(FormatTest, SpacesInAngles) { 14953 FormatStyle Spaces = getLLVMStyle(); 14954 Spaces.SpacesInAngles = true; 14955 14956 verifyFormat("static_cast< int >(arg);", Spaces); 14957 verifyFormat("template < typename T0, typename T1 > void f() {}", Spaces); 14958 verifyFormat("f< int, float >();", Spaces); 14959 verifyFormat("template <> g() {}", Spaces); 14960 verifyFormat("template < std::vector< int > > f() {}", Spaces); 14961 verifyFormat("std::function< void(int, int) > fct;", Spaces); 14962 verifyFormat("void inFunction() { std::function< void(int, int) > fct; }", 14963 Spaces); 14964 14965 Spaces.Standard = FormatStyle::LS_Cpp03; 14966 Spaces.SpacesInAngles = true; 14967 verifyFormat("A< A< int > >();", Spaces); 14968 14969 Spaces.SpacesInAngles = false; 14970 verifyFormat("A<A<int> >();", Spaces); 14971 14972 Spaces.Standard = FormatStyle::LS_Cpp11; 14973 Spaces.SpacesInAngles = true; 14974 verifyFormat("A< A< int > >();", Spaces); 14975 14976 Spaces.SpacesInAngles = false; 14977 verifyFormat("A<A<int>>();", Spaces); 14978 } 14979 14980 TEST_F(FormatTest, SpaceAfterTemplateKeyword) { 14981 FormatStyle Style = getLLVMStyle(); 14982 Style.SpaceAfterTemplateKeyword = false; 14983 verifyFormat("template<int> void foo();", Style); 14984 } 14985 14986 TEST_F(FormatTest, TripleAngleBrackets) { 14987 verifyFormat("f<<<1, 1>>>();"); 14988 verifyFormat("f<<<1, 1, 1, s>>>();"); 14989 verifyFormat("f<<<a, b, c, d>>>();"); 14990 EXPECT_EQ("f<<<1, 1>>>();", format("f <<< 1, 1 >>> ();")); 14991 verifyFormat("f<param><<<1, 1>>>();"); 14992 verifyFormat("f<1><<<1, 1>>>();"); 14993 EXPECT_EQ("f<param><<<1, 1>>>();", format("f< param > <<< 1, 1 >>> ();")); 14994 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 14995 "aaaaaaaaaaa<<<\n 1, 1>>>();"); 14996 verifyFormat("aaaaaaaaaaaaaaa<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaa>\n" 14997 " <<<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaaaaaa>>>();"); 14998 } 14999 15000 TEST_F(FormatTest, MergeLessLessAtEnd) { 15001 verifyFormat("<<"); 15002 EXPECT_EQ("< < <", format("\\\n<<<")); 15003 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 15004 "aaallvm::outs() <<"); 15005 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 15006 "aaaallvm::outs()\n <<"); 15007 } 15008 15009 TEST_F(FormatTest, HandleUnbalancedImplicitBracesAcrossPPBranches) { 15010 std::string code = "#if A\n" 15011 "#if B\n" 15012 "a.\n" 15013 "#endif\n" 15014 " a = 1;\n" 15015 "#else\n" 15016 "#endif\n" 15017 "#if C\n" 15018 "#else\n" 15019 "#endif\n"; 15020 EXPECT_EQ(code, format(code)); 15021 } 15022 15023 TEST_F(FormatTest, HandleConflictMarkers) { 15024 // Git/SVN conflict markers. 15025 EXPECT_EQ("int a;\n" 15026 "void f() {\n" 15027 " callme(some(parameter1,\n" 15028 "<<<<<<< text by the vcs\n" 15029 " parameter2),\n" 15030 "||||||| text by the vcs\n" 15031 " parameter2),\n" 15032 " parameter3,\n" 15033 "======= text by the vcs\n" 15034 " parameter2, parameter3),\n" 15035 ">>>>>>> text by the vcs\n" 15036 " otherparameter);\n", 15037 format("int a;\n" 15038 "void f() {\n" 15039 " callme(some(parameter1,\n" 15040 "<<<<<<< text by the vcs\n" 15041 " parameter2),\n" 15042 "||||||| text by the vcs\n" 15043 " parameter2),\n" 15044 " parameter3,\n" 15045 "======= text by the vcs\n" 15046 " parameter2,\n" 15047 " parameter3),\n" 15048 ">>>>>>> text by the vcs\n" 15049 " otherparameter);\n")); 15050 15051 // Perforce markers. 15052 EXPECT_EQ("void f() {\n" 15053 " function(\n" 15054 ">>>> text by the vcs\n" 15055 " parameter,\n" 15056 "==== text by the vcs\n" 15057 " parameter,\n" 15058 "==== text by the vcs\n" 15059 " parameter,\n" 15060 "<<<< text by the vcs\n" 15061 " parameter);\n", 15062 format("void f() {\n" 15063 " function(\n" 15064 ">>>> text by the vcs\n" 15065 " parameter,\n" 15066 "==== text by the vcs\n" 15067 " parameter,\n" 15068 "==== text by the vcs\n" 15069 " parameter,\n" 15070 "<<<< text by the vcs\n" 15071 " parameter);\n")); 15072 15073 EXPECT_EQ("<<<<<<<\n" 15074 "|||||||\n" 15075 "=======\n" 15076 ">>>>>>>", 15077 format("<<<<<<<\n" 15078 "|||||||\n" 15079 "=======\n" 15080 ">>>>>>>")); 15081 15082 EXPECT_EQ("<<<<<<<\n" 15083 "|||||||\n" 15084 "int i;\n" 15085 "=======\n" 15086 ">>>>>>>", 15087 format("<<<<<<<\n" 15088 "|||||||\n" 15089 "int i;\n" 15090 "=======\n" 15091 ">>>>>>>")); 15092 15093 // FIXME: Handle parsing of macros around conflict markers correctly: 15094 EXPECT_EQ("#define Macro \\\n" 15095 "<<<<<<<\n" 15096 "Something \\\n" 15097 "|||||||\n" 15098 "Else \\\n" 15099 "=======\n" 15100 "Other \\\n" 15101 ">>>>>>>\n" 15102 " End int i;\n", 15103 format("#define Macro \\\n" 15104 "<<<<<<<\n" 15105 " Something \\\n" 15106 "|||||||\n" 15107 " Else \\\n" 15108 "=======\n" 15109 " Other \\\n" 15110 ">>>>>>>\n" 15111 " End\n" 15112 "int i;\n")); 15113 } 15114 15115 TEST_F(FormatTest, DisableRegions) { 15116 EXPECT_EQ("int i;\n" 15117 "// clang-format off\n" 15118 " int j;\n" 15119 "// clang-format on\n" 15120 "int k;", 15121 format(" int i;\n" 15122 " // clang-format off\n" 15123 " int j;\n" 15124 " // clang-format on\n" 15125 " int k;")); 15126 EXPECT_EQ("int i;\n" 15127 "/* clang-format off */\n" 15128 " int j;\n" 15129 "/* clang-format on */\n" 15130 "int k;", 15131 format(" int i;\n" 15132 " /* clang-format off */\n" 15133 " int j;\n" 15134 " /* clang-format on */\n" 15135 " int k;")); 15136 15137 // Don't reflow comments within disabled regions. 15138 EXPECT_EQ("// clang-format off\n" 15139 "// long long long long long long line\n" 15140 "/* clang-format on */\n" 15141 "/* long long long\n" 15142 " * long long long\n" 15143 " * line */\n" 15144 "int i;\n" 15145 "/* clang-format off */\n" 15146 "/* long long long long long long line */\n", 15147 format("// clang-format off\n" 15148 "// long long long long long long line\n" 15149 "/* clang-format on */\n" 15150 "/* long long long long long long line */\n" 15151 "int i;\n" 15152 "/* clang-format off */\n" 15153 "/* long long long long long long line */\n", 15154 getLLVMStyleWithColumns(20))); 15155 } 15156 15157 TEST_F(FormatTest, DoNotCrashOnInvalidInput) { 15158 format("? ) ="); 15159 verifyNoCrash("#define a\\\n /**/}"); 15160 } 15161 15162 TEST_F(FormatTest, FormatsTableGenCode) { 15163 FormatStyle Style = getLLVMStyle(); 15164 Style.Language = FormatStyle::LK_TableGen; 15165 verifyFormat("include \"a.td\"\ninclude \"b.td\"", Style); 15166 } 15167 15168 TEST_F(FormatTest, ArrayOfTemplates) { 15169 EXPECT_EQ("auto a = new unique_ptr<int>[10];", 15170 format("auto a = new unique_ptr<int > [ 10];")); 15171 15172 FormatStyle Spaces = getLLVMStyle(); 15173 Spaces.SpacesInSquareBrackets = true; 15174 EXPECT_EQ("auto a = new unique_ptr<int>[ 10 ];", 15175 format("auto a = new unique_ptr<int > [10];", Spaces)); 15176 } 15177 15178 TEST_F(FormatTest, ArrayAsTemplateType) { 15179 EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[10]>;", 15180 format("auto a = unique_ptr < Foo < Bar>[ 10]> ;")); 15181 15182 FormatStyle Spaces = getLLVMStyle(); 15183 Spaces.SpacesInSquareBrackets = true; 15184 EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[ 10 ]>;", 15185 format("auto a = unique_ptr < Foo < Bar>[10]> ;", Spaces)); 15186 } 15187 15188 TEST_F(FormatTest, NoSpaceAfterSuper) { verifyFormat("__super::FooBar();"); } 15189 15190 TEST(FormatStyle, GetStyleWithEmptyFileName) { 15191 llvm::vfs::InMemoryFileSystem FS; 15192 auto Style1 = getStyle("file", "", "Google", "", &FS); 15193 ASSERT_TRUE((bool)Style1); 15194 ASSERT_EQ(*Style1, getGoogleStyle()); 15195 } 15196 15197 TEST(FormatStyle, GetStyleOfFile) { 15198 llvm::vfs::InMemoryFileSystem FS; 15199 // Test 1: format file in the same directory. 15200 ASSERT_TRUE( 15201 FS.addFile("/a/.clang-format", 0, 15202 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM"))); 15203 ASSERT_TRUE( 15204 FS.addFile("/a/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;"))); 15205 auto Style1 = getStyle("file", "/a/.clang-format", "Google", "", &FS); 15206 ASSERT_TRUE((bool)Style1); 15207 ASSERT_EQ(*Style1, getLLVMStyle()); 15208 15209 // Test 2.1: fallback to default. 15210 ASSERT_TRUE( 15211 FS.addFile("/b/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;"))); 15212 auto Style2 = getStyle("file", "/b/test.cpp", "Mozilla", "", &FS); 15213 ASSERT_TRUE((bool)Style2); 15214 ASSERT_EQ(*Style2, getMozillaStyle()); 15215 15216 // Test 2.2: no format on 'none' fallback style. 15217 Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS); 15218 ASSERT_TRUE((bool)Style2); 15219 ASSERT_EQ(*Style2, getNoStyle()); 15220 15221 // Test 2.3: format if config is found with no based style while fallback is 15222 // 'none'. 15223 ASSERT_TRUE(FS.addFile("/b/.clang-format", 0, 15224 llvm::MemoryBuffer::getMemBuffer("IndentWidth: 2"))); 15225 Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS); 15226 ASSERT_TRUE((bool)Style2); 15227 ASSERT_EQ(*Style2, getLLVMStyle()); 15228 15229 // Test 2.4: format if yaml with no based style, while fallback is 'none'. 15230 Style2 = getStyle("{}", "a.h", "none", "", &FS); 15231 ASSERT_TRUE((bool)Style2); 15232 ASSERT_EQ(*Style2, getLLVMStyle()); 15233 15234 // Test 3: format file in parent directory. 15235 ASSERT_TRUE( 15236 FS.addFile("/c/.clang-format", 0, 15237 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: Google"))); 15238 ASSERT_TRUE(FS.addFile("/c/sub/sub/sub/test.cpp", 0, 15239 llvm::MemoryBuffer::getMemBuffer("int i;"))); 15240 auto Style3 = getStyle("file", "/c/sub/sub/sub/test.cpp", "LLVM", "", &FS); 15241 ASSERT_TRUE((bool)Style3); 15242 ASSERT_EQ(*Style3, getGoogleStyle()); 15243 15244 // Test 4: error on invalid fallback style 15245 auto Style4 = getStyle("file", "a.h", "KungFu", "", &FS); 15246 ASSERT_FALSE((bool)Style4); 15247 llvm::consumeError(Style4.takeError()); 15248 15249 // Test 5: error on invalid yaml on command line 15250 auto Style5 = getStyle("{invalid_key=invalid_value}", "a.h", "LLVM", "", &FS); 15251 ASSERT_FALSE((bool)Style5); 15252 llvm::consumeError(Style5.takeError()); 15253 15254 // Test 6: error on invalid style 15255 auto Style6 = getStyle("KungFu", "a.h", "LLVM", "", &FS); 15256 ASSERT_FALSE((bool)Style6); 15257 llvm::consumeError(Style6.takeError()); 15258 15259 // Test 7: found config file, error on parsing it 15260 ASSERT_TRUE( 15261 FS.addFile("/d/.clang-format", 0, 15262 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM\n" 15263 "InvalidKey: InvalidValue"))); 15264 ASSERT_TRUE( 15265 FS.addFile("/d/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;"))); 15266 auto Style7 = getStyle("file", "/d/.clang-format", "LLVM", "", &FS); 15267 ASSERT_FALSE((bool)Style7); 15268 llvm::consumeError(Style7.takeError()); 15269 15270 // Test 8: inferred per-language defaults apply. 15271 auto StyleTd = getStyle("file", "x.td", "llvm", "", &FS); 15272 ASSERT_TRUE((bool)StyleTd); 15273 ASSERT_EQ(*StyleTd, getLLVMStyle(FormatStyle::LK_TableGen)); 15274 } 15275 15276 TEST_F(ReplacementTest, FormatCodeAfterReplacements) { 15277 // Column limit is 20. 15278 std::string Code = "Type *a =\n" 15279 " new Type();\n" 15280 "g(iiiii, 0, jjjjj,\n" 15281 " 0, kkkkk, 0, mm);\n" 15282 "int bad = format ;"; 15283 std::string Expected = "auto a = new Type();\n" 15284 "g(iiiii, nullptr,\n" 15285 " jjjjj, nullptr,\n" 15286 " kkkkk, nullptr,\n" 15287 " mm);\n" 15288 "int bad = format ;"; 15289 FileID ID = Context.createInMemoryFile("format.cpp", Code); 15290 tooling::Replacements Replaces = toReplacements( 15291 {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 6, 15292 "auto "), 15293 tooling::Replacement(Context.Sources, Context.getLocation(ID, 3, 10), 1, 15294 "nullptr"), 15295 tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 3), 1, 15296 "nullptr"), 15297 tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 13), 1, 15298 "nullptr")}); 15299 15300 format::FormatStyle Style = format::getLLVMStyle(); 15301 Style.ColumnLimit = 20; // Set column limit to 20 to increase readibility. 15302 auto FormattedReplaces = formatReplacements(Code, Replaces, Style); 15303 EXPECT_TRUE(static_cast<bool>(FormattedReplaces)) 15304 << llvm::toString(FormattedReplaces.takeError()) << "\n"; 15305 auto Result = applyAllReplacements(Code, *FormattedReplaces); 15306 EXPECT_TRUE(static_cast<bool>(Result)); 15307 EXPECT_EQ(Expected, *Result); 15308 } 15309 15310 TEST_F(ReplacementTest, SortIncludesAfterReplacement) { 15311 std::string Code = "#include \"a.h\"\n" 15312 "#include \"c.h\"\n" 15313 "\n" 15314 "int main() {\n" 15315 " return 0;\n" 15316 "}"; 15317 std::string Expected = "#include \"a.h\"\n" 15318 "#include \"b.h\"\n" 15319 "#include \"c.h\"\n" 15320 "\n" 15321 "int main() {\n" 15322 " return 0;\n" 15323 "}"; 15324 FileID ID = Context.createInMemoryFile("fix.cpp", Code); 15325 tooling::Replacements Replaces = toReplacements( 15326 {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 0, 15327 "#include \"b.h\"\n")}); 15328 15329 format::FormatStyle Style = format::getLLVMStyle(); 15330 Style.SortIncludes = true; 15331 auto FormattedReplaces = formatReplacements(Code, Replaces, Style); 15332 EXPECT_TRUE(static_cast<bool>(FormattedReplaces)) 15333 << llvm::toString(FormattedReplaces.takeError()) << "\n"; 15334 auto Result = applyAllReplacements(Code, *FormattedReplaces); 15335 EXPECT_TRUE(static_cast<bool>(Result)); 15336 EXPECT_EQ(Expected, *Result); 15337 } 15338 15339 TEST_F(FormatTest, FormatSortsUsingDeclarations) { 15340 EXPECT_EQ("using std::cin;\n" 15341 "using std::cout;", 15342 format("using std::cout;\n" 15343 "using std::cin;", 15344 getGoogleStyle())); 15345 } 15346 15347 TEST_F(FormatTest, UTF8CharacterLiteralCpp03) { 15348 format::FormatStyle Style = format::getLLVMStyle(); 15349 Style.Standard = FormatStyle::LS_Cpp03; 15350 // cpp03 recognize this string as identifier u8 and literal character 'a' 15351 EXPECT_EQ("auto c = u8 'a';", format("auto c = u8'a';", Style)); 15352 } 15353 15354 TEST_F(FormatTest, UTF8CharacterLiteralCpp11) { 15355 // u8'a' is a C++17 feature, utf8 literal character, LS_Cpp11 covers 15356 // all modes, including C++11, C++14 and C++17 15357 EXPECT_EQ("auto c = u8'a';", format("auto c = u8'a';")); 15358 } 15359 15360 TEST_F(FormatTest, DoNotFormatLikelyXml) { 15361 EXPECT_EQ("<!-- ;> -->", format("<!-- ;> -->", getGoogleStyle())); 15362 EXPECT_EQ(" <!-- >; -->", format(" <!-- >; -->", getGoogleStyle())); 15363 } 15364 15365 TEST_F(FormatTest, StructuredBindings) { 15366 // Structured bindings is a C++17 feature. 15367 // all modes, including C++11, C++14 and C++17 15368 verifyFormat("auto [a, b] = f();"); 15369 EXPECT_EQ("auto [a, b] = f();", format("auto[a, b] = f();")); 15370 EXPECT_EQ("const auto [a, b] = f();", format("const auto[a, b] = f();")); 15371 EXPECT_EQ("auto const [a, b] = f();", format("auto const[a, b] = f();")); 15372 EXPECT_EQ("auto const volatile [a, b] = f();", 15373 format("auto const volatile[a, b] = f();")); 15374 EXPECT_EQ("auto [a, b, c] = f();", format("auto [ a , b,c ] = f();")); 15375 EXPECT_EQ("auto &[a, b, c] = f();", 15376 format("auto &[ a , b,c ] = f();")); 15377 EXPECT_EQ("auto &&[a, b, c] = f();", 15378 format("auto &&[ a , b,c ] = f();")); 15379 EXPECT_EQ("auto const &[a, b] = f();", format("auto const&[a, b] = f();")); 15380 EXPECT_EQ("auto const volatile &&[a, b] = f();", 15381 format("auto const volatile &&[a, b] = f();")); 15382 EXPECT_EQ("auto const &&[a, b] = f();", 15383 format("auto const && [a, b] = f();")); 15384 EXPECT_EQ("const auto &[a, b] = f();", 15385 format("const auto & [a, b] = f();")); 15386 EXPECT_EQ("const auto volatile &&[a, b] = f();", 15387 format("const auto volatile &&[a, b] = f();")); 15388 EXPECT_EQ("volatile const auto &&[a, b] = f();", 15389 format("volatile const auto &&[a, b] = f();")); 15390 EXPECT_EQ("const auto &&[a, b] = f();", 15391 format("const auto && [a, b] = f();")); 15392 15393 // Make sure we don't mistake structured bindings for lambdas. 15394 FormatStyle PointerMiddle = getLLVMStyle(); 15395 PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle; 15396 verifyFormat("auto [a1, b]{A * i};", getGoogleStyle()); 15397 verifyFormat("auto [a2, b]{A * i};", getLLVMStyle()); 15398 verifyFormat("auto [a3, b]{A * i};", PointerMiddle); 15399 verifyFormat("auto const [a1, b]{A * i};", getGoogleStyle()); 15400 verifyFormat("auto const [a2, b]{A * i};", getLLVMStyle()); 15401 verifyFormat("auto const [a3, b]{A * i};", PointerMiddle); 15402 verifyFormat("auto const& [a1, b]{A * i};", getGoogleStyle()); 15403 verifyFormat("auto const &[a2, b]{A * i};", getLLVMStyle()); 15404 verifyFormat("auto const & [a3, b]{A * i};", PointerMiddle); 15405 verifyFormat("auto const&& [a1, b]{A * i};", getGoogleStyle()); 15406 verifyFormat("auto const &&[a2, b]{A * i};", getLLVMStyle()); 15407 verifyFormat("auto const && [a3, b]{A * i};", PointerMiddle); 15408 15409 EXPECT_EQ("for (const auto &&[a, b] : some_range) {\n}", 15410 format("for (const auto && [a, b] : some_range) {\n}")); 15411 EXPECT_EQ("for (const auto &[a, b] : some_range) {\n}", 15412 format("for (const auto & [a, b] : some_range) {\n}")); 15413 EXPECT_EQ("for (const auto [a, b] : some_range) {\n}", 15414 format("for (const auto[a, b] : some_range) {\n}")); 15415 EXPECT_EQ("auto [x, y](expr);", format("auto[x,y] (expr);")); 15416 EXPECT_EQ("auto &[x, y](expr);", format("auto & [x,y] (expr);")); 15417 EXPECT_EQ("auto &&[x, y](expr);", format("auto && [x,y] (expr);")); 15418 EXPECT_EQ("auto const &[x, y](expr);", 15419 format("auto const & [x,y] (expr);")); 15420 EXPECT_EQ("auto const &&[x, y](expr);", 15421 format("auto const && [x,y] (expr);")); 15422 EXPECT_EQ("auto [x, y]{expr};", format("auto[x,y] {expr};")); 15423 EXPECT_EQ("auto const &[x, y]{expr};", 15424 format("auto const & [x,y] {expr};")); 15425 EXPECT_EQ("auto const &&[x, y]{expr};", 15426 format("auto const && [x,y] {expr};")); 15427 15428 format::FormatStyle Spaces = format::getLLVMStyle(); 15429 Spaces.SpacesInSquareBrackets = true; 15430 verifyFormat("auto [ a, b ] = f();", Spaces); 15431 verifyFormat("auto &&[ a, b ] = f();", Spaces); 15432 verifyFormat("auto &[ a, b ] = f();", Spaces); 15433 verifyFormat("auto const &&[ a, b ] = f();", Spaces); 15434 verifyFormat("auto const &[ a, b ] = f();", Spaces); 15435 } 15436 15437 TEST_F(FormatTest, FileAndCode) { 15438 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.cc", "")); 15439 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.m", "")); 15440 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.mm", "")); 15441 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "")); 15442 EXPECT_EQ(FormatStyle::LK_ObjC, 15443 guessLanguage("foo.h", "@interface Foo\n@end\n")); 15444 EXPECT_EQ( 15445 FormatStyle::LK_ObjC, 15446 guessLanguage("foo.h", "#define TRY(x, y) @try { x; } @finally { y; }")); 15447 EXPECT_EQ(FormatStyle::LK_ObjC, 15448 guessLanguage("foo.h", "#define AVAIL(x) @available(x, *))")); 15449 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.h", "@class Foo;")); 15450 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo", "")); 15451 EXPECT_EQ(FormatStyle::LK_ObjC, 15452 guessLanguage("foo", "@interface Foo\n@end\n")); 15453 EXPECT_EQ(FormatStyle::LK_ObjC, 15454 guessLanguage("foo.h", "int DoStuff(CGRect rect);\n")); 15455 EXPECT_EQ( 15456 FormatStyle::LK_ObjC, 15457 guessLanguage("foo.h", 15458 "#define MY_POINT_MAKE(x, y) CGPointMake((x), (y));\n")); 15459 EXPECT_EQ( 15460 FormatStyle::LK_Cpp, 15461 guessLanguage("foo.h", "#define FOO(...) auto bar = [] __VA_ARGS__;")); 15462 } 15463 15464 TEST_F(FormatTest, GuessLanguageWithCpp11AttributeSpecifiers) { 15465 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[noreturn]];")); 15466 EXPECT_EQ(FormatStyle::LK_ObjC, 15467 guessLanguage("foo.h", "array[[calculator getIndex]];")); 15468 EXPECT_EQ(FormatStyle::LK_Cpp, 15469 guessLanguage("foo.h", "[[noreturn, deprecated(\"so sorry\")]];")); 15470 EXPECT_EQ( 15471 FormatStyle::LK_Cpp, 15472 guessLanguage("foo.h", "[[noreturn, deprecated(\"gone, sorry\")]];")); 15473 EXPECT_EQ(FormatStyle::LK_ObjC, 15474 guessLanguage("foo.h", "[[noreturn foo] bar];")); 15475 EXPECT_EQ(FormatStyle::LK_Cpp, 15476 guessLanguage("foo.h", "[[clang::fallthrough]];")); 15477 EXPECT_EQ(FormatStyle::LK_ObjC, 15478 guessLanguage("foo.h", "[[clang:fallthrough] foo];")); 15479 EXPECT_EQ(FormatStyle::LK_Cpp, 15480 guessLanguage("foo.h", "[[gsl::suppress(\"type\")]];")); 15481 EXPECT_EQ(FormatStyle::LK_Cpp, 15482 guessLanguage("foo.h", "[[using clang: fallthrough]];")); 15483 EXPECT_EQ(FormatStyle::LK_ObjC, 15484 guessLanguage("foo.h", "[[abusing clang:fallthrough] bar];")); 15485 EXPECT_EQ(FormatStyle::LK_Cpp, 15486 guessLanguage("foo.h", "[[using gsl: suppress(\"type\")]];")); 15487 EXPECT_EQ( 15488 FormatStyle::LK_Cpp, 15489 guessLanguage("foo.h", "for (auto &&[endpoint, stream] : streams_)")); 15490 EXPECT_EQ( 15491 FormatStyle::LK_Cpp, 15492 guessLanguage("foo.h", 15493 "[[clang::callable_when(\"unconsumed\", \"unknown\")]]")); 15494 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[foo::bar, ...]]")); 15495 } 15496 15497 TEST_F(FormatTest, GuessLanguageWithCaret) { 15498 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^);")); 15499 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^, Bar);")); 15500 EXPECT_EQ(FormatStyle::LK_ObjC, 15501 guessLanguage("foo.h", "int(^)(char, float);")); 15502 EXPECT_EQ(FormatStyle::LK_ObjC, 15503 guessLanguage("foo.h", "int(^foo)(char, float);")); 15504 EXPECT_EQ(FormatStyle::LK_ObjC, 15505 guessLanguage("foo.h", "int(^foo[10])(char, float);")); 15506 EXPECT_EQ(FormatStyle::LK_ObjC, 15507 guessLanguage("foo.h", "int(^foo[kNumEntries])(char, float);")); 15508 EXPECT_EQ( 15509 FormatStyle::LK_ObjC, 15510 guessLanguage("foo.h", "int(^foo[(kNumEntries + 10)])(char, float);")); 15511 } 15512 15513 TEST_F(FormatTest, FormatsInlineAsmSymbolicNames) { 15514 // ASM symbolic names are identifiers that must be surrounded by [] without 15515 // space in between: 15516 // https://gcc.gnu.org/onlinedocs/gcc/Extended-Asm.html#InputOperands 15517 15518 // Example from https://bugs.llvm.org/show_bug.cgi?id=45108. 15519 verifyFormat(R"(// 15520 asm volatile("mrs %x[result], FPCR" : [result] "=r"(result)); 15521 )"); 15522 15523 // A list of several ASM symbolic names. 15524 verifyFormat(R"(asm("mov %[e], %[d]" : [d] "=rm"(d), [e] "rm"(*e));)"); 15525 15526 // ASM symbolic names in inline ASM with inputs and outputs. 15527 verifyFormat(R"(// 15528 asm("cmoveq %1, %2, %[result]" 15529 : [result] "=r"(result) 15530 : "r"(test), "r"(new), "[result]"(old)); 15531 )"); 15532 15533 // ASM symbolic names in inline ASM with no outputs. 15534 verifyFormat(R"(asm("mov %[e], %[d]" : : [d] "=rm"(d), [e] "rm"(*e));)"); 15535 } 15536 15537 TEST_F(FormatTest, GuessedLanguageWithInlineAsmClobbers) { 15538 EXPECT_EQ(FormatStyle::LK_Cpp, 15539 guessLanguage("foo.h", "void f() {\n" 15540 " asm (\"mov %[e], %[d]\"\n" 15541 " : [d] \"=rm\" (d)\n" 15542 " [e] \"rm\" (*e));\n" 15543 "}")); 15544 EXPECT_EQ(FormatStyle::LK_Cpp, 15545 guessLanguage("foo.h", "void f() {\n" 15546 " _asm (\"mov %[e], %[d]\"\n" 15547 " : [d] \"=rm\" (d)\n" 15548 " [e] \"rm\" (*e));\n" 15549 "}")); 15550 EXPECT_EQ(FormatStyle::LK_Cpp, 15551 guessLanguage("foo.h", "void f() {\n" 15552 " __asm (\"mov %[e], %[d]\"\n" 15553 " : [d] \"=rm\" (d)\n" 15554 " [e] \"rm\" (*e));\n" 15555 "}")); 15556 EXPECT_EQ(FormatStyle::LK_Cpp, 15557 guessLanguage("foo.h", "void f() {\n" 15558 " __asm__ (\"mov %[e], %[d]\"\n" 15559 " : [d] \"=rm\" (d)\n" 15560 " [e] \"rm\" (*e));\n" 15561 "}")); 15562 EXPECT_EQ(FormatStyle::LK_Cpp, 15563 guessLanguage("foo.h", "void f() {\n" 15564 " asm (\"mov %[e], %[d]\"\n" 15565 " : [d] \"=rm\" (d),\n" 15566 " [e] \"rm\" (*e));\n" 15567 "}")); 15568 EXPECT_EQ(FormatStyle::LK_Cpp, 15569 guessLanguage("foo.h", "void f() {\n" 15570 " asm volatile (\"mov %[e], %[d]\"\n" 15571 " : [d] \"=rm\" (d)\n" 15572 " [e] \"rm\" (*e));\n" 15573 "}")); 15574 } 15575 15576 TEST_F(FormatTest, GuessLanguageWithChildLines) { 15577 EXPECT_EQ(FormatStyle::LK_Cpp, 15578 guessLanguage("foo.h", "#define FOO ({ std::string s; })")); 15579 EXPECT_EQ(FormatStyle::LK_ObjC, 15580 guessLanguage("foo.h", "#define FOO ({ NSString *s; })")); 15581 EXPECT_EQ( 15582 FormatStyle::LK_Cpp, 15583 guessLanguage("foo.h", "#define FOO ({ foo(); ({ std::string s; }) })")); 15584 EXPECT_EQ( 15585 FormatStyle::LK_ObjC, 15586 guessLanguage("foo.h", "#define FOO ({ foo(); ({ NSString *s; }) })")); 15587 } 15588 15589 TEST_F(FormatTest, TypenameMacros) { 15590 std::vector<std::string> TypenameMacros = {"STACK_OF", "LIST", "TAILQ_ENTRY"}; 15591 15592 // Test case reported in https://bugs.llvm.org/show_bug.cgi?id=30353 15593 FormatStyle Google = getGoogleStyleWithColumns(0); 15594 Google.TypenameMacros = TypenameMacros; 15595 verifyFormat("struct foo {\n" 15596 " int bar;\n" 15597 " TAILQ_ENTRY(a) bleh;\n" 15598 "};", 15599 Google); 15600 15601 FormatStyle Macros = getLLVMStyle(); 15602 Macros.TypenameMacros = TypenameMacros; 15603 15604 verifyFormat("STACK_OF(int) a;", Macros); 15605 verifyFormat("STACK_OF(int) *a;", Macros); 15606 verifyFormat("STACK_OF(int const *) *a;", Macros); 15607 verifyFormat("STACK_OF(int *const) *a;", Macros); 15608 verifyFormat("STACK_OF(int, string) a;", Macros); 15609 verifyFormat("STACK_OF(LIST(int)) a;", Macros); 15610 verifyFormat("STACK_OF(LIST(int)) a, b;", Macros); 15611 verifyFormat("for (LIST(int) *a = NULL; a;) {\n}", Macros); 15612 verifyFormat("STACK_OF(int) f(LIST(int) *arg);", Macros); 15613 15614 Macros.PointerAlignment = FormatStyle::PAS_Left; 15615 verifyFormat("STACK_OF(int)* a;", Macros); 15616 verifyFormat("STACK_OF(int*)* a;", Macros); 15617 } 15618 15619 TEST_F(FormatTest, AmbersandInLamda) { 15620 // Test case reported in https://bugs.llvm.org/show_bug.cgi?id=41899 15621 FormatStyle AlignStyle = getLLVMStyle(); 15622 AlignStyle.PointerAlignment = FormatStyle::PAS_Left; 15623 verifyFormat("auto lambda = [&a = a]() { a = 2; };", AlignStyle); 15624 AlignStyle.PointerAlignment = FormatStyle::PAS_Right; 15625 verifyFormat("auto lambda = [&a = a]() { a = 2; };", AlignStyle); 15626 } 15627 15628 TEST_F(FormatTest, SpacesInConditionalStatement) { 15629 FormatStyle Spaces = getLLVMStyle(); 15630 Spaces.SpacesInConditionalStatement = true; 15631 verifyFormat("for ( int i = 0; i; i++ )\n continue;", Spaces); 15632 verifyFormat("if ( !a )\n return;", Spaces); 15633 verifyFormat("if ( a )\n return;", Spaces); 15634 verifyFormat("if constexpr ( a )\n return;", Spaces); 15635 verifyFormat("switch ( a )\ncase 1:\n return;", Spaces); 15636 verifyFormat("while ( a )\n return;", Spaces); 15637 verifyFormat("while ( (a && b) )\n return;", Spaces); 15638 verifyFormat("do {\n} while ( 1 != 0 );", Spaces); 15639 verifyFormat("try {\n} catch ( const std::exception & ) {\n}", Spaces); 15640 // Check that space on the left of "::" is inserted as expected at beginning 15641 // of condition. 15642 verifyFormat("while ( ::func() )\n return;", Spaces); 15643 } 15644 15645 TEST_F(FormatTest, AlternativeOperators) { 15646 // Test case for ensuring alternate operators are not 15647 // combined with their right most neighbour. 15648 verifyFormat("int a and b;"); 15649 verifyFormat("int a and_eq b;"); 15650 verifyFormat("int a bitand b;"); 15651 verifyFormat("int a bitor b;"); 15652 verifyFormat("int a compl b;"); 15653 verifyFormat("int a not b;"); 15654 verifyFormat("int a not_eq b;"); 15655 verifyFormat("int a or b;"); 15656 verifyFormat("int a xor b;"); 15657 verifyFormat("int a xor_eq b;"); 15658 verifyFormat("return this not_eq bitand other;"); 15659 verifyFormat("bool operator not_eq(const X bitand other)"); 15660 15661 verifyFormat("int a and 5;"); 15662 verifyFormat("int a and_eq 5;"); 15663 verifyFormat("int a bitand 5;"); 15664 verifyFormat("int a bitor 5;"); 15665 verifyFormat("int a compl 5;"); 15666 verifyFormat("int a not 5;"); 15667 verifyFormat("int a not_eq 5;"); 15668 verifyFormat("int a or 5;"); 15669 verifyFormat("int a xor 5;"); 15670 verifyFormat("int a xor_eq 5;"); 15671 15672 verifyFormat("int a compl(5);"); 15673 verifyFormat("int a not(5);"); 15674 15675 /* FIXME handle alternate tokens 15676 * https://en.cppreference.com/w/cpp/language/operator_alternative 15677 // alternative tokens 15678 verifyFormat("compl foo();"); // ~foo(); 15679 verifyFormat("foo() <%%>;"); // foo(); 15680 verifyFormat("void foo() <%%>;"); // void foo(){} 15681 verifyFormat("int a <:1:>;"); // int a[1];[ 15682 verifyFormat("%:define ABC abc"); // #define ABC abc 15683 verifyFormat("%:%:"); // ## 15684 */ 15685 } 15686 15687 TEST_F(FormatTest, STLWhileNotDefineChed) { 15688 verifyFormat("#if defined(while)\n" 15689 "#define while EMIT WARNING C4005\n" 15690 "#endif // while"); 15691 } 15692 15693 TEST_F(FormatTest, OperatorSpacing) { 15694 FormatStyle Style = getLLVMStyle(); 15695 Style.PointerAlignment = FormatStyle::PAS_Right; 15696 verifyFormat("Foo::operator*();", Style); 15697 verifyFormat("Foo::operator void *();", Style); 15698 verifyFormat("Foo::operator void **();", Style); 15699 verifyFormat("Foo::operator()(void *);", Style); 15700 verifyFormat("Foo::operator*(void *);", Style); 15701 verifyFormat("Foo::operator*();", Style); 15702 verifyFormat("Foo::operator**();", Style); 15703 verifyFormat("Foo::operator&();", Style); 15704 verifyFormat("Foo::operator<int> *();", Style); 15705 verifyFormat("Foo::operator<Foo> *();", Style); 15706 verifyFormat("Foo::operator<int> **();", Style); 15707 verifyFormat("Foo::operator<Foo> **();", Style); 15708 verifyFormat("Foo::operator<int> &();", Style); 15709 verifyFormat("Foo::operator<Foo> &();", Style); 15710 verifyFormat("Foo::operator<int> &&();", Style); 15711 verifyFormat("Foo::operator<Foo> &&();", Style); 15712 verifyFormat("operator*(int (*)(), class Foo);", Style); 15713 15714 verifyFormat("Foo::operator&();", Style); 15715 verifyFormat("Foo::operator void &();", Style); 15716 verifyFormat("Foo::operator()(void &);", Style); 15717 verifyFormat("Foo::operator&(void &);", Style); 15718 verifyFormat("Foo::operator&();", Style); 15719 verifyFormat("operator&(int (&)(), class Foo);", Style); 15720 15721 verifyFormat("Foo::operator&&();", Style); 15722 verifyFormat("Foo::operator**();", Style); 15723 verifyFormat("Foo::operator void &&();", Style); 15724 verifyFormat("Foo::operator()(void &&);", Style); 15725 verifyFormat("Foo::operator&&(void &&);", Style); 15726 verifyFormat("Foo::operator&&();", Style); 15727 verifyFormat("operator&&(int(&&)(), class Foo);", Style); 15728 verifyFormat("operator const nsTArrayRight<E> &()", Style); 15729 verifyFormat("[[nodiscard]] operator const nsTArrayRight<E, Allocator> &()", 15730 Style); 15731 verifyFormat("operator void **()", Style); 15732 verifyFormat("operator const FooRight<Object> &()", Style); 15733 verifyFormat("operator const FooRight<Object> *()", Style); 15734 verifyFormat("operator const FooRight<Object> **()", Style); 15735 15736 Style.PointerAlignment = FormatStyle::PAS_Left; 15737 verifyFormat("Foo::operator*();", Style); 15738 verifyFormat("Foo::operator**();", Style); 15739 verifyFormat("Foo::operator void*();", Style); 15740 verifyFormat("Foo::operator void**();", Style); 15741 verifyFormat("Foo::operator/*comment*/ void*();", Style); 15742 verifyFormat("Foo::operator/*a*/ const /*b*/ void*();", Style); 15743 verifyFormat("Foo::operator/*a*/ volatile /*b*/ void*();", Style); 15744 verifyFormat("Foo::operator()(void*);", Style); 15745 verifyFormat("Foo::operator*(void*);", Style); 15746 verifyFormat("Foo::operator*();", Style); 15747 verifyFormat("Foo::operator<int>*();", Style); 15748 verifyFormat("Foo::operator<Foo>*();", Style); 15749 verifyFormat("Foo::operator<int>**();", Style); 15750 verifyFormat("Foo::operator<Foo>**();", Style); 15751 verifyFormat("Foo::operator<int>&();", Style); 15752 verifyFormat("Foo::operator<Foo>&();", Style); 15753 verifyFormat("Foo::operator<int>&&();", Style); 15754 verifyFormat("Foo::operator<Foo>&&();", Style); 15755 verifyFormat("operator*(int (*)(), class Foo);", Style); 15756 15757 verifyFormat("Foo::operator&();", Style); 15758 verifyFormat("Foo::operator void&();", Style); 15759 verifyFormat("Foo::operator/*comment*/ void&();", Style); 15760 verifyFormat("Foo::operator/*a*/ const /*b*/ void&();", Style); 15761 verifyFormat("Foo::operator/*a*/ volatile /*b*/ void&();", Style); 15762 verifyFormat("Foo::operator()(void&);", Style); 15763 verifyFormat("Foo::operator&(void&);", Style); 15764 verifyFormat("Foo::operator&();", Style); 15765 verifyFormat("operator&(int (&)(), class Foo);", Style); 15766 15767 verifyFormat("Foo::operator&&();", Style); 15768 verifyFormat("Foo::operator void&&();", Style); 15769 verifyFormat("Foo::operator/*comment*/ void&&();", Style); 15770 verifyFormat("Foo::operator/*a*/ const /*b*/ void&&();", Style); 15771 verifyFormat("Foo::operator/*a*/ volatile /*b*/ void&&();", Style); 15772 verifyFormat("Foo::operator()(void&&);", Style); 15773 verifyFormat("Foo::operator&&(void&&);", Style); 15774 verifyFormat("Foo::operator&&();", Style); 15775 verifyFormat("operator&&(int(&&)(), class Foo);", Style); 15776 verifyFormat("operator const nsTArrayLeft<E>&()", Style); 15777 verifyFormat("[[nodiscard]] operator const nsTArrayLeft<E, Allocator>&()", 15778 Style); 15779 verifyFormat("operator void**()", Style); 15780 verifyFormat("operator const FooLeft<Object>&()", Style); 15781 verifyFormat("operator const FooLeft<Object>*()", Style); 15782 verifyFormat("operator const FooLeft<Object>**()", Style); 15783 15784 // PR45107 15785 verifyFormat("operator Vector<String>&();", Style); 15786 verifyFormat("operator const Vector<String>&();", Style); 15787 verifyFormat("operator foo::Bar*();", Style); 15788 verifyFormat("operator const Foo<X>::Bar<Y>*();", Style); 15789 verifyFormat("operator/*a*/ const /*b*/ Foo /*c*/<X> /*d*/ ::Bar<Y>*();", 15790 Style); 15791 15792 Style.PointerAlignment = FormatStyle::PAS_Middle; 15793 verifyFormat("Foo::operator*();", Style); 15794 verifyFormat("Foo::operator void *();", Style); 15795 verifyFormat("Foo::operator()(void *);", Style); 15796 verifyFormat("Foo::operator*(void *);", Style); 15797 verifyFormat("Foo::operator*();", Style); 15798 verifyFormat("operator*(int (*)(), class Foo);", Style); 15799 15800 verifyFormat("Foo::operator&();", Style); 15801 verifyFormat("Foo::operator void &();", Style); 15802 verifyFormat("Foo::operator()(void &);", Style); 15803 verifyFormat("Foo::operator&(void &);", Style); 15804 verifyFormat("Foo::operator&();", Style); 15805 verifyFormat("operator&(int (&)(), class Foo);", Style); 15806 15807 verifyFormat("Foo::operator&&();", Style); 15808 verifyFormat("Foo::operator void &&();", Style); 15809 verifyFormat("Foo::operator()(void &&);", Style); 15810 verifyFormat("Foo::operator&&(void &&);", Style); 15811 verifyFormat("Foo::operator&&();", Style); 15812 verifyFormat("operator&&(int(&&)(), class Foo);", Style); 15813 } 15814 15815 } // namespace 15816 } // namespace format 15817 } // namespace clang 15818