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 // handle microsoft non standard extension 999 verifyFormat("for each (char c in x->MyStringProperty)"); 1000 } 1001 1002 TEST_F(FormatTest, FormatsWhileLoop) { 1003 verifyFormat("while (true) {\n}"); 1004 verifyFormat("while (true)\n" 1005 " f();"); 1006 verifyFormat("while () {\n}"); 1007 verifyFormat("while () {\n" 1008 " f();\n" 1009 "}"); 1010 } 1011 1012 TEST_F(FormatTest, FormatsDoWhile) { 1013 verifyFormat("do {\n" 1014 " do_something();\n" 1015 "} while (something());"); 1016 verifyFormat("do\n" 1017 " do_something();\n" 1018 "while (something());"); 1019 } 1020 1021 TEST_F(FormatTest, FormatsSwitchStatement) { 1022 verifyFormat("switch (x) {\n" 1023 "case 1:\n" 1024 " f();\n" 1025 " break;\n" 1026 "case kFoo:\n" 1027 "case ns::kBar:\n" 1028 "case kBaz:\n" 1029 " break;\n" 1030 "default:\n" 1031 " g();\n" 1032 " break;\n" 1033 "}"); 1034 verifyFormat("switch (x) {\n" 1035 "case 1: {\n" 1036 " f();\n" 1037 " break;\n" 1038 "}\n" 1039 "case 2: {\n" 1040 " break;\n" 1041 "}\n" 1042 "}"); 1043 verifyFormat("switch (x) {\n" 1044 "case 1: {\n" 1045 " f();\n" 1046 " {\n" 1047 " g();\n" 1048 " h();\n" 1049 " }\n" 1050 " break;\n" 1051 "}\n" 1052 "}"); 1053 verifyFormat("switch (x) {\n" 1054 "case 1: {\n" 1055 " f();\n" 1056 " if (foo) {\n" 1057 " g();\n" 1058 " h();\n" 1059 " }\n" 1060 " break;\n" 1061 "}\n" 1062 "}"); 1063 verifyFormat("switch (x) {\n" 1064 "case 1: {\n" 1065 " f();\n" 1066 " g();\n" 1067 "} break;\n" 1068 "}"); 1069 verifyFormat("switch (test)\n" 1070 " ;"); 1071 verifyFormat("switch (x) {\n" 1072 "default: {\n" 1073 " // Do nothing.\n" 1074 "}\n" 1075 "}"); 1076 verifyFormat("switch (x) {\n" 1077 "// comment\n" 1078 "// if 1, do f()\n" 1079 "case 1:\n" 1080 " f();\n" 1081 "}"); 1082 verifyFormat("switch (x) {\n" 1083 "case 1:\n" 1084 " // Do amazing stuff\n" 1085 " {\n" 1086 " f();\n" 1087 " g();\n" 1088 " }\n" 1089 " break;\n" 1090 "}"); 1091 verifyFormat("#define A \\\n" 1092 " switch (x) { \\\n" 1093 " case a: \\\n" 1094 " foo = b; \\\n" 1095 " }", 1096 getLLVMStyleWithColumns(20)); 1097 verifyFormat("#define OPERATION_CASE(name) \\\n" 1098 " case OP_name: \\\n" 1099 " return operations::Operation##name\n", 1100 getLLVMStyleWithColumns(40)); 1101 verifyFormat("switch (x) {\n" 1102 "case 1:;\n" 1103 "default:;\n" 1104 " int i;\n" 1105 "}"); 1106 1107 verifyGoogleFormat("switch (x) {\n" 1108 " case 1:\n" 1109 " f();\n" 1110 " break;\n" 1111 " case kFoo:\n" 1112 " case ns::kBar:\n" 1113 " case kBaz:\n" 1114 " break;\n" 1115 " default:\n" 1116 " g();\n" 1117 " break;\n" 1118 "}"); 1119 verifyGoogleFormat("switch (x) {\n" 1120 " case 1: {\n" 1121 " f();\n" 1122 " break;\n" 1123 " }\n" 1124 "}"); 1125 verifyGoogleFormat("switch (test)\n" 1126 " ;"); 1127 1128 verifyGoogleFormat("#define OPERATION_CASE(name) \\\n" 1129 " case OP_name: \\\n" 1130 " return operations::Operation##name\n"); 1131 verifyGoogleFormat("Operation codeToOperation(OperationCode OpCode) {\n" 1132 " // Get the correction operation class.\n" 1133 " switch (OpCode) {\n" 1134 " CASE(Add);\n" 1135 " CASE(Subtract);\n" 1136 " default:\n" 1137 " return operations::Unknown;\n" 1138 " }\n" 1139 "#undef OPERATION_CASE\n" 1140 "}"); 1141 verifyFormat("DEBUG({\n" 1142 " switch (x) {\n" 1143 " case A:\n" 1144 " f();\n" 1145 " break;\n" 1146 " // fallthrough\n" 1147 " case B:\n" 1148 " g();\n" 1149 " break;\n" 1150 " }\n" 1151 "});"); 1152 EXPECT_EQ("DEBUG({\n" 1153 " switch (x) {\n" 1154 " case A:\n" 1155 " f();\n" 1156 " break;\n" 1157 " // On B:\n" 1158 " case B:\n" 1159 " g();\n" 1160 " break;\n" 1161 " }\n" 1162 "});", 1163 format("DEBUG({\n" 1164 " switch (x) {\n" 1165 " case A:\n" 1166 " f();\n" 1167 " break;\n" 1168 " // On B:\n" 1169 " case B:\n" 1170 " g();\n" 1171 " break;\n" 1172 " }\n" 1173 "});", 1174 getLLVMStyle())); 1175 EXPECT_EQ("switch (n) {\n" 1176 "case 0: {\n" 1177 " return false;\n" 1178 "}\n" 1179 "default: {\n" 1180 " return true;\n" 1181 "}\n" 1182 "}", 1183 format("switch (n)\n" 1184 "{\n" 1185 "case 0: {\n" 1186 " return false;\n" 1187 "}\n" 1188 "default: {\n" 1189 " return true;\n" 1190 "}\n" 1191 "}", 1192 getLLVMStyle())); 1193 verifyFormat("switch (a) {\n" 1194 "case (b):\n" 1195 " return;\n" 1196 "}"); 1197 1198 verifyFormat("switch (a) {\n" 1199 "case some_namespace::\n" 1200 " some_constant:\n" 1201 " return;\n" 1202 "}", 1203 getLLVMStyleWithColumns(34)); 1204 1205 FormatStyle Style = getLLVMStyle(); 1206 Style.IndentCaseLabels = true; 1207 Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Never; 1208 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 1209 Style.BraceWrapping.AfterCaseLabel = true; 1210 Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always; 1211 EXPECT_EQ("switch (n)\n" 1212 "{\n" 1213 " case 0:\n" 1214 " {\n" 1215 " return false;\n" 1216 " }\n" 1217 " default:\n" 1218 " {\n" 1219 " return true;\n" 1220 " }\n" 1221 "}", 1222 format("switch (n) {\n" 1223 " case 0: {\n" 1224 " return false;\n" 1225 " }\n" 1226 " default: {\n" 1227 " return true;\n" 1228 " }\n" 1229 "}", 1230 Style)); 1231 Style.BraceWrapping.AfterCaseLabel = false; 1232 EXPECT_EQ("switch (n)\n" 1233 "{\n" 1234 " case 0: {\n" 1235 " return false;\n" 1236 " }\n" 1237 " default: {\n" 1238 " return true;\n" 1239 " }\n" 1240 "}", 1241 format("switch (n) {\n" 1242 " case 0:\n" 1243 " {\n" 1244 " return false;\n" 1245 " }\n" 1246 " default:\n" 1247 " {\n" 1248 " return true;\n" 1249 " }\n" 1250 "}", 1251 Style)); 1252 Style.IndentCaseLabels = false; 1253 Style.IndentCaseBlocks = true; 1254 EXPECT_EQ("switch (n)\n" 1255 "{\n" 1256 "case 0:\n" 1257 " {\n" 1258 " return false;\n" 1259 " }\n" 1260 "case 1:\n" 1261 " break;\n" 1262 "default:\n" 1263 " {\n" 1264 " return true;\n" 1265 " }\n" 1266 "}", 1267 format("switch (n) {\n" 1268 "case 0: {\n" 1269 " return false;\n" 1270 "}\n" 1271 "case 1:\n" 1272 " break;\n" 1273 "default: {\n" 1274 " return true;\n" 1275 "}\n" 1276 "}", 1277 Style)); 1278 Style.IndentCaseLabels = true; 1279 Style.IndentCaseBlocks = true; 1280 EXPECT_EQ("switch (n)\n" 1281 "{\n" 1282 " case 0:\n" 1283 " {\n" 1284 " return false;\n" 1285 " }\n" 1286 " case 1:\n" 1287 " break;\n" 1288 " default:\n" 1289 " {\n" 1290 " return true;\n" 1291 " }\n" 1292 "}", 1293 format("switch (n) {\n" 1294 "case 0: {\n" 1295 " return false;\n" 1296 "}\n" 1297 "case 1:\n" 1298 " break;\n" 1299 "default: {\n" 1300 " return true;\n" 1301 "}\n" 1302 "}", 1303 Style)); 1304 } 1305 1306 TEST_F(FormatTest, CaseRanges) { 1307 verifyFormat("switch (x) {\n" 1308 "case 'A' ... 'Z':\n" 1309 "case 1 ... 5:\n" 1310 "case a ... b:\n" 1311 " break;\n" 1312 "}"); 1313 } 1314 1315 TEST_F(FormatTest, ShortEnums) { 1316 FormatStyle Style = getLLVMStyle(); 1317 Style.AllowShortEnumsOnASingleLine = true; 1318 verifyFormat("enum { A, B, C } ShortEnum1, ShortEnum2;", Style); 1319 Style.AllowShortEnumsOnASingleLine = false; 1320 verifyFormat("enum\n" 1321 "{\n" 1322 " A,\n" 1323 " B,\n" 1324 " C\n" 1325 "} ShortEnum1, ShortEnum2;", 1326 Style); 1327 } 1328 1329 TEST_F(FormatTest, ShortCaseLabels) { 1330 FormatStyle Style = getLLVMStyle(); 1331 Style.AllowShortCaseLabelsOnASingleLine = true; 1332 verifyFormat("switch (a) {\n" 1333 "case 1: x = 1; break;\n" 1334 "case 2: return;\n" 1335 "case 3:\n" 1336 "case 4:\n" 1337 "case 5: return;\n" 1338 "case 6: // comment\n" 1339 " return;\n" 1340 "case 7:\n" 1341 " // comment\n" 1342 " return;\n" 1343 "case 8:\n" 1344 " x = 8; // comment\n" 1345 " break;\n" 1346 "default: y = 1; break;\n" 1347 "}", 1348 Style); 1349 verifyFormat("switch (a) {\n" 1350 "case 0: return; // comment\n" 1351 "case 1: break; // comment\n" 1352 "case 2: return;\n" 1353 "// comment\n" 1354 "case 3: return;\n" 1355 "// comment 1\n" 1356 "// comment 2\n" 1357 "// comment 3\n" 1358 "case 4: break; /* comment */\n" 1359 "case 5:\n" 1360 " // comment\n" 1361 " break;\n" 1362 "case 6: /* comment */ x = 1; break;\n" 1363 "case 7: x = /* comment */ 1; break;\n" 1364 "case 8:\n" 1365 " x = 1; /* comment */\n" 1366 " break;\n" 1367 "case 9:\n" 1368 " break; // comment line 1\n" 1369 " // comment line 2\n" 1370 "}", 1371 Style); 1372 EXPECT_EQ("switch (a) {\n" 1373 "case 1:\n" 1374 " x = 8;\n" 1375 " // fall through\n" 1376 "case 2: x = 8;\n" 1377 "// comment\n" 1378 "case 3:\n" 1379 " return; /* comment line 1\n" 1380 " * comment line 2 */\n" 1381 "case 4: i = 8;\n" 1382 "// something else\n" 1383 "#if FOO\n" 1384 "case 5: break;\n" 1385 "#endif\n" 1386 "}", 1387 format("switch (a) {\n" 1388 "case 1: x = 8;\n" 1389 " // fall through\n" 1390 "case 2:\n" 1391 " x = 8;\n" 1392 "// comment\n" 1393 "case 3:\n" 1394 " return; /* comment line 1\n" 1395 " * comment line 2 */\n" 1396 "case 4:\n" 1397 " i = 8;\n" 1398 "// something else\n" 1399 "#if FOO\n" 1400 "case 5: break;\n" 1401 "#endif\n" 1402 "}", 1403 Style)); 1404 EXPECT_EQ("switch (a) {\n" 1405 "case 0:\n" 1406 " return; // long long long long long long long long long long " 1407 "long long comment\n" 1408 " // line\n" 1409 "}", 1410 format("switch (a) {\n" 1411 "case 0: return; // long long long long long long long long " 1412 "long long long long comment line\n" 1413 "}", 1414 Style)); 1415 EXPECT_EQ("switch (a) {\n" 1416 "case 0:\n" 1417 " return; /* long long long long long long long long long long " 1418 "long long comment\n" 1419 " line */\n" 1420 "}", 1421 format("switch (a) {\n" 1422 "case 0: return; /* long long long long long long long long " 1423 "long long long long comment line */\n" 1424 "}", 1425 Style)); 1426 verifyFormat("switch (a) {\n" 1427 "#if FOO\n" 1428 "case 0: return 0;\n" 1429 "#endif\n" 1430 "}", 1431 Style); 1432 verifyFormat("switch (a) {\n" 1433 "case 1: {\n" 1434 "}\n" 1435 "case 2: {\n" 1436 " return;\n" 1437 "}\n" 1438 "case 3: {\n" 1439 " x = 1;\n" 1440 " return;\n" 1441 "}\n" 1442 "case 4:\n" 1443 " if (x)\n" 1444 " return;\n" 1445 "}", 1446 Style); 1447 Style.ColumnLimit = 21; 1448 verifyFormat("switch (a) {\n" 1449 "case 1: x = 1; break;\n" 1450 "case 2: return;\n" 1451 "case 3:\n" 1452 "case 4:\n" 1453 "case 5: return;\n" 1454 "default:\n" 1455 " y = 1;\n" 1456 " break;\n" 1457 "}", 1458 Style); 1459 Style.ColumnLimit = 80; 1460 Style.AllowShortCaseLabelsOnASingleLine = false; 1461 Style.IndentCaseLabels = true; 1462 EXPECT_EQ("switch (n) {\n" 1463 " default /*comments*/:\n" 1464 " return true;\n" 1465 " case 0:\n" 1466 " return false;\n" 1467 "}", 1468 format("switch (n) {\n" 1469 "default/*comments*/:\n" 1470 " return true;\n" 1471 "case 0:\n" 1472 " return false;\n" 1473 "}", 1474 Style)); 1475 Style.AllowShortCaseLabelsOnASingleLine = true; 1476 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 1477 Style.BraceWrapping.AfterCaseLabel = true; 1478 Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always; 1479 EXPECT_EQ("switch (n)\n" 1480 "{\n" 1481 " case 0:\n" 1482 " {\n" 1483 " return false;\n" 1484 " }\n" 1485 " default:\n" 1486 " {\n" 1487 " return true;\n" 1488 " }\n" 1489 "}", 1490 format("switch (n) {\n" 1491 " case 0: {\n" 1492 " return false;\n" 1493 " }\n" 1494 " default:\n" 1495 " {\n" 1496 " return true;\n" 1497 " }\n" 1498 "}", 1499 Style)); 1500 } 1501 1502 TEST_F(FormatTest, FormatsLabels) { 1503 verifyFormat("void f() {\n" 1504 " some_code();\n" 1505 "test_label:\n" 1506 " some_other_code();\n" 1507 " {\n" 1508 " some_more_code();\n" 1509 " another_label:\n" 1510 " some_more_code();\n" 1511 " }\n" 1512 "}"); 1513 verifyFormat("{\n" 1514 " some_code();\n" 1515 "test_label:\n" 1516 " some_other_code();\n" 1517 "}"); 1518 verifyFormat("{\n" 1519 " some_code();\n" 1520 "test_label:;\n" 1521 " int i = 0;\n" 1522 "}"); 1523 FormatStyle Style = getLLVMStyle(); 1524 Style.IndentGotoLabels = false; 1525 verifyFormat("void f() {\n" 1526 " some_code();\n" 1527 "test_label:\n" 1528 " some_other_code();\n" 1529 " {\n" 1530 " some_more_code();\n" 1531 "another_label:\n" 1532 " some_more_code();\n" 1533 " }\n" 1534 "}", 1535 Style); 1536 verifyFormat("{\n" 1537 " some_code();\n" 1538 "test_label:\n" 1539 " some_other_code();\n" 1540 "}", 1541 Style); 1542 verifyFormat("{\n" 1543 " some_code();\n" 1544 "test_label:;\n" 1545 " int i = 0;\n" 1546 "}"); 1547 } 1548 1549 TEST_F(FormatTest, MultiLineControlStatements) { 1550 FormatStyle Style = getLLVMStyle(); 1551 Style.BreakBeforeBraces = FormatStyle::BraceBreakingStyle::BS_Custom; 1552 Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_MultiLine; 1553 Style.ColumnLimit = 20; 1554 // Short lines should keep opening brace on same line. 1555 EXPECT_EQ("if (foo) {\n" 1556 " bar();\n" 1557 "}", 1558 format("if(foo){bar();}", Style)); 1559 EXPECT_EQ("if (foo) {\n" 1560 " bar();\n" 1561 "} else {\n" 1562 " baz();\n" 1563 "}", 1564 format("if(foo){bar();}else{baz();}", Style)); 1565 EXPECT_EQ("if (foo && bar) {\n" 1566 " baz();\n" 1567 "}", 1568 format("if(foo&&bar){baz();}", Style)); 1569 EXPECT_EQ("if (foo) {\n" 1570 " bar();\n" 1571 "} else if (baz) {\n" 1572 " quux();\n" 1573 "}", 1574 format("if(foo){bar();}else if(baz){quux();}", Style)); 1575 EXPECT_EQ( 1576 "if (foo) {\n" 1577 " bar();\n" 1578 "} else if (baz) {\n" 1579 " quux();\n" 1580 "} else {\n" 1581 " foobar();\n" 1582 "}", 1583 format("if(foo){bar();}else if(baz){quux();}else{foobar();}", Style)); 1584 EXPECT_EQ("for (;;) {\n" 1585 " foo();\n" 1586 "}", 1587 format("for(;;){foo();}")); 1588 EXPECT_EQ("while (1) {\n" 1589 " foo();\n" 1590 "}", 1591 format("while(1){foo();}", Style)); 1592 EXPECT_EQ("switch (foo) {\n" 1593 "case bar:\n" 1594 " return;\n" 1595 "}", 1596 format("switch(foo){case bar:return;}", Style)); 1597 EXPECT_EQ("try {\n" 1598 " foo();\n" 1599 "} catch (...) {\n" 1600 " bar();\n" 1601 "}", 1602 format("try{foo();}catch(...){bar();}", Style)); 1603 EXPECT_EQ("do {\n" 1604 " foo();\n" 1605 "} while (bar &&\n" 1606 " baz);", 1607 format("do{foo();}while(bar&&baz);", Style)); 1608 // Long lines should put opening brace on new line. 1609 EXPECT_EQ("if (foo && bar &&\n" 1610 " baz)\n" 1611 "{\n" 1612 " quux();\n" 1613 "}", 1614 format("if(foo&&bar&&baz){quux();}", Style)); 1615 EXPECT_EQ("if (foo && bar &&\n" 1616 " baz)\n" 1617 "{\n" 1618 " quux();\n" 1619 "}", 1620 format("if (foo && bar &&\n" 1621 " baz) {\n" 1622 " quux();\n" 1623 "}", 1624 Style)); 1625 EXPECT_EQ("if (foo) {\n" 1626 " bar();\n" 1627 "} else if (baz ||\n" 1628 " quux)\n" 1629 "{\n" 1630 " foobar();\n" 1631 "}", 1632 format("if(foo){bar();}else if(baz||quux){foobar();}", Style)); 1633 EXPECT_EQ( 1634 "if (foo) {\n" 1635 " bar();\n" 1636 "} else if (baz ||\n" 1637 " quux)\n" 1638 "{\n" 1639 " foobar();\n" 1640 "} else {\n" 1641 " barbaz();\n" 1642 "}", 1643 format("if(foo){bar();}else if(baz||quux){foobar();}else{barbaz();}", 1644 Style)); 1645 EXPECT_EQ("for (int i = 0;\n" 1646 " i < 10; ++i)\n" 1647 "{\n" 1648 " foo();\n" 1649 "}", 1650 format("for(int i=0;i<10;++i){foo();}", Style)); 1651 EXPECT_EQ("while (foo || bar ||\n" 1652 " baz)\n" 1653 "{\n" 1654 " quux();\n" 1655 "}", 1656 format("while(foo||bar||baz){quux();}", Style)); 1657 EXPECT_EQ("switch (\n" 1658 " foo = barbaz)\n" 1659 "{\n" 1660 "case quux:\n" 1661 " return;\n" 1662 "}", 1663 format("switch(foo=barbaz){case quux:return;}", Style)); 1664 EXPECT_EQ("try {\n" 1665 " foo();\n" 1666 "} catch (\n" 1667 " Exception &bar)\n" 1668 "{\n" 1669 " baz();\n" 1670 "}", 1671 format("try{foo();}catch(Exception&bar){baz();}", Style)); 1672 Style.ColumnLimit = 1673 40; // to concentrate at brace wrapping, not line wrap due to column limit 1674 EXPECT_EQ("try {\n" 1675 " foo();\n" 1676 "} catch (Exception &bar) {\n" 1677 " baz();\n" 1678 "}", 1679 format("try{foo();}catch(Exception&bar){baz();}", Style)); 1680 Style.ColumnLimit = 1681 20; // to concentrate at brace wrapping, not line wrap due to column limit 1682 1683 Style.BraceWrapping.BeforeElse = true; 1684 EXPECT_EQ( 1685 "if (foo) {\n" 1686 " bar();\n" 1687 "}\n" 1688 "else if (baz ||\n" 1689 " quux)\n" 1690 "{\n" 1691 " foobar();\n" 1692 "}\n" 1693 "else {\n" 1694 " barbaz();\n" 1695 "}", 1696 format("if(foo){bar();}else if(baz||quux){foobar();}else{barbaz();}", 1697 Style)); 1698 1699 Style.BraceWrapping.BeforeCatch = true; 1700 EXPECT_EQ("try {\n" 1701 " foo();\n" 1702 "}\n" 1703 "catch (...) {\n" 1704 " baz();\n" 1705 "}", 1706 format("try{foo();}catch(...){baz();}", Style)); 1707 } 1708 1709 TEST_F(FormatTest, BeforeWhile) { 1710 FormatStyle Style = getLLVMStyle(); 1711 Style.BreakBeforeBraces = FormatStyle::BraceBreakingStyle::BS_Custom; 1712 1713 verifyFormat("do {\n" 1714 " foo();\n" 1715 "} while (1);", 1716 Style); 1717 Style.BraceWrapping.BeforeWhile = true; 1718 verifyFormat("do {\n" 1719 " foo();\n" 1720 "}\n" 1721 "while (1);", 1722 Style); 1723 } 1724 1725 //===----------------------------------------------------------------------===// 1726 // Tests for classes, namespaces, etc. 1727 //===----------------------------------------------------------------------===// 1728 1729 TEST_F(FormatTest, DoesNotBreakSemiAfterClassDecl) { 1730 verifyFormat("class A {};"); 1731 } 1732 1733 TEST_F(FormatTest, UnderstandsAccessSpecifiers) { 1734 verifyFormat("class A {\n" 1735 "public:\n" 1736 "public: // comment\n" 1737 "protected:\n" 1738 "private:\n" 1739 " void f() {}\n" 1740 "};"); 1741 verifyFormat("export class A {\n" 1742 "public:\n" 1743 "public: // comment\n" 1744 "protected:\n" 1745 "private:\n" 1746 " void f() {}\n" 1747 "};"); 1748 verifyGoogleFormat("class A {\n" 1749 " public:\n" 1750 " protected:\n" 1751 " private:\n" 1752 " void f() {}\n" 1753 "};"); 1754 verifyGoogleFormat("export class A {\n" 1755 " public:\n" 1756 " protected:\n" 1757 " private:\n" 1758 " void f() {}\n" 1759 "};"); 1760 verifyFormat("class A {\n" 1761 "public slots:\n" 1762 " void f1() {}\n" 1763 "public Q_SLOTS:\n" 1764 " void f2() {}\n" 1765 "protected slots:\n" 1766 " void f3() {}\n" 1767 "protected Q_SLOTS:\n" 1768 " void f4() {}\n" 1769 "private slots:\n" 1770 " void f5() {}\n" 1771 "private Q_SLOTS:\n" 1772 " void f6() {}\n" 1773 "signals:\n" 1774 " void g1();\n" 1775 "Q_SIGNALS:\n" 1776 " void g2();\n" 1777 "};"); 1778 1779 // Don't interpret 'signals' the wrong way. 1780 verifyFormat("signals.set();"); 1781 verifyFormat("for (Signals signals : f()) {\n}"); 1782 verifyFormat("{\n" 1783 " signals.set(); // This needs indentation.\n" 1784 "}"); 1785 verifyFormat("void f() {\n" 1786 "label:\n" 1787 " signals.baz();\n" 1788 "}"); 1789 } 1790 1791 TEST_F(FormatTest, SeparatesLogicalBlocks) { 1792 EXPECT_EQ("class A {\n" 1793 "public:\n" 1794 " void f();\n" 1795 "\n" 1796 "private:\n" 1797 " void g() {}\n" 1798 " // test\n" 1799 "protected:\n" 1800 " int h;\n" 1801 "};", 1802 format("class A {\n" 1803 "public:\n" 1804 "void f();\n" 1805 "private:\n" 1806 "void g() {}\n" 1807 "// test\n" 1808 "protected:\n" 1809 "int h;\n" 1810 "};")); 1811 EXPECT_EQ("class A {\n" 1812 "protected:\n" 1813 "public:\n" 1814 " void f();\n" 1815 "};", 1816 format("class A {\n" 1817 "protected:\n" 1818 "\n" 1819 "public:\n" 1820 "\n" 1821 " void f();\n" 1822 "};")); 1823 1824 // Even ensure proper spacing inside macros. 1825 EXPECT_EQ("#define B \\\n" 1826 " class A { \\\n" 1827 " protected: \\\n" 1828 " public: \\\n" 1829 " void f(); \\\n" 1830 " };", 1831 format("#define B \\\n" 1832 " class A { \\\n" 1833 " protected: \\\n" 1834 " \\\n" 1835 " public: \\\n" 1836 " \\\n" 1837 " void f(); \\\n" 1838 " };", 1839 getGoogleStyle())); 1840 // But don't remove empty lines after macros ending in access specifiers. 1841 EXPECT_EQ("#define A private:\n" 1842 "\n" 1843 "int i;", 1844 format("#define A private:\n" 1845 "\n" 1846 "int i;")); 1847 } 1848 1849 TEST_F(FormatTest, FormatsClasses) { 1850 verifyFormat("class A : public B {};"); 1851 verifyFormat("class A : public ::B {};"); 1852 1853 verifyFormat( 1854 "class AAAAAAAAAAAAAAAAAAAA : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n" 1855 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};"); 1856 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n" 1857 " : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n" 1858 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};"); 1859 verifyFormat( 1860 "class A : public B, public C, public D, public E, public F {};"); 1861 verifyFormat("class AAAAAAAAAAAA : public B,\n" 1862 " public C,\n" 1863 " public D,\n" 1864 " public E,\n" 1865 " public F,\n" 1866 " public G {};"); 1867 1868 verifyFormat("class\n" 1869 " ReallyReallyLongClassName {\n" 1870 " int i;\n" 1871 "};", 1872 getLLVMStyleWithColumns(32)); 1873 verifyFormat("struct aaaaaaaaaaaaa : public aaaaaaaaaaaaaaaaaaa< // break\n" 1874 " aaaaaaaaaaaaaaaa> {};"); 1875 verifyFormat("struct aaaaaaaaaaaaaaaaaaaa\n" 1876 " : public aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaa,\n" 1877 " aaaaaaaaaaaaaaaaaaaaaa> {};"); 1878 verifyFormat("template <class R, class C>\n" 1879 "struct Aaaaaaaaaaaaaaaaa<R (C::*)(int) const>\n" 1880 " : Aaaaaaaaaaaaaaaaa<R (C::*)(int)> {};"); 1881 verifyFormat("class ::A::B {};"); 1882 } 1883 1884 TEST_F(FormatTest, BreakInheritanceStyle) { 1885 FormatStyle StyleWithInheritanceBreakBeforeComma = getLLVMStyle(); 1886 StyleWithInheritanceBreakBeforeComma.BreakInheritanceList = 1887 FormatStyle::BILS_BeforeComma; 1888 verifyFormat("class MyClass : public X {};", 1889 StyleWithInheritanceBreakBeforeComma); 1890 verifyFormat("class MyClass\n" 1891 " : public X\n" 1892 " , public Y {};", 1893 StyleWithInheritanceBreakBeforeComma); 1894 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAA\n" 1895 " : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n" 1896 " , public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};", 1897 StyleWithInheritanceBreakBeforeComma); 1898 verifyFormat("struct aaaaaaaaaaaaa\n" 1899 " : public aaaaaaaaaaaaaaaaaaa< // break\n" 1900 " aaaaaaaaaaaaaaaa> {};", 1901 StyleWithInheritanceBreakBeforeComma); 1902 1903 FormatStyle StyleWithInheritanceBreakAfterColon = getLLVMStyle(); 1904 StyleWithInheritanceBreakAfterColon.BreakInheritanceList = 1905 FormatStyle::BILS_AfterColon; 1906 verifyFormat("class MyClass : public X {};", 1907 StyleWithInheritanceBreakAfterColon); 1908 verifyFormat("class MyClass : public X, public Y {};", 1909 StyleWithInheritanceBreakAfterColon); 1910 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAA :\n" 1911 " public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n" 1912 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};", 1913 StyleWithInheritanceBreakAfterColon); 1914 verifyFormat("struct aaaaaaaaaaaaa :\n" 1915 " public aaaaaaaaaaaaaaaaaaa< // break\n" 1916 " aaaaaaaaaaaaaaaa> {};", 1917 StyleWithInheritanceBreakAfterColon); 1918 } 1919 1920 TEST_F(FormatTest, FormatsVariableDeclarationsAfterStructOrClass) { 1921 verifyFormat("class A {\n} a, b;"); 1922 verifyFormat("struct A {\n} a, b;"); 1923 verifyFormat("union A {\n} a;"); 1924 } 1925 1926 TEST_F(FormatTest, FormatsEnum) { 1927 verifyFormat("enum {\n" 1928 " Zero,\n" 1929 " One = 1,\n" 1930 " Two = One + 1,\n" 1931 " Three = (One + Two),\n" 1932 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1933 " Five = (One, Two, Three, Four, 5)\n" 1934 "};"); 1935 verifyGoogleFormat("enum {\n" 1936 " Zero,\n" 1937 " One = 1,\n" 1938 " Two = One + 1,\n" 1939 " Three = (One + Two),\n" 1940 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1941 " Five = (One, Two, Three, Four, 5)\n" 1942 "};"); 1943 verifyFormat("enum Enum {};"); 1944 verifyFormat("enum {};"); 1945 verifyFormat("enum X E {} d;"); 1946 verifyFormat("enum __attribute__((...)) E {} d;"); 1947 verifyFormat("enum __declspec__((...)) E {} d;"); 1948 verifyFormat("enum {\n" 1949 " Bar = Foo<int, int>::value\n" 1950 "};", 1951 getLLVMStyleWithColumns(30)); 1952 1953 verifyFormat("enum ShortEnum { A, B, C };"); 1954 verifyGoogleFormat("enum ShortEnum { A, B, C };"); 1955 1956 EXPECT_EQ("enum KeepEmptyLines {\n" 1957 " ONE,\n" 1958 "\n" 1959 " TWO,\n" 1960 "\n" 1961 " THREE\n" 1962 "}", 1963 format("enum KeepEmptyLines {\n" 1964 " ONE,\n" 1965 "\n" 1966 " TWO,\n" 1967 "\n" 1968 "\n" 1969 " THREE\n" 1970 "}")); 1971 verifyFormat("enum E { // comment\n" 1972 " ONE,\n" 1973 " TWO\n" 1974 "};\n" 1975 "int i;"); 1976 1977 FormatStyle EightIndent = getLLVMStyle(); 1978 EightIndent.IndentWidth = 8; 1979 verifyFormat("enum {\n" 1980 " VOID,\n" 1981 " CHAR,\n" 1982 " SHORT,\n" 1983 " INT,\n" 1984 " LONG,\n" 1985 " SIGNED,\n" 1986 " UNSIGNED,\n" 1987 " BOOL,\n" 1988 " FLOAT,\n" 1989 " DOUBLE,\n" 1990 " COMPLEX\n" 1991 "};", 1992 EightIndent); 1993 1994 // Not enums. 1995 verifyFormat("enum X f() {\n" 1996 " a();\n" 1997 " return 42;\n" 1998 "}"); 1999 verifyFormat("enum X Type::f() {\n" 2000 " a();\n" 2001 " return 42;\n" 2002 "}"); 2003 verifyFormat("enum ::X f() {\n" 2004 " a();\n" 2005 " return 42;\n" 2006 "}"); 2007 verifyFormat("enum ns::X f() {\n" 2008 " a();\n" 2009 " return 42;\n" 2010 "}"); 2011 } 2012 2013 TEST_F(FormatTest, FormatsEnumsWithErrors) { 2014 verifyFormat("enum Type {\n" 2015 " One = 0; // These semicolons should be commas.\n" 2016 " Two = 1;\n" 2017 "};"); 2018 verifyFormat("namespace n {\n" 2019 "enum Type {\n" 2020 " One,\n" 2021 " Two, // missing };\n" 2022 " int i;\n" 2023 "}\n" 2024 "void g() {}"); 2025 } 2026 2027 TEST_F(FormatTest, FormatsEnumStruct) { 2028 verifyFormat("enum struct {\n" 2029 " Zero,\n" 2030 " One = 1,\n" 2031 " Two = One + 1,\n" 2032 " Three = (One + Two),\n" 2033 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 2034 " Five = (One, Two, Three, Four, 5)\n" 2035 "};"); 2036 verifyFormat("enum struct Enum {};"); 2037 verifyFormat("enum struct {};"); 2038 verifyFormat("enum struct X E {} d;"); 2039 verifyFormat("enum struct __attribute__((...)) E {} d;"); 2040 verifyFormat("enum struct __declspec__((...)) E {} d;"); 2041 verifyFormat("enum struct X f() {\n a();\n return 42;\n}"); 2042 } 2043 2044 TEST_F(FormatTest, FormatsEnumClass) { 2045 verifyFormat("enum class {\n" 2046 " Zero,\n" 2047 " One = 1,\n" 2048 " Two = One + 1,\n" 2049 " Three = (One + Two),\n" 2050 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 2051 " Five = (One, Two, Three, Four, 5)\n" 2052 "};"); 2053 verifyFormat("enum class Enum {};"); 2054 verifyFormat("enum class {};"); 2055 verifyFormat("enum class X E {} d;"); 2056 verifyFormat("enum class __attribute__((...)) E {} d;"); 2057 verifyFormat("enum class __declspec__((...)) E {} d;"); 2058 verifyFormat("enum class X f() {\n a();\n return 42;\n}"); 2059 } 2060 2061 TEST_F(FormatTest, FormatsEnumTypes) { 2062 verifyFormat("enum X : int {\n" 2063 " A, // Force multiple lines.\n" 2064 " B\n" 2065 "};"); 2066 verifyFormat("enum X : int { A, B };"); 2067 verifyFormat("enum X : std::uint32_t { A, B };"); 2068 } 2069 2070 TEST_F(FormatTest, FormatsTypedefEnum) { 2071 FormatStyle Style = getLLVMStyle(); 2072 Style.ColumnLimit = 40; 2073 verifyFormat("typedef enum {} EmptyEnum;"); 2074 verifyFormat("typedef enum { A, B, C } ShortEnum;"); 2075 verifyFormat("typedef enum {\n" 2076 " ZERO = 0,\n" 2077 " ONE = 1,\n" 2078 " TWO = 2,\n" 2079 " THREE = 3\n" 2080 "} LongEnum;", 2081 Style); 2082 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 2083 Style.BraceWrapping.AfterEnum = true; 2084 verifyFormat("typedef enum {} EmptyEnum;"); 2085 verifyFormat("typedef enum { A, B, C } ShortEnum;"); 2086 verifyFormat("typedef enum\n" 2087 "{\n" 2088 " ZERO = 0,\n" 2089 " ONE = 1,\n" 2090 " TWO = 2,\n" 2091 " THREE = 3\n" 2092 "} LongEnum;", 2093 Style); 2094 } 2095 2096 TEST_F(FormatTest, FormatsNSEnums) { 2097 verifyGoogleFormat("typedef NS_ENUM(NSInteger, SomeName) { AAA, BBB }"); 2098 verifyGoogleFormat( 2099 "typedef NS_CLOSED_ENUM(NSInteger, SomeName) { AAA, BBB }"); 2100 verifyGoogleFormat("typedef NS_ENUM(NSInteger, MyType) {\n" 2101 " // Information about someDecentlyLongValue.\n" 2102 " someDecentlyLongValue,\n" 2103 " // Information about anotherDecentlyLongValue.\n" 2104 " anotherDecentlyLongValue,\n" 2105 " // Information about aThirdDecentlyLongValue.\n" 2106 " aThirdDecentlyLongValue\n" 2107 "};"); 2108 verifyGoogleFormat("typedef NS_CLOSED_ENUM(NSInteger, MyType) {\n" 2109 " // Information about someDecentlyLongValue.\n" 2110 " someDecentlyLongValue,\n" 2111 " // Information about anotherDecentlyLongValue.\n" 2112 " anotherDecentlyLongValue,\n" 2113 " // Information about aThirdDecentlyLongValue.\n" 2114 " aThirdDecentlyLongValue\n" 2115 "};"); 2116 verifyGoogleFormat("typedef NS_OPTIONS(NSInteger, MyType) {\n" 2117 " a = 1,\n" 2118 " b = 2,\n" 2119 " c = 3,\n" 2120 "};"); 2121 verifyGoogleFormat("typedef CF_ENUM(NSInteger, MyType) {\n" 2122 " a = 1,\n" 2123 " b = 2,\n" 2124 " c = 3,\n" 2125 "};"); 2126 verifyGoogleFormat("typedef CF_CLOSED_ENUM(NSInteger, MyType) {\n" 2127 " a = 1,\n" 2128 " b = 2,\n" 2129 " c = 3,\n" 2130 "};"); 2131 verifyGoogleFormat("typedef CF_OPTIONS(NSInteger, MyType) {\n" 2132 " a = 1,\n" 2133 " b = 2,\n" 2134 " c = 3,\n" 2135 "};"); 2136 } 2137 2138 TEST_F(FormatTest, FormatsBitfields) { 2139 verifyFormat("struct Bitfields {\n" 2140 " unsigned sClass : 8;\n" 2141 " unsigned ValueKind : 2;\n" 2142 "};"); 2143 verifyFormat("struct A {\n" 2144 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa : 1,\n" 2145 " bbbbbbbbbbbbbbbbbbbbbbbbb;\n" 2146 "};"); 2147 verifyFormat("struct MyStruct {\n" 2148 " uchar data;\n" 2149 " uchar : 8;\n" 2150 " uchar : 8;\n" 2151 " uchar other;\n" 2152 "};"); 2153 } 2154 2155 TEST_F(FormatTest, FormatsNamespaces) { 2156 FormatStyle LLVMWithNoNamespaceFix = getLLVMStyle(); 2157 LLVMWithNoNamespaceFix.FixNamespaceComments = false; 2158 2159 verifyFormat("namespace some_namespace {\n" 2160 "class A {};\n" 2161 "void f() { f(); }\n" 2162 "}", 2163 LLVMWithNoNamespaceFix); 2164 verifyFormat("namespace N::inline D {\n" 2165 "class A {};\n" 2166 "void f() { f(); }\n" 2167 "}", 2168 LLVMWithNoNamespaceFix); 2169 verifyFormat("namespace N::inline D::E {\n" 2170 "class A {};\n" 2171 "void f() { f(); }\n" 2172 "}", 2173 LLVMWithNoNamespaceFix); 2174 verifyFormat("namespace [[deprecated(\"foo[bar\")]] some_namespace {\n" 2175 "class A {};\n" 2176 "void f() { f(); }\n" 2177 "}", 2178 LLVMWithNoNamespaceFix); 2179 verifyFormat("/* something */ namespace some_namespace {\n" 2180 "class A {};\n" 2181 "void f() { f(); }\n" 2182 "}", 2183 LLVMWithNoNamespaceFix); 2184 verifyFormat("namespace {\n" 2185 "class A {};\n" 2186 "void f() { f(); }\n" 2187 "}", 2188 LLVMWithNoNamespaceFix); 2189 verifyFormat("/* something */ namespace {\n" 2190 "class A {};\n" 2191 "void f() { f(); }\n" 2192 "}", 2193 LLVMWithNoNamespaceFix); 2194 verifyFormat("inline namespace X {\n" 2195 "class A {};\n" 2196 "void f() { f(); }\n" 2197 "}", 2198 LLVMWithNoNamespaceFix); 2199 verifyFormat("/* something */ inline namespace X {\n" 2200 "class A {};\n" 2201 "void f() { f(); }\n" 2202 "}", 2203 LLVMWithNoNamespaceFix); 2204 verifyFormat("export namespace X {\n" 2205 "class A {};\n" 2206 "void f() { f(); }\n" 2207 "}", 2208 LLVMWithNoNamespaceFix); 2209 verifyFormat("using namespace some_namespace;\n" 2210 "class A {};\n" 2211 "void f() { f(); }", 2212 LLVMWithNoNamespaceFix); 2213 2214 // This code is more common than we thought; if we 2215 // layout this correctly the semicolon will go into 2216 // its own line, which is undesirable. 2217 verifyFormat("namespace {};", LLVMWithNoNamespaceFix); 2218 verifyFormat("namespace {\n" 2219 "class A {};\n" 2220 "};", 2221 LLVMWithNoNamespaceFix); 2222 2223 verifyFormat("namespace {\n" 2224 "int SomeVariable = 0; // comment\n" 2225 "} // namespace", 2226 LLVMWithNoNamespaceFix); 2227 EXPECT_EQ("#ifndef HEADER_GUARD\n" 2228 "#define HEADER_GUARD\n" 2229 "namespace my_namespace {\n" 2230 "int i;\n" 2231 "} // my_namespace\n" 2232 "#endif // HEADER_GUARD", 2233 format("#ifndef HEADER_GUARD\n" 2234 " #define HEADER_GUARD\n" 2235 " namespace my_namespace {\n" 2236 "int i;\n" 2237 "} // my_namespace\n" 2238 "#endif // HEADER_GUARD", 2239 LLVMWithNoNamespaceFix)); 2240 2241 EXPECT_EQ("namespace A::B {\n" 2242 "class C {};\n" 2243 "}", 2244 format("namespace A::B {\n" 2245 "class C {};\n" 2246 "}", 2247 LLVMWithNoNamespaceFix)); 2248 2249 FormatStyle Style = getLLVMStyle(); 2250 Style.NamespaceIndentation = FormatStyle::NI_All; 2251 EXPECT_EQ("namespace out {\n" 2252 " int i;\n" 2253 " namespace in {\n" 2254 " int i;\n" 2255 " } // namespace in\n" 2256 "} // namespace out", 2257 format("namespace out {\n" 2258 "int i;\n" 2259 "namespace in {\n" 2260 "int i;\n" 2261 "} // namespace in\n" 2262 "} // namespace out", 2263 Style)); 2264 2265 Style.NamespaceIndentation = FormatStyle::NI_Inner; 2266 EXPECT_EQ("namespace out {\n" 2267 "int i;\n" 2268 "namespace in {\n" 2269 " int i;\n" 2270 "} // namespace in\n" 2271 "} // namespace out", 2272 format("namespace out {\n" 2273 "int i;\n" 2274 "namespace in {\n" 2275 "int i;\n" 2276 "} // namespace in\n" 2277 "} // namespace out", 2278 Style)); 2279 } 2280 2281 TEST_F(FormatTest, NamespaceMacros) { 2282 FormatStyle Style = getLLVMStyle(); 2283 Style.NamespaceMacros.push_back("TESTSUITE"); 2284 2285 verifyFormat("TESTSUITE(A) {\n" 2286 "int foo();\n" 2287 "} // TESTSUITE(A)", 2288 Style); 2289 2290 verifyFormat("TESTSUITE(A, B) {\n" 2291 "int foo();\n" 2292 "} // TESTSUITE(A)", 2293 Style); 2294 2295 // Properly indent according to NamespaceIndentation style 2296 Style.NamespaceIndentation = FormatStyle::NI_All; 2297 verifyFormat("TESTSUITE(A) {\n" 2298 " int foo();\n" 2299 "} // TESTSUITE(A)", 2300 Style); 2301 verifyFormat("TESTSUITE(A) {\n" 2302 " namespace B {\n" 2303 " int foo();\n" 2304 " } // namespace B\n" 2305 "} // TESTSUITE(A)", 2306 Style); 2307 verifyFormat("namespace A {\n" 2308 " TESTSUITE(B) {\n" 2309 " int foo();\n" 2310 " } // TESTSUITE(B)\n" 2311 "} // namespace A", 2312 Style); 2313 2314 Style.NamespaceIndentation = FormatStyle::NI_Inner; 2315 verifyFormat("TESTSUITE(A) {\n" 2316 "TESTSUITE(B) {\n" 2317 " int foo();\n" 2318 "} // TESTSUITE(B)\n" 2319 "} // TESTSUITE(A)", 2320 Style); 2321 verifyFormat("TESTSUITE(A) {\n" 2322 "namespace B {\n" 2323 " int foo();\n" 2324 "} // namespace B\n" 2325 "} // TESTSUITE(A)", 2326 Style); 2327 verifyFormat("namespace A {\n" 2328 "TESTSUITE(B) {\n" 2329 " int foo();\n" 2330 "} // TESTSUITE(B)\n" 2331 "} // namespace A", 2332 Style); 2333 2334 // Properly merge namespace-macros blocks in CompactNamespaces mode 2335 Style.NamespaceIndentation = FormatStyle::NI_None; 2336 Style.CompactNamespaces = true; 2337 verifyFormat("TESTSUITE(A) { TESTSUITE(B) {\n" 2338 "}} // TESTSUITE(A::B)", 2339 Style); 2340 2341 EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n" 2342 "}} // TESTSUITE(out::in)", 2343 format("TESTSUITE(out) {\n" 2344 "TESTSUITE(in) {\n" 2345 "} // TESTSUITE(in)\n" 2346 "} // TESTSUITE(out)", 2347 Style)); 2348 2349 EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n" 2350 "}} // TESTSUITE(out::in)", 2351 format("TESTSUITE(out) {\n" 2352 "TESTSUITE(in) {\n" 2353 "} // TESTSUITE(in)\n" 2354 "} // TESTSUITE(out)", 2355 Style)); 2356 2357 // Do not merge different namespaces/macros 2358 EXPECT_EQ("namespace out {\n" 2359 "TESTSUITE(in) {\n" 2360 "} // TESTSUITE(in)\n" 2361 "} // namespace out", 2362 format("namespace out {\n" 2363 "TESTSUITE(in) {\n" 2364 "} // TESTSUITE(in)\n" 2365 "} // namespace out", 2366 Style)); 2367 EXPECT_EQ("TESTSUITE(out) {\n" 2368 "namespace in {\n" 2369 "} // namespace in\n" 2370 "} // TESTSUITE(out)", 2371 format("TESTSUITE(out) {\n" 2372 "namespace in {\n" 2373 "} // namespace in\n" 2374 "} // TESTSUITE(out)", 2375 Style)); 2376 Style.NamespaceMacros.push_back("FOOBAR"); 2377 EXPECT_EQ("TESTSUITE(out) {\n" 2378 "FOOBAR(in) {\n" 2379 "} // FOOBAR(in)\n" 2380 "} // TESTSUITE(out)", 2381 format("TESTSUITE(out) {\n" 2382 "FOOBAR(in) {\n" 2383 "} // FOOBAR(in)\n" 2384 "} // TESTSUITE(out)", 2385 Style)); 2386 } 2387 2388 TEST_F(FormatTest, FormatsCompactNamespaces) { 2389 FormatStyle Style = getLLVMStyle(); 2390 Style.CompactNamespaces = true; 2391 Style.NamespaceMacros.push_back("TESTSUITE"); 2392 2393 verifyFormat("namespace A { namespace B {\n" 2394 "}} // namespace A::B", 2395 Style); 2396 2397 EXPECT_EQ("namespace out { namespace in {\n" 2398 "}} // namespace out::in", 2399 format("namespace out {\n" 2400 "namespace in {\n" 2401 "} // namespace in\n" 2402 "} // namespace out", 2403 Style)); 2404 2405 // Only namespaces which have both consecutive opening and end get compacted 2406 EXPECT_EQ("namespace out {\n" 2407 "namespace in1 {\n" 2408 "} // namespace in1\n" 2409 "namespace in2 {\n" 2410 "} // namespace in2\n" 2411 "} // namespace out", 2412 format("namespace out {\n" 2413 "namespace in1 {\n" 2414 "} // namespace in1\n" 2415 "namespace in2 {\n" 2416 "} // namespace in2\n" 2417 "} // namespace out", 2418 Style)); 2419 2420 EXPECT_EQ("namespace out {\n" 2421 "int i;\n" 2422 "namespace in {\n" 2423 "int j;\n" 2424 "} // namespace in\n" 2425 "int k;\n" 2426 "} // namespace out", 2427 format("namespace out { int i;\n" 2428 "namespace in { int j; } // namespace in\n" 2429 "int k; } // namespace out", 2430 Style)); 2431 2432 EXPECT_EQ("namespace A { namespace B { namespace C {\n" 2433 "}}} // namespace A::B::C\n", 2434 format("namespace A { namespace B {\n" 2435 "namespace C {\n" 2436 "}} // namespace B::C\n" 2437 "} // namespace A\n", 2438 Style)); 2439 2440 Style.ColumnLimit = 40; 2441 EXPECT_EQ("namespace aaaaaaaaaa {\n" 2442 "namespace bbbbbbbbbb {\n" 2443 "}} // namespace aaaaaaaaaa::bbbbbbbbbb", 2444 format("namespace aaaaaaaaaa {\n" 2445 "namespace bbbbbbbbbb {\n" 2446 "} // namespace bbbbbbbbbb\n" 2447 "} // namespace aaaaaaaaaa", 2448 Style)); 2449 2450 EXPECT_EQ("namespace aaaaaa { namespace bbbbbb {\n" 2451 "namespace cccccc {\n" 2452 "}}} // namespace aaaaaa::bbbbbb::cccccc", 2453 format("namespace aaaaaa {\n" 2454 "namespace bbbbbb {\n" 2455 "namespace cccccc {\n" 2456 "} // namespace cccccc\n" 2457 "} // namespace bbbbbb\n" 2458 "} // namespace aaaaaa", 2459 Style)); 2460 Style.ColumnLimit = 80; 2461 2462 // Extra semicolon after 'inner' closing brace prevents merging 2463 EXPECT_EQ("namespace out { namespace in {\n" 2464 "}; } // namespace out::in", 2465 format("namespace out {\n" 2466 "namespace in {\n" 2467 "}; // namespace in\n" 2468 "} // namespace out", 2469 Style)); 2470 2471 // Extra semicolon after 'outer' closing brace is conserved 2472 EXPECT_EQ("namespace out { namespace in {\n" 2473 "}}; // namespace out::in", 2474 format("namespace out {\n" 2475 "namespace in {\n" 2476 "} // namespace in\n" 2477 "}; // namespace out", 2478 Style)); 2479 2480 Style.NamespaceIndentation = FormatStyle::NI_All; 2481 EXPECT_EQ("namespace out { namespace in {\n" 2482 " int i;\n" 2483 "}} // namespace out::in", 2484 format("namespace out {\n" 2485 "namespace in {\n" 2486 "int i;\n" 2487 "} // namespace in\n" 2488 "} // namespace out", 2489 Style)); 2490 EXPECT_EQ("namespace out { namespace mid {\n" 2491 " namespace in {\n" 2492 " int j;\n" 2493 " } // namespace in\n" 2494 " int k;\n" 2495 "}} // namespace out::mid", 2496 format("namespace out { namespace mid {\n" 2497 "namespace in { int j; } // namespace in\n" 2498 "int k; }} // namespace out::mid", 2499 Style)); 2500 2501 Style.NamespaceIndentation = FormatStyle::NI_Inner; 2502 EXPECT_EQ("namespace out { namespace in {\n" 2503 " int i;\n" 2504 "}} // namespace out::in", 2505 format("namespace out {\n" 2506 "namespace in {\n" 2507 "int i;\n" 2508 "} // namespace in\n" 2509 "} // namespace out", 2510 Style)); 2511 EXPECT_EQ("namespace out { namespace mid { namespace in {\n" 2512 " int i;\n" 2513 "}}} // namespace out::mid::in", 2514 format("namespace out {\n" 2515 "namespace mid {\n" 2516 "namespace in {\n" 2517 "int i;\n" 2518 "} // namespace in\n" 2519 "} // namespace mid\n" 2520 "} // namespace out", 2521 Style)); 2522 } 2523 2524 TEST_F(FormatTest, FormatsExternC) { 2525 verifyFormat("extern \"C\" {\nint a;"); 2526 verifyFormat("extern \"C\" {}"); 2527 verifyFormat("extern \"C\" {\n" 2528 "int foo();\n" 2529 "}"); 2530 verifyFormat("extern \"C\" int foo() {}"); 2531 verifyFormat("extern \"C\" int foo();"); 2532 verifyFormat("extern \"C\" int foo() {\n" 2533 " int i = 42;\n" 2534 " return i;\n" 2535 "}"); 2536 2537 FormatStyle Style = getLLVMStyle(); 2538 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 2539 Style.BraceWrapping.AfterFunction = true; 2540 verifyFormat("extern \"C\" int foo() {}", Style); 2541 verifyFormat("extern \"C\" int foo();", Style); 2542 verifyFormat("extern \"C\" int foo()\n" 2543 "{\n" 2544 " int i = 42;\n" 2545 " return i;\n" 2546 "}", 2547 Style); 2548 2549 Style.BraceWrapping.AfterExternBlock = true; 2550 Style.BraceWrapping.SplitEmptyRecord = false; 2551 verifyFormat("extern \"C\"\n" 2552 "{}", 2553 Style); 2554 verifyFormat("extern \"C\"\n" 2555 "{\n" 2556 " int foo();\n" 2557 "}", 2558 Style); 2559 } 2560 2561 TEST_F(FormatTest, FormatsInlineASM) { 2562 verifyFormat("asm(\"xyz\" : \"=a\"(a), \"=d\"(b) : \"a\"(data));"); 2563 verifyFormat("asm(\"nop\" ::: \"memory\");"); 2564 verifyFormat( 2565 "asm(\"movq\\t%%rbx, %%rsi\\n\\t\"\n" 2566 " \"cpuid\\n\\t\"\n" 2567 " \"xchgq\\t%%rbx, %%rsi\\n\\t\"\n" 2568 " : \"=a\"(*rEAX), \"=S\"(*rEBX), \"=c\"(*rECX), \"=d\"(*rEDX)\n" 2569 " : \"a\"(value));"); 2570 EXPECT_EQ( 2571 "void NS_InvokeByIndex(void *that, unsigned int methodIndex) {\n" 2572 " __asm {\n" 2573 " mov edx,[that] // vtable in edx\n" 2574 " mov eax,methodIndex\n" 2575 " call [edx][eax*4] // stdcall\n" 2576 " }\n" 2577 "}", 2578 format("void NS_InvokeByIndex(void *that, unsigned int methodIndex) {\n" 2579 " __asm {\n" 2580 " mov edx,[that] // vtable in edx\n" 2581 " mov eax,methodIndex\n" 2582 " call [edx][eax*4] // stdcall\n" 2583 " }\n" 2584 "}")); 2585 EXPECT_EQ("_asm {\n" 2586 " xor eax, eax;\n" 2587 " cpuid;\n" 2588 "}", 2589 format("_asm {\n" 2590 " xor eax, eax;\n" 2591 " cpuid;\n" 2592 "}")); 2593 verifyFormat("void function() {\n" 2594 " // comment\n" 2595 " asm(\"\");\n" 2596 "}"); 2597 EXPECT_EQ("__asm {\n" 2598 "}\n" 2599 "int i;", 2600 format("__asm {\n" 2601 "}\n" 2602 "int i;")); 2603 } 2604 2605 TEST_F(FormatTest, FormatTryCatch) { 2606 verifyFormat("try {\n" 2607 " throw a * b;\n" 2608 "} catch (int a) {\n" 2609 " // Do nothing.\n" 2610 "} catch (...) {\n" 2611 " exit(42);\n" 2612 "}"); 2613 2614 // Function-level try statements. 2615 verifyFormat("int f() try { return 4; } catch (...) {\n" 2616 " return 5;\n" 2617 "}"); 2618 verifyFormat("class A {\n" 2619 " int a;\n" 2620 " A() try : a(0) {\n" 2621 " } catch (...) {\n" 2622 " throw;\n" 2623 " }\n" 2624 "};\n"); 2625 2626 // Incomplete try-catch blocks. 2627 verifyIncompleteFormat("try {} catch ("); 2628 } 2629 2630 TEST_F(FormatTest, FormatSEHTryCatch) { 2631 verifyFormat("__try {\n" 2632 " int a = b * c;\n" 2633 "} __except (EXCEPTION_EXECUTE_HANDLER) {\n" 2634 " // Do nothing.\n" 2635 "}"); 2636 2637 verifyFormat("__try {\n" 2638 " int a = b * c;\n" 2639 "} __finally {\n" 2640 " // Do nothing.\n" 2641 "}"); 2642 2643 verifyFormat("DEBUG({\n" 2644 " __try {\n" 2645 " } __finally {\n" 2646 " }\n" 2647 "});\n"); 2648 } 2649 2650 TEST_F(FormatTest, IncompleteTryCatchBlocks) { 2651 verifyFormat("try {\n" 2652 " f();\n" 2653 "} catch {\n" 2654 " g();\n" 2655 "}"); 2656 verifyFormat("try {\n" 2657 " f();\n" 2658 "} catch (A a) MACRO(x) {\n" 2659 " g();\n" 2660 "} catch (B b) MACRO(x) {\n" 2661 " g();\n" 2662 "}"); 2663 } 2664 2665 TEST_F(FormatTest, FormatTryCatchBraceStyles) { 2666 FormatStyle Style = getLLVMStyle(); 2667 for (auto BraceStyle : {FormatStyle::BS_Attach, FormatStyle::BS_Mozilla, 2668 FormatStyle::BS_WebKit}) { 2669 Style.BreakBeforeBraces = BraceStyle; 2670 verifyFormat("try {\n" 2671 " // something\n" 2672 "} catch (...) {\n" 2673 " // something\n" 2674 "}", 2675 Style); 2676 } 2677 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 2678 verifyFormat("try {\n" 2679 " // something\n" 2680 "}\n" 2681 "catch (...) {\n" 2682 " // something\n" 2683 "}", 2684 Style); 2685 verifyFormat("__try {\n" 2686 " // something\n" 2687 "}\n" 2688 "__finally {\n" 2689 " // something\n" 2690 "}", 2691 Style); 2692 verifyFormat("@try {\n" 2693 " // something\n" 2694 "}\n" 2695 "@finally {\n" 2696 " // something\n" 2697 "}", 2698 Style); 2699 Style.BreakBeforeBraces = FormatStyle::BS_Allman; 2700 verifyFormat("try\n" 2701 "{\n" 2702 " // something\n" 2703 "}\n" 2704 "catch (...)\n" 2705 "{\n" 2706 " // something\n" 2707 "}", 2708 Style); 2709 Style.BreakBeforeBraces = FormatStyle::BS_Whitesmiths; 2710 verifyFormat("try\n" 2711 " {\n" 2712 " // something white\n" 2713 " }\n" 2714 "catch (...)\n" 2715 " {\n" 2716 " // something white\n" 2717 " }", 2718 Style); 2719 Style.BreakBeforeBraces = FormatStyle::BS_GNU; 2720 verifyFormat("try\n" 2721 " {\n" 2722 " // something\n" 2723 " }\n" 2724 "catch (...)\n" 2725 " {\n" 2726 " // something\n" 2727 " }", 2728 Style); 2729 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 2730 Style.BraceWrapping.BeforeCatch = true; 2731 verifyFormat("try {\n" 2732 " // something\n" 2733 "}\n" 2734 "catch (...) {\n" 2735 " // something\n" 2736 "}", 2737 Style); 2738 } 2739 2740 TEST_F(FormatTest, StaticInitializers) { 2741 verifyFormat("static SomeClass SC = {1, 'a'};"); 2742 2743 verifyFormat("static SomeClass WithALoooooooooooooooooooongName = {\n" 2744 " 100000000, " 2745 "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"};"); 2746 2747 // Here, everything other than the "}" would fit on a line. 2748 verifyFormat("static int LooooooooooooooooooooooooongVariable[1] = {\n" 2749 " 10000000000000000000000000};"); 2750 EXPECT_EQ("S s = {a,\n" 2751 "\n" 2752 " b};", 2753 format("S s = {\n" 2754 " a,\n" 2755 "\n" 2756 " b\n" 2757 "};")); 2758 2759 // FIXME: This would fit into the column limit if we'd fit "{ {" on the first 2760 // line. However, the formatting looks a bit off and this probably doesn't 2761 // happen often in practice. 2762 verifyFormat("static int Variable[1] = {\n" 2763 " {1000000000000000000000000000000000000}};", 2764 getLLVMStyleWithColumns(40)); 2765 } 2766 2767 TEST_F(FormatTest, DesignatedInitializers) { 2768 verifyFormat("const struct A a = {.a = 1, .b = 2};"); 2769 verifyFormat("const struct A a = {.aaaaaaaaaa = 1,\n" 2770 " .bbbbbbbbbb = 2,\n" 2771 " .cccccccccc = 3,\n" 2772 " .dddddddddd = 4,\n" 2773 " .eeeeeeeeee = 5};"); 2774 verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n" 2775 " .aaaaaaaaaaaaaaaaaaaaaaaaaaa = 1,\n" 2776 " .bbbbbbbbbbbbbbbbbbbbbbbbbbb = 2,\n" 2777 " .ccccccccccccccccccccccccccc = 3,\n" 2778 " .ddddddddddddddddddddddddddd = 4,\n" 2779 " .eeeeeeeeeeeeeeeeeeeeeeeeeee = 5};"); 2780 2781 verifyGoogleFormat("const struct A a = {.a = 1, .b = 2};"); 2782 2783 verifyFormat("const struct A a = {[0] = 1, [1] = 2};"); 2784 verifyFormat("const struct A a = {[1] = aaaaaaaaaa,\n" 2785 " [2] = bbbbbbbbbb,\n" 2786 " [3] = cccccccccc,\n" 2787 " [4] = dddddddddd,\n" 2788 " [5] = eeeeeeeeee};"); 2789 verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n" 2790 " [1] = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 2791 " [2] = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" 2792 " [3] = cccccccccccccccccccccccccccccccccccccc,\n" 2793 " [4] = dddddddddddddddddddddddddddddddddddddd,\n" 2794 " [5] = eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee};"); 2795 } 2796 2797 TEST_F(FormatTest, NestedStaticInitializers) { 2798 verifyFormat("static A x = {{{}}};\n"); 2799 verifyFormat("static A x = {{{init1, init2, init3, init4},\n" 2800 " {init1, init2, init3, init4}}};", 2801 getLLVMStyleWithColumns(50)); 2802 2803 verifyFormat("somes Status::global_reps[3] = {\n" 2804 " {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n" 2805 " {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n" 2806 " {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};", 2807 getLLVMStyleWithColumns(60)); 2808 verifyGoogleFormat("SomeType Status::global_reps[3] = {\n" 2809 " {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n" 2810 " {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n" 2811 " {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};"); 2812 verifyFormat("CGRect cg_rect = {{rect.fLeft, rect.fTop},\n" 2813 " {rect.fRight - rect.fLeft, rect.fBottom - " 2814 "rect.fTop}};"); 2815 2816 verifyFormat( 2817 "SomeArrayOfSomeType a = {\n" 2818 " {{1, 2, 3},\n" 2819 " {1, 2, 3},\n" 2820 " {111111111111111111111111111111, 222222222222222222222222222222,\n" 2821 " 333333333333333333333333333333},\n" 2822 " {1, 2, 3},\n" 2823 " {1, 2, 3}}};"); 2824 verifyFormat( 2825 "SomeArrayOfSomeType a = {\n" 2826 " {{1, 2, 3}},\n" 2827 " {{1, 2, 3}},\n" 2828 " {{111111111111111111111111111111, 222222222222222222222222222222,\n" 2829 " 333333333333333333333333333333}},\n" 2830 " {{1, 2, 3}},\n" 2831 " {{1, 2, 3}}};"); 2832 2833 verifyFormat("struct {\n" 2834 " unsigned bit;\n" 2835 " const char *const name;\n" 2836 "} kBitsToOs[] = {{kOsMac, \"Mac\"},\n" 2837 " {kOsWin, \"Windows\"},\n" 2838 " {kOsLinux, \"Linux\"},\n" 2839 " {kOsCrOS, \"Chrome OS\"}};"); 2840 verifyFormat("struct {\n" 2841 " unsigned bit;\n" 2842 " const char *const name;\n" 2843 "} kBitsToOs[] = {\n" 2844 " {kOsMac, \"Mac\"},\n" 2845 " {kOsWin, \"Windows\"},\n" 2846 " {kOsLinux, \"Linux\"},\n" 2847 " {kOsCrOS, \"Chrome OS\"},\n" 2848 "};"); 2849 } 2850 2851 TEST_F(FormatTest, FormatsSmallMacroDefinitionsInSingleLine) { 2852 verifyFormat("#define ALooooooooooooooooooooooooooooooooooooooongMacro(" 2853 " \\\n" 2854 " aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)"); 2855 } 2856 2857 TEST_F(FormatTest, DoesNotBreakPureVirtualFunctionDefinition) { 2858 verifyFormat("virtual void write(ELFWriter *writerrr,\n" 2859 " OwningPtr<FileOutputBuffer> &buffer) = 0;"); 2860 2861 // Do break defaulted and deleted functions. 2862 verifyFormat("virtual void ~Deeeeeeeestructor() =\n" 2863 " default;", 2864 getLLVMStyleWithColumns(40)); 2865 verifyFormat("virtual void ~Deeeeeeeestructor() =\n" 2866 " delete;", 2867 getLLVMStyleWithColumns(40)); 2868 } 2869 2870 TEST_F(FormatTest, BreaksStringLiteralsOnlyInDefine) { 2871 verifyFormat("# 1111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\" 2 3", 2872 getLLVMStyleWithColumns(40)); 2873 verifyFormat("#line 11111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"", 2874 getLLVMStyleWithColumns(40)); 2875 EXPECT_EQ("#define Q \\\n" 2876 " \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/\" \\\n" 2877 " \"aaaaaaaa.cpp\"", 2878 format("#define Q \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"", 2879 getLLVMStyleWithColumns(40))); 2880 } 2881 2882 TEST_F(FormatTest, UnderstandsLinePPDirective) { 2883 EXPECT_EQ("# 123 \"A string literal\"", 2884 format(" # 123 \"A string literal\"")); 2885 } 2886 2887 TEST_F(FormatTest, LayoutUnknownPPDirective) { 2888 EXPECT_EQ("#;", format("#;")); 2889 verifyFormat("#\n;\n;\n;"); 2890 } 2891 2892 TEST_F(FormatTest, UnescapedEndOfLineEndsPPDirective) { 2893 EXPECT_EQ("#line 42 \"test\"\n", 2894 format("# \\\n line \\\n 42 \\\n \"test\"\n")); 2895 EXPECT_EQ("#define A B\n", format("# \\\n define \\\n A \\\n B\n", 2896 getLLVMStyleWithColumns(12))); 2897 } 2898 2899 TEST_F(FormatTest, EndOfFileEndsPPDirective) { 2900 EXPECT_EQ("#line 42 \"test\"", 2901 format("# \\\n line \\\n 42 \\\n \"test\"")); 2902 EXPECT_EQ("#define A B", format("# \\\n define \\\n A \\\n B")); 2903 } 2904 2905 TEST_F(FormatTest, DoesntRemoveUnknownTokens) { 2906 verifyFormat("#define A \\x20"); 2907 verifyFormat("#define A \\ x20"); 2908 EXPECT_EQ("#define A \\ x20", format("#define A \\ x20")); 2909 verifyFormat("#define A ''"); 2910 verifyFormat("#define A ''qqq"); 2911 verifyFormat("#define A `qqq"); 2912 verifyFormat("f(\"aaaa, bbbb, \"\\\"ccccc\\\"\");"); 2913 EXPECT_EQ("const char *c = STRINGIFY(\n" 2914 "\\na : b);", 2915 format("const char * c = STRINGIFY(\n" 2916 "\\na : b);")); 2917 2918 verifyFormat("a\r\\"); 2919 verifyFormat("a\v\\"); 2920 verifyFormat("a\f\\"); 2921 } 2922 2923 TEST_F(FormatTest, IndentsPPDirectiveInReducedSpace) { 2924 verifyFormat("#define A(BB)", getLLVMStyleWithColumns(13)); 2925 verifyFormat("#define A( \\\n BB)", getLLVMStyleWithColumns(12)); 2926 verifyFormat("#define A( \\\n A, B)", getLLVMStyleWithColumns(12)); 2927 // FIXME: We never break before the macro name. 2928 verifyFormat("#define AA( \\\n B)", getLLVMStyleWithColumns(12)); 2929 2930 verifyFormat("#define A A\n#define A A"); 2931 verifyFormat("#define A(X) A\n#define A A"); 2932 2933 verifyFormat("#define Something Other", getLLVMStyleWithColumns(23)); 2934 verifyFormat("#define Something \\\n Other", getLLVMStyleWithColumns(22)); 2935 } 2936 2937 TEST_F(FormatTest, HandlePreprocessorDirectiveContext) { 2938 EXPECT_EQ("// somecomment\n" 2939 "#include \"a.h\"\n" 2940 "#define A( \\\n" 2941 " A, B)\n" 2942 "#include \"b.h\"\n" 2943 "// somecomment\n", 2944 format(" // somecomment\n" 2945 " #include \"a.h\"\n" 2946 "#define A(A,\\\n" 2947 " B)\n" 2948 " #include \"b.h\"\n" 2949 " // somecomment\n", 2950 getLLVMStyleWithColumns(13))); 2951 } 2952 2953 TEST_F(FormatTest, LayoutSingleHash) { EXPECT_EQ("#\na;", format("#\na;")); } 2954 2955 TEST_F(FormatTest, LayoutCodeInMacroDefinitions) { 2956 EXPECT_EQ("#define A \\\n" 2957 " c; \\\n" 2958 " e;\n" 2959 "f;", 2960 format("#define A c; e;\n" 2961 "f;", 2962 getLLVMStyleWithColumns(14))); 2963 } 2964 2965 TEST_F(FormatTest, LayoutRemainingTokens) { EXPECT_EQ("{}", format("{}")); } 2966 2967 TEST_F(FormatTest, MacroDefinitionInsideStatement) { 2968 EXPECT_EQ("int x,\n" 2969 "#define A\n" 2970 " y;", 2971 format("int x,\n#define A\ny;")); 2972 } 2973 2974 TEST_F(FormatTest, HashInMacroDefinition) { 2975 EXPECT_EQ("#define A(c) L#c", format("#define A(c) L#c", getLLVMStyle())); 2976 verifyFormat("#define A \\\n b #c;", getLLVMStyleWithColumns(11)); 2977 verifyFormat("#define A \\\n" 2978 " { \\\n" 2979 " f(#c); \\\n" 2980 " }", 2981 getLLVMStyleWithColumns(11)); 2982 2983 verifyFormat("#define A(X) \\\n" 2984 " void function##X()", 2985 getLLVMStyleWithColumns(22)); 2986 2987 verifyFormat("#define A(a, b, c) \\\n" 2988 " void a##b##c()", 2989 getLLVMStyleWithColumns(22)); 2990 2991 verifyFormat("#define A void # ## #", getLLVMStyleWithColumns(22)); 2992 } 2993 2994 TEST_F(FormatTest, RespectWhitespaceInMacroDefinitions) { 2995 EXPECT_EQ("#define A (x)", format("#define A (x)")); 2996 EXPECT_EQ("#define A(x)", format("#define A(x)")); 2997 2998 FormatStyle Style = getLLVMStyle(); 2999 Style.SpaceBeforeParens = FormatStyle::SBPO_Never; 3000 verifyFormat("#define true ((foo)1)", Style); 3001 Style.SpaceBeforeParens = FormatStyle::SBPO_Always; 3002 verifyFormat("#define false((foo)0)", Style); 3003 } 3004 3005 TEST_F(FormatTest, EmptyLinesInMacroDefinitions) { 3006 EXPECT_EQ("#define A b;", format("#define A \\\n" 3007 " \\\n" 3008 " b;", 3009 getLLVMStyleWithColumns(25))); 3010 EXPECT_EQ("#define A \\\n" 3011 " \\\n" 3012 " a; \\\n" 3013 " b;", 3014 format("#define A \\\n" 3015 " \\\n" 3016 " a; \\\n" 3017 " b;", 3018 getLLVMStyleWithColumns(11))); 3019 EXPECT_EQ("#define A \\\n" 3020 " a; \\\n" 3021 " \\\n" 3022 " b;", 3023 format("#define A \\\n" 3024 " a; \\\n" 3025 " \\\n" 3026 " b;", 3027 getLLVMStyleWithColumns(11))); 3028 } 3029 3030 TEST_F(FormatTest, MacroDefinitionsWithIncompleteCode) { 3031 verifyIncompleteFormat("#define A :"); 3032 verifyFormat("#define SOMECASES \\\n" 3033 " case 1: \\\n" 3034 " case 2\n", 3035 getLLVMStyleWithColumns(20)); 3036 verifyFormat("#define MACRO(a) \\\n" 3037 " if (a) \\\n" 3038 " f(); \\\n" 3039 " else \\\n" 3040 " g()", 3041 getLLVMStyleWithColumns(18)); 3042 verifyFormat("#define A template <typename T>"); 3043 verifyIncompleteFormat("#define STR(x) #x\n" 3044 "f(STR(this_is_a_string_literal{));"); 3045 verifyFormat("#pragma omp threadprivate( \\\n" 3046 " y)), // expected-warning", 3047 getLLVMStyleWithColumns(28)); 3048 verifyFormat("#d, = };"); 3049 verifyFormat("#if \"a"); 3050 verifyIncompleteFormat("({\n" 3051 "#define b \\\n" 3052 " } \\\n" 3053 " a\n" 3054 "a", 3055 getLLVMStyleWithColumns(15)); 3056 verifyFormat("#define A \\\n" 3057 " { \\\n" 3058 " {\n" 3059 "#define B \\\n" 3060 " } \\\n" 3061 " }", 3062 getLLVMStyleWithColumns(15)); 3063 verifyNoCrash("#if a\na(\n#else\n#endif\n{a"); 3064 verifyNoCrash("a={0,1\n#if a\n#else\n;\n#endif\n}"); 3065 verifyNoCrash("#if a\na(\n#else\n#endif\n) a {a,b,c,d,f,g};"); 3066 verifyNoCrash("#ifdef A\n a(\n #else\n #endif\n) = []() { \n)}"); 3067 } 3068 3069 TEST_F(FormatTest, MacrosWithoutTrailingSemicolon) { 3070 verifyFormat("SOME_TYPE_NAME abc;"); // Gated on the newline. 3071 EXPECT_EQ("class A : public QObject {\n" 3072 " Q_OBJECT\n" 3073 "\n" 3074 " A() {}\n" 3075 "};", 3076 format("class A : public QObject {\n" 3077 " Q_OBJECT\n" 3078 "\n" 3079 " A() {\n}\n" 3080 "} ;")); 3081 EXPECT_EQ("MACRO\n" 3082 "/*static*/ int i;", 3083 format("MACRO\n" 3084 " /*static*/ int i;")); 3085 EXPECT_EQ("SOME_MACRO\n" 3086 "namespace {\n" 3087 "void f();\n" 3088 "} // namespace", 3089 format("SOME_MACRO\n" 3090 " namespace {\n" 3091 "void f( );\n" 3092 "} // namespace")); 3093 // Only if the identifier contains at least 5 characters. 3094 EXPECT_EQ("HTTP f();", format("HTTP\nf();")); 3095 EXPECT_EQ("MACRO\nf();", format("MACRO\nf();")); 3096 // Only if everything is upper case. 3097 EXPECT_EQ("class A : public QObject {\n" 3098 " Q_Object A() {}\n" 3099 "};", 3100 format("class A : public QObject {\n" 3101 " Q_Object\n" 3102 " A() {\n}\n" 3103 "} ;")); 3104 3105 // Only if the next line can actually start an unwrapped line. 3106 EXPECT_EQ("SOME_WEIRD_LOG_MACRO << SomeThing;", 3107 format("SOME_WEIRD_LOG_MACRO\n" 3108 "<< SomeThing;")); 3109 3110 verifyFormat("VISIT_GL_CALL(GenBuffers, void, (GLsizei n, GLuint* buffers), " 3111 "(n, buffers))\n", 3112 getChromiumStyle(FormatStyle::LK_Cpp)); 3113 3114 // See PR41483 3115 EXPECT_EQ("/**/ FOO(a)\n" 3116 "FOO(b)", 3117 format("/**/ FOO(a)\n" 3118 "FOO(b)")); 3119 } 3120 3121 TEST_F(FormatTest, MacroCallsWithoutTrailingSemicolon) { 3122 EXPECT_EQ("INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n" 3123 "INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n" 3124 "INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n" 3125 "class X {};\n" 3126 "INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n" 3127 "int *createScopDetectionPass() { return 0; }", 3128 format(" INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n" 3129 " INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n" 3130 " INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n" 3131 " class X {};\n" 3132 " INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n" 3133 " int *createScopDetectionPass() { return 0; }")); 3134 // FIXME: We could probably treat IPC_BEGIN_MESSAGE_MAP/IPC_END_MESSAGE_MAP as 3135 // braces, so that inner block is indented one level more. 3136 EXPECT_EQ("int q() {\n" 3137 " IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n" 3138 " IPC_MESSAGE_HANDLER(xxx, qqq)\n" 3139 " IPC_END_MESSAGE_MAP()\n" 3140 "}", 3141 format("int q() {\n" 3142 " IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n" 3143 " IPC_MESSAGE_HANDLER(xxx, qqq)\n" 3144 " IPC_END_MESSAGE_MAP()\n" 3145 "}")); 3146 3147 // Same inside macros. 3148 EXPECT_EQ("#define LIST(L) \\\n" 3149 " L(A) \\\n" 3150 " L(B) \\\n" 3151 " L(C)", 3152 format("#define LIST(L) \\\n" 3153 " L(A) \\\n" 3154 " L(B) \\\n" 3155 " L(C)", 3156 getGoogleStyle())); 3157 3158 // These must not be recognized as macros. 3159 EXPECT_EQ("int q() {\n" 3160 " f(x);\n" 3161 " f(x) {}\n" 3162 " f(x)->g();\n" 3163 " f(x)->*g();\n" 3164 " f(x).g();\n" 3165 " f(x) = x;\n" 3166 " f(x) += x;\n" 3167 " f(x) -= x;\n" 3168 " f(x) *= x;\n" 3169 " f(x) /= x;\n" 3170 " f(x) %= x;\n" 3171 " f(x) &= x;\n" 3172 " f(x) |= x;\n" 3173 " f(x) ^= x;\n" 3174 " f(x) >>= x;\n" 3175 " f(x) <<= x;\n" 3176 " f(x)[y].z();\n" 3177 " LOG(INFO) << x;\n" 3178 " ifstream(x) >> x;\n" 3179 "}\n", 3180 format("int q() {\n" 3181 " f(x)\n;\n" 3182 " f(x)\n {}\n" 3183 " f(x)\n->g();\n" 3184 " f(x)\n->*g();\n" 3185 " f(x)\n.g();\n" 3186 " f(x)\n = x;\n" 3187 " f(x)\n += x;\n" 3188 " f(x)\n -= x;\n" 3189 " f(x)\n *= x;\n" 3190 " f(x)\n /= x;\n" 3191 " f(x)\n %= x;\n" 3192 " f(x)\n &= x;\n" 3193 " f(x)\n |= x;\n" 3194 " f(x)\n ^= x;\n" 3195 " f(x)\n >>= x;\n" 3196 " f(x)\n <<= x;\n" 3197 " f(x)\n[y].z();\n" 3198 " LOG(INFO)\n << x;\n" 3199 " ifstream(x)\n >> x;\n" 3200 "}\n")); 3201 EXPECT_EQ("int q() {\n" 3202 " F(x)\n" 3203 " if (1) {\n" 3204 " }\n" 3205 " F(x)\n" 3206 " while (1) {\n" 3207 " }\n" 3208 " F(x)\n" 3209 " G(x);\n" 3210 " F(x)\n" 3211 " try {\n" 3212 " Q();\n" 3213 " } catch (...) {\n" 3214 " }\n" 3215 "}\n", 3216 format("int q() {\n" 3217 "F(x)\n" 3218 "if (1) {}\n" 3219 "F(x)\n" 3220 "while (1) {}\n" 3221 "F(x)\n" 3222 "G(x);\n" 3223 "F(x)\n" 3224 "try { Q(); } catch (...) {}\n" 3225 "}\n")); 3226 EXPECT_EQ("class A {\n" 3227 " A() : t(0) {}\n" 3228 " A(int i) noexcept() : {}\n" 3229 " A(X x)\n" // FIXME: function-level try blocks are broken. 3230 " try : t(0) {\n" 3231 " } catch (...) {\n" 3232 " }\n" 3233 "};", 3234 format("class A {\n" 3235 " A()\n : t(0) {}\n" 3236 " A(int i)\n noexcept() : {}\n" 3237 " A(X x)\n" 3238 " try : t(0) {} catch (...) {}\n" 3239 "};")); 3240 FormatStyle Style = getLLVMStyle(); 3241 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 3242 Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always; 3243 Style.BraceWrapping.AfterFunction = true; 3244 EXPECT_EQ("void f()\n" 3245 "try\n" 3246 "{\n" 3247 "}", 3248 format("void f() try {\n" 3249 "}", 3250 Style)); 3251 EXPECT_EQ("class SomeClass {\n" 3252 "public:\n" 3253 " SomeClass() EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 3254 "};", 3255 format("class SomeClass {\n" 3256 "public:\n" 3257 " SomeClass()\n" 3258 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 3259 "};")); 3260 EXPECT_EQ("class SomeClass {\n" 3261 "public:\n" 3262 " SomeClass()\n" 3263 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 3264 "};", 3265 format("class SomeClass {\n" 3266 "public:\n" 3267 " SomeClass()\n" 3268 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 3269 "};", 3270 getLLVMStyleWithColumns(40))); 3271 3272 verifyFormat("MACRO(>)"); 3273 3274 // Some macros contain an implicit semicolon. 3275 Style = getLLVMStyle(); 3276 Style.StatementMacros.push_back("FOO"); 3277 verifyFormat("FOO(a) int b = 0;"); 3278 verifyFormat("FOO(a)\n" 3279 "int b = 0;", 3280 Style); 3281 verifyFormat("FOO(a);\n" 3282 "int b = 0;", 3283 Style); 3284 verifyFormat("FOO(argc, argv, \"4.0.2\")\n" 3285 "int b = 0;", 3286 Style); 3287 verifyFormat("FOO()\n" 3288 "int b = 0;", 3289 Style); 3290 verifyFormat("FOO\n" 3291 "int b = 0;", 3292 Style); 3293 verifyFormat("void f() {\n" 3294 " FOO(a)\n" 3295 " return a;\n" 3296 "}", 3297 Style); 3298 verifyFormat("FOO(a)\n" 3299 "FOO(b)", 3300 Style); 3301 verifyFormat("int a = 0;\n" 3302 "FOO(b)\n" 3303 "int c = 0;", 3304 Style); 3305 verifyFormat("int a = 0;\n" 3306 "int x = FOO(a)\n" 3307 "int b = 0;", 3308 Style); 3309 verifyFormat("void foo(int a) { FOO(a) }\n" 3310 "uint32_t bar() {}", 3311 Style); 3312 } 3313 3314 TEST_F(FormatTest, LayoutMacroDefinitionsStatementsSpanningBlocks) { 3315 verifyFormat("#define A \\\n" 3316 " f({ \\\n" 3317 " g(); \\\n" 3318 " });", 3319 getLLVMStyleWithColumns(11)); 3320 } 3321 3322 TEST_F(FormatTest, IndentPreprocessorDirectives) { 3323 FormatStyle Style = getLLVMStyle(); 3324 Style.IndentPPDirectives = FormatStyle::PPDIS_None; 3325 Style.ColumnLimit = 40; 3326 verifyFormat("#ifdef _WIN32\n" 3327 "#define A 0\n" 3328 "#ifdef VAR2\n" 3329 "#define B 1\n" 3330 "#include <someheader.h>\n" 3331 "#define MACRO \\\n" 3332 " some_very_long_func_aaaaaaaaaa();\n" 3333 "#endif\n" 3334 "#else\n" 3335 "#define A 1\n" 3336 "#endif", 3337 Style); 3338 Style.IndentPPDirectives = FormatStyle::PPDIS_AfterHash; 3339 verifyFormat("#ifdef _WIN32\n" 3340 "# define A 0\n" 3341 "# ifdef VAR2\n" 3342 "# define B 1\n" 3343 "# include <someheader.h>\n" 3344 "# define MACRO \\\n" 3345 " some_very_long_func_aaaaaaaaaa();\n" 3346 "# endif\n" 3347 "#else\n" 3348 "# define A 1\n" 3349 "#endif", 3350 Style); 3351 verifyFormat("#if A\n" 3352 "# define MACRO \\\n" 3353 " void a(int x) { \\\n" 3354 " b(); \\\n" 3355 " c(); \\\n" 3356 " d(); \\\n" 3357 " e(); \\\n" 3358 " f(); \\\n" 3359 " }\n" 3360 "#endif", 3361 Style); 3362 // Comments before include guard. 3363 verifyFormat("// file comment\n" 3364 "// file comment\n" 3365 "#ifndef HEADER_H\n" 3366 "#define HEADER_H\n" 3367 "code();\n" 3368 "#endif", 3369 Style); 3370 // Test with include guards. 3371 verifyFormat("#ifndef HEADER_H\n" 3372 "#define HEADER_H\n" 3373 "code();\n" 3374 "#endif", 3375 Style); 3376 // Include guards must have a #define with the same variable immediately 3377 // after #ifndef. 3378 verifyFormat("#ifndef NOT_GUARD\n" 3379 "# define FOO\n" 3380 "code();\n" 3381 "#endif", 3382 Style); 3383 3384 // Include guards must cover the entire file. 3385 verifyFormat("code();\n" 3386 "code();\n" 3387 "#ifndef NOT_GUARD\n" 3388 "# define NOT_GUARD\n" 3389 "code();\n" 3390 "#endif", 3391 Style); 3392 verifyFormat("#ifndef NOT_GUARD\n" 3393 "# define NOT_GUARD\n" 3394 "code();\n" 3395 "#endif\n" 3396 "code();", 3397 Style); 3398 // Test with trailing blank lines. 3399 verifyFormat("#ifndef HEADER_H\n" 3400 "#define HEADER_H\n" 3401 "code();\n" 3402 "#endif\n", 3403 Style); 3404 // Include guards don't have #else. 3405 verifyFormat("#ifndef NOT_GUARD\n" 3406 "# define NOT_GUARD\n" 3407 "code();\n" 3408 "#else\n" 3409 "#endif", 3410 Style); 3411 verifyFormat("#ifndef NOT_GUARD\n" 3412 "# define NOT_GUARD\n" 3413 "code();\n" 3414 "#elif FOO\n" 3415 "#endif", 3416 Style); 3417 // Non-identifier #define after potential include guard. 3418 verifyFormat("#ifndef FOO\n" 3419 "# define 1\n" 3420 "#endif\n", 3421 Style); 3422 // #if closes past last non-preprocessor line. 3423 verifyFormat("#ifndef FOO\n" 3424 "#define FOO\n" 3425 "#if 1\n" 3426 "int i;\n" 3427 "# define A 0\n" 3428 "#endif\n" 3429 "#endif\n", 3430 Style); 3431 // Don't crash if there is an #elif directive without a condition. 3432 verifyFormat("#if 1\n" 3433 "int x;\n" 3434 "#elif\n" 3435 "int y;\n" 3436 "#else\n" 3437 "int z;\n" 3438 "#endif", 3439 Style); 3440 // FIXME: This doesn't handle the case where there's code between the 3441 // #ifndef and #define but all other conditions hold. This is because when 3442 // the #define line is parsed, UnwrappedLineParser::Lines doesn't hold the 3443 // previous code line yet, so we can't detect it. 3444 EXPECT_EQ("#ifndef NOT_GUARD\n" 3445 "code();\n" 3446 "#define NOT_GUARD\n" 3447 "code();\n" 3448 "#endif", 3449 format("#ifndef NOT_GUARD\n" 3450 "code();\n" 3451 "# define NOT_GUARD\n" 3452 "code();\n" 3453 "#endif", 3454 Style)); 3455 // FIXME: This doesn't handle cases where legitimate preprocessor lines may 3456 // be outside an include guard. Examples are #pragma once and 3457 // #pragma GCC diagnostic, or anything else that does not change the meaning 3458 // of the file if it's included multiple times. 3459 EXPECT_EQ("#ifdef WIN32\n" 3460 "# pragma once\n" 3461 "#endif\n" 3462 "#ifndef HEADER_H\n" 3463 "# define HEADER_H\n" 3464 "code();\n" 3465 "#endif", 3466 format("#ifdef WIN32\n" 3467 "# pragma once\n" 3468 "#endif\n" 3469 "#ifndef HEADER_H\n" 3470 "#define HEADER_H\n" 3471 "code();\n" 3472 "#endif", 3473 Style)); 3474 // FIXME: This does not detect when there is a single non-preprocessor line 3475 // in front of an include-guard-like structure where other conditions hold 3476 // because ScopedLineState hides the line. 3477 EXPECT_EQ("code();\n" 3478 "#ifndef HEADER_H\n" 3479 "#define HEADER_H\n" 3480 "code();\n" 3481 "#endif", 3482 format("code();\n" 3483 "#ifndef HEADER_H\n" 3484 "# define HEADER_H\n" 3485 "code();\n" 3486 "#endif", 3487 Style)); 3488 // Keep comments aligned with #, otherwise indent comments normally. These 3489 // tests cannot use verifyFormat because messUp manipulates leading 3490 // whitespace. 3491 { 3492 const char *Expected = "" 3493 "void f() {\n" 3494 "#if 1\n" 3495 "// Preprocessor aligned.\n" 3496 "# define A 0\n" 3497 " // Code. Separated by blank line.\n" 3498 "\n" 3499 "# define B 0\n" 3500 " // Code. Not aligned with #\n" 3501 "# define C 0\n" 3502 "#endif"; 3503 const char *ToFormat = "" 3504 "void f() {\n" 3505 "#if 1\n" 3506 "// Preprocessor aligned.\n" 3507 "# define A 0\n" 3508 "// Code. Separated by blank line.\n" 3509 "\n" 3510 "# define B 0\n" 3511 " // Code. Not aligned with #\n" 3512 "# define C 0\n" 3513 "#endif"; 3514 EXPECT_EQ(Expected, format(ToFormat, Style)); 3515 EXPECT_EQ(Expected, format(Expected, Style)); 3516 } 3517 // Keep block quotes aligned. 3518 { 3519 const char *Expected = "" 3520 "void f() {\n" 3521 "#if 1\n" 3522 "/* Preprocessor aligned. */\n" 3523 "# define A 0\n" 3524 " /* Code. Separated by blank line. */\n" 3525 "\n" 3526 "# define B 0\n" 3527 " /* Code. Not aligned with # */\n" 3528 "# define C 0\n" 3529 "#endif"; 3530 const char *ToFormat = "" 3531 "void f() {\n" 3532 "#if 1\n" 3533 "/* Preprocessor aligned. */\n" 3534 "# define A 0\n" 3535 "/* Code. Separated by blank line. */\n" 3536 "\n" 3537 "# define B 0\n" 3538 " /* Code. Not aligned with # */\n" 3539 "# define C 0\n" 3540 "#endif"; 3541 EXPECT_EQ(Expected, format(ToFormat, Style)); 3542 EXPECT_EQ(Expected, format(Expected, Style)); 3543 } 3544 // Keep comments aligned with un-indented directives. 3545 { 3546 const char *Expected = "" 3547 "void f() {\n" 3548 "// Preprocessor aligned.\n" 3549 "#define A 0\n" 3550 " // Code. Separated by blank line.\n" 3551 "\n" 3552 "#define B 0\n" 3553 " // Code. Not aligned with #\n" 3554 "#define C 0\n"; 3555 const char *ToFormat = "" 3556 "void f() {\n" 3557 "// Preprocessor aligned.\n" 3558 "#define A 0\n" 3559 "// Code. Separated by blank line.\n" 3560 "\n" 3561 "#define B 0\n" 3562 " // Code. Not aligned with #\n" 3563 "#define C 0\n"; 3564 EXPECT_EQ(Expected, format(ToFormat, Style)); 3565 EXPECT_EQ(Expected, format(Expected, Style)); 3566 } 3567 // Test AfterHash with tabs. 3568 { 3569 FormatStyle Tabbed = Style; 3570 Tabbed.UseTab = FormatStyle::UT_Always; 3571 Tabbed.IndentWidth = 8; 3572 Tabbed.TabWidth = 8; 3573 verifyFormat("#ifdef _WIN32\n" 3574 "#\tdefine A 0\n" 3575 "#\tifdef VAR2\n" 3576 "#\t\tdefine B 1\n" 3577 "#\t\tinclude <someheader.h>\n" 3578 "#\t\tdefine MACRO \\\n" 3579 "\t\t\tsome_very_long_func_aaaaaaaaaa();\n" 3580 "#\tendif\n" 3581 "#else\n" 3582 "#\tdefine A 1\n" 3583 "#endif", 3584 Tabbed); 3585 } 3586 3587 // Regression test: Multiline-macro inside include guards. 3588 verifyFormat("#ifndef HEADER_H\n" 3589 "#define HEADER_H\n" 3590 "#define A() \\\n" 3591 " int i; \\\n" 3592 " int j;\n" 3593 "#endif // HEADER_H", 3594 getLLVMStyleWithColumns(20)); 3595 3596 Style.IndentPPDirectives = FormatStyle::PPDIS_BeforeHash; 3597 // Basic before hash indent tests 3598 verifyFormat("#ifdef _WIN32\n" 3599 " #define A 0\n" 3600 " #ifdef VAR2\n" 3601 " #define B 1\n" 3602 " #include <someheader.h>\n" 3603 " #define MACRO \\\n" 3604 " some_very_long_func_aaaaaaaaaa();\n" 3605 " #endif\n" 3606 "#else\n" 3607 " #define A 1\n" 3608 "#endif", 3609 Style); 3610 verifyFormat("#if A\n" 3611 " #define MACRO \\\n" 3612 " void a(int x) { \\\n" 3613 " b(); \\\n" 3614 " c(); \\\n" 3615 " d(); \\\n" 3616 " e(); \\\n" 3617 " f(); \\\n" 3618 " }\n" 3619 "#endif", 3620 Style); 3621 // Keep comments aligned with indented directives. These 3622 // tests cannot use verifyFormat because messUp manipulates leading 3623 // whitespace. 3624 { 3625 const char *Expected = "void f() {\n" 3626 "// Aligned to preprocessor.\n" 3627 "#if 1\n" 3628 " // Aligned to code.\n" 3629 " int a;\n" 3630 " #if 1\n" 3631 " // Aligned to preprocessor.\n" 3632 " #define A 0\n" 3633 " // Aligned to code.\n" 3634 " int b;\n" 3635 " #endif\n" 3636 "#endif\n" 3637 "}"; 3638 const char *ToFormat = "void f() {\n" 3639 "// Aligned to preprocessor.\n" 3640 "#if 1\n" 3641 "// Aligned to code.\n" 3642 "int a;\n" 3643 "#if 1\n" 3644 "// Aligned to preprocessor.\n" 3645 "#define A 0\n" 3646 "// Aligned to code.\n" 3647 "int b;\n" 3648 "#endif\n" 3649 "#endif\n" 3650 "}"; 3651 EXPECT_EQ(Expected, format(ToFormat, Style)); 3652 EXPECT_EQ(Expected, format(Expected, Style)); 3653 } 3654 { 3655 const char *Expected = "void f() {\n" 3656 "/* Aligned to preprocessor. */\n" 3657 "#if 1\n" 3658 " /* Aligned to code. */\n" 3659 " int a;\n" 3660 " #if 1\n" 3661 " /* Aligned to preprocessor. */\n" 3662 " #define A 0\n" 3663 " /* Aligned to code. */\n" 3664 " int b;\n" 3665 " #endif\n" 3666 "#endif\n" 3667 "}"; 3668 const char *ToFormat = "void f() {\n" 3669 "/* Aligned to preprocessor. */\n" 3670 "#if 1\n" 3671 "/* Aligned to code. */\n" 3672 "int a;\n" 3673 "#if 1\n" 3674 "/* Aligned to preprocessor. */\n" 3675 "#define A 0\n" 3676 "/* Aligned to code. */\n" 3677 "int b;\n" 3678 "#endif\n" 3679 "#endif\n" 3680 "}"; 3681 EXPECT_EQ(Expected, format(ToFormat, Style)); 3682 EXPECT_EQ(Expected, format(Expected, Style)); 3683 } 3684 3685 // Test single comment before preprocessor 3686 verifyFormat("// Comment\n" 3687 "\n" 3688 "#if 1\n" 3689 "#endif", 3690 Style); 3691 } 3692 3693 TEST_F(FormatTest, FormatHashIfNotAtStartOfLine) { 3694 verifyFormat("{\n { a #c; }\n}"); 3695 } 3696 3697 TEST_F(FormatTest, FormatUnbalancedStructuralElements) { 3698 EXPECT_EQ("#define A \\\n { \\\n {\nint i;", 3699 format("#define A { {\nint i;", getLLVMStyleWithColumns(11))); 3700 EXPECT_EQ("#define A \\\n } \\\n }\nint i;", 3701 format("#define A } }\nint i;", getLLVMStyleWithColumns(11))); 3702 } 3703 3704 TEST_F(FormatTest, EscapedNewlines) { 3705 FormatStyle Narrow = getLLVMStyleWithColumns(11); 3706 EXPECT_EQ("#define A \\\n int i; \\\n int j;", 3707 format("#define A \\\nint i;\\\n int j;", Narrow)); 3708 EXPECT_EQ("#define A\n\nint i;", format("#define A \\\n\n int i;")); 3709 EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();")); 3710 EXPECT_EQ("/* \\ \\ \\\n */", format("\\\n/* \\ \\ \\\n */")); 3711 EXPECT_EQ("<a\n\\\\\n>", format("<a\n\\\\\n>")); 3712 3713 FormatStyle AlignLeft = getLLVMStyle(); 3714 AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left; 3715 EXPECT_EQ("#define MACRO(x) \\\n" 3716 "private: \\\n" 3717 " int x(int a);\n", 3718 format("#define MACRO(x) \\\n" 3719 "private: \\\n" 3720 " int x(int a);\n", 3721 AlignLeft)); 3722 3723 // CRLF line endings 3724 EXPECT_EQ("#define A \\\r\n int i; \\\r\n int j;", 3725 format("#define A \\\r\nint i;\\\r\n int j;", Narrow)); 3726 EXPECT_EQ("#define A\r\n\r\nint i;", format("#define A \\\r\n\r\n int i;")); 3727 EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();")); 3728 EXPECT_EQ("/* \\ \\ \\\r\n */", format("\\\r\n/* \\ \\ \\\r\n */")); 3729 EXPECT_EQ("<a\r\n\\\\\r\n>", format("<a\r\n\\\\\r\n>")); 3730 EXPECT_EQ("#define MACRO(x) \\\r\n" 3731 "private: \\\r\n" 3732 " int x(int a);\r\n", 3733 format("#define MACRO(x) \\\r\n" 3734 "private: \\\r\n" 3735 " int x(int a);\r\n", 3736 AlignLeft)); 3737 3738 FormatStyle DontAlign = getLLVMStyle(); 3739 DontAlign.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign; 3740 DontAlign.MaxEmptyLinesToKeep = 3; 3741 // FIXME: can't use verifyFormat here because the newline before 3742 // "public:" is not inserted the first time it's reformatted 3743 EXPECT_EQ("#define A \\\n" 3744 " class Foo { \\\n" 3745 " void bar(); \\\n" 3746 "\\\n" 3747 "\\\n" 3748 "\\\n" 3749 " public: \\\n" 3750 " void baz(); \\\n" 3751 " };", 3752 format("#define A \\\n" 3753 " class Foo { \\\n" 3754 " void bar(); \\\n" 3755 "\\\n" 3756 "\\\n" 3757 "\\\n" 3758 " public: \\\n" 3759 " void baz(); \\\n" 3760 " };", 3761 DontAlign)); 3762 } 3763 3764 TEST_F(FormatTest, CalculateSpaceOnConsecutiveLinesInMacro) { 3765 verifyFormat("#define A \\\n" 3766 " int v( \\\n" 3767 " a); \\\n" 3768 " int i;", 3769 getLLVMStyleWithColumns(11)); 3770 } 3771 3772 TEST_F(FormatTest, MixingPreprocessorDirectivesAndNormalCode) { 3773 EXPECT_EQ( 3774 "#define ALooooooooooooooooooooooooooooooooooooooongMacro(" 3775 " \\\n" 3776 " aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n" 3777 "\n" 3778 "AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n" 3779 " aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n", 3780 format(" #define ALooooooooooooooooooooooooooooooooooooooongMacro(" 3781 "\\\n" 3782 "aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n" 3783 " \n" 3784 " AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n" 3785 " aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n")); 3786 } 3787 3788 TEST_F(FormatTest, LayoutStatementsAroundPreprocessorDirectives) { 3789 EXPECT_EQ("int\n" 3790 "#define A\n" 3791 " a;", 3792 format("int\n#define A\na;")); 3793 verifyFormat("functionCallTo(\n" 3794 " someOtherFunction(\n" 3795 " withSomeParameters, whichInSequence,\n" 3796 " areLongerThanALine(andAnotherCall,\n" 3797 "#define A B\n" 3798 " withMoreParamters,\n" 3799 " whichStronglyInfluenceTheLayout),\n" 3800 " andMoreParameters),\n" 3801 " trailing);", 3802 getLLVMStyleWithColumns(69)); 3803 verifyFormat("Foo::Foo()\n" 3804 "#ifdef BAR\n" 3805 " : baz(0)\n" 3806 "#endif\n" 3807 "{\n" 3808 "}"); 3809 verifyFormat("void f() {\n" 3810 " if (true)\n" 3811 "#ifdef A\n" 3812 " f(42);\n" 3813 " x();\n" 3814 "#else\n" 3815 " g();\n" 3816 " x();\n" 3817 "#endif\n" 3818 "}"); 3819 verifyFormat("void f(param1, param2,\n" 3820 " param3,\n" 3821 "#ifdef A\n" 3822 " param4(param5,\n" 3823 "#ifdef A1\n" 3824 " param6,\n" 3825 "#ifdef A2\n" 3826 " param7),\n" 3827 "#else\n" 3828 " param8),\n" 3829 " param9,\n" 3830 "#endif\n" 3831 " param10,\n" 3832 "#endif\n" 3833 " param11)\n" 3834 "#else\n" 3835 " param12)\n" 3836 "#endif\n" 3837 "{\n" 3838 " x();\n" 3839 "}", 3840 getLLVMStyleWithColumns(28)); 3841 verifyFormat("#if 1\n" 3842 "int i;"); 3843 verifyFormat("#if 1\n" 3844 "#endif\n" 3845 "#if 1\n" 3846 "#else\n" 3847 "#endif\n"); 3848 verifyFormat("DEBUG({\n" 3849 " return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3850 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n" 3851 "});\n" 3852 "#if a\n" 3853 "#else\n" 3854 "#endif"); 3855 3856 verifyIncompleteFormat("void f(\n" 3857 "#if A\n" 3858 ");\n" 3859 "#else\n" 3860 "#endif"); 3861 } 3862 3863 TEST_F(FormatTest, GraciouslyHandleIncorrectPreprocessorConditions) { 3864 verifyFormat("#endif\n" 3865 "#if B"); 3866 } 3867 3868 TEST_F(FormatTest, FormatsJoinedLinesOnSubsequentRuns) { 3869 FormatStyle SingleLine = getLLVMStyle(); 3870 SingleLine.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_WithoutElse; 3871 verifyFormat("#if 0\n" 3872 "#elif 1\n" 3873 "#endif\n" 3874 "void foo() {\n" 3875 " if (test) foo2();\n" 3876 "}", 3877 SingleLine); 3878 } 3879 3880 TEST_F(FormatTest, LayoutBlockInsideParens) { 3881 verifyFormat("functionCall({ int i; });"); 3882 verifyFormat("functionCall({\n" 3883 " int i;\n" 3884 " int j;\n" 3885 "});"); 3886 verifyFormat("functionCall(\n" 3887 " {\n" 3888 " int i;\n" 3889 " int j;\n" 3890 " },\n" 3891 " aaaa, bbbb, cccc);"); 3892 verifyFormat("functionA(functionB({\n" 3893 " int i;\n" 3894 " int j;\n" 3895 " }),\n" 3896 " aaaa, bbbb, cccc);"); 3897 verifyFormat("functionCall(\n" 3898 " {\n" 3899 " int i;\n" 3900 " int j;\n" 3901 " },\n" 3902 " aaaa, bbbb, // comment\n" 3903 " cccc);"); 3904 verifyFormat("functionA(functionB({\n" 3905 " int i;\n" 3906 " int j;\n" 3907 " }),\n" 3908 " aaaa, bbbb, // comment\n" 3909 " cccc);"); 3910 verifyFormat("functionCall(aaaa, bbbb, { int i; });"); 3911 verifyFormat("functionCall(aaaa, bbbb, {\n" 3912 " int i;\n" 3913 " int j;\n" 3914 "});"); 3915 verifyFormat( 3916 "Aaa(\n" // FIXME: There shouldn't be a linebreak here. 3917 " {\n" 3918 " int i; // break\n" 3919 " },\n" 3920 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" 3921 " ccccccccccccccccc));"); 3922 verifyFormat("DEBUG({\n" 3923 " if (a)\n" 3924 " f();\n" 3925 "});"); 3926 } 3927 3928 TEST_F(FormatTest, LayoutBlockInsideStatement) { 3929 EXPECT_EQ("SOME_MACRO { int i; }\n" 3930 "int i;", 3931 format(" SOME_MACRO {int i;} int i;")); 3932 } 3933 3934 TEST_F(FormatTest, LayoutNestedBlocks) { 3935 verifyFormat("void AddOsStrings(unsigned bitmask) {\n" 3936 " struct s {\n" 3937 " int i;\n" 3938 " };\n" 3939 " s kBitsToOs[] = {{10}};\n" 3940 " for (int i = 0; i < 10; ++i)\n" 3941 " return;\n" 3942 "}"); 3943 verifyFormat("call(parameter, {\n" 3944 " something();\n" 3945 " // Comment using all columns.\n" 3946 " somethingelse();\n" 3947 "});", 3948 getLLVMStyleWithColumns(40)); 3949 verifyFormat("DEBUG( //\n" 3950 " { f(); }, a);"); 3951 verifyFormat("DEBUG( //\n" 3952 " {\n" 3953 " f(); //\n" 3954 " },\n" 3955 " a);"); 3956 3957 EXPECT_EQ("call(parameter, {\n" 3958 " something();\n" 3959 " // Comment too\n" 3960 " // looooooooooong.\n" 3961 " somethingElse();\n" 3962 "});", 3963 format("call(parameter, {\n" 3964 " something();\n" 3965 " // Comment too looooooooooong.\n" 3966 " somethingElse();\n" 3967 "});", 3968 getLLVMStyleWithColumns(29))); 3969 EXPECT_EQ("DEBUG({ int i; });", format("DEBUG({ int i; });")); 3970 EXPECT_EQ("DEBUG({ // comment\n" 3971 " int i;\n" 3972 "});", 3973 format("DEBUG({ // comment\n" 3974 "int i;\n" 3975 "});")); 3976 EXPECT_EQ("DEBUG({\n" 3977 " int i;\n" 3978 "\n" 3979 " // comment\n" 3980 " int j;\n" 3981 "});", 3982 format("DEBUG({\n" 3983 " int i;\n" 3984 "\n" 3985 " // comment\n" 3986 " int j;\n" 3987 "});")); 3988 3989 verifyFormat("DEBUG({\n" 3990 " if (a)\n" 3991 " return;\n" 3992 "});"); 3993 verifyGoogleFormat("DEBUG({\n" 3994 " if (a) return;\n" 3995 "});"); 3996 FormatStyle Style = getGoogleStyle(); 3997 Style.ColumnLimit = 45; 3998 verifyFormat("Debug(\n" 3999 " aaaaa,\n" 4000 " {\n" 4001 " if (aaaaaaaaaaaaaaaaaaaaaaaa) return;\n" 4002 " },\n" 4003 " a);", 4004 Style); 4005 4006 verifyFormat("SomeFunction({MACRO({ return output; }), b});"); 4007 4008 verifyNoCrash("^{v^{a}}"); 4009 } 4010 4011 TEST_F(FormatTest, FormatNestedBlocksInMacros) { 4012 EXPECT_EQ("#define MACRO() \\\n" 4013 " Debug(aaa, /* force line break */ \\\n" 4014 " { \\\n" 4015 " int i; \\\n" 4016 " int j; \\\n" 4017 " })", 4018 format("#define MACRO() Debug(aaa, /* force line break */ \\\n" 4019 " { int i; int j; })", 4020 getGoogleStyle())); 4021 4022 EXPECT_EQ("#define A \\\n" 4023 " [] { \\\n" 4024 " xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n" 4025 " xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); \\\n" 4026 " }", 4027 format("#define A [] { xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n" 4028 "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); }", 4029 getGoogleStyle())); 4030 } 4031 4032 TEST_F(FormatTest, PutEmptyBlocksIntoOneLine) { 4033 EXPECT_EQ("{}", format("{}")); 4034 verifyFormat("enum E {};"); 4035 verifyFormat("enum E {}"); 4036 FormatStyle Style = getLLVMStyle(); 4037 Style.SpaceInEmptyBlock = true; 4038 EXPECT_EQ("void f() { }", format("void f() {}", Style)); 4039 Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty; 4040 EXPECT_EQ("while (true) { }", format("while (true) {}", Style)); 4041 } 4042 4043 TEST_F(FormatTest, FormatBeginBlockEndMacros) { 4044 FormatStyle Style = getLLVMStyle(); 4045 Style.MacroBlockBegin = "^[A-Z_]+_BEGIN$"; 4046 Style.MacroBlockEnd = "^[A-Z_]+_END$"; 4047 verifyFormat("FOO_BEGIN\n" 4048 " FOO_ENTRY\n" 4049 "FOO_END", 4050 Style); 4051 verifyFormat("FOO_BEGIN\n" 4052 " NESTED_FOO_BEGIN\n" 4053 " NESTED_FOO_ENTRY\n" 4054 " NESTED_FOO_END\n" 4055 "FOO_END", 4056 Style); 4057 verifyFormat("FOO_BEGIN(Foo, Bar)\n" 4058 " int x;\n" 4059 " x = 1;\n" 4060 "FOO_END(Baz)", 4061 Style); 4062 } 4063 4064 //===----------------------------------------------------------------------===// 4065 // Line break tests. 4066 //===----------------------------------------------------------------------===// 4067 4068 TEST_F(FormatTest, PreventConfusingIndents) { 4069 verifyFormat( 4070 "void f() {\n" 4071 " SomeLongMethodName(SomeReallyLongMethod(CallOtherReallyLongMethod(\n" 4072 " parameter, parameter, parameter)),\n" 4073 " SecondLongCall(parameter));\n" 4074 "}"); 4075 verifyFormat( 4076 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4077 " aaaaaaaaaaaaaaaaaaaaaaaa(\n" 4078 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4079 " aaaaaaaaaaaaaaaaaaaaaaaa);"); 4080 verifyFormat( 4081 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4082 " [aaaaaaaaaaaaaaaaaaaaaaaa\n" 4083 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n" 4084 " [aaaaaaaaaaaaaaaaaaaaaaaa]];"); 4085 verifyFormat( 4086 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n" 4087 " aaaaaaaaaaaaaaaaaaaaaaaa<\n" 4088 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>,\n" 4089 " aaaaaaaaaaaaaaaaaaaaaaaa>;"); 4090 verifyFormat("int a = bbbb && ccc &&\n" 4091 " fffff(\n" 4092 "#define A Just forcing a new line\n" 4093 " ddd);"); 4094 } 4095 4096 TEST_F(FormatTest, LineBreakingInBinaryExpressions) { 4097 verifyFormat( 4098 "bool aaaaaaa =\n" 4099 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() ||\n" 4100 " bbbbbbbb();"); 4101 verifyFormat( 4102 "bool aaaaaaa =\n" 4103 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() or\n" 4104 " bbbbbbbb();"); 4105 4106 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n" 4107 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb &&\n" 4108 " ccccccccc == ddddddddddd;"); 4109 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n" 4110 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb and\n" 4111 " ccccccccc == ddddddddddd;"); 4112 verifyFormat( 4113 "bool aaaaaaaaaaaaaaaaaaaaa =\n" 4114 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa not_eq bbbbbbbbbbbbbbbbbb and\n" 4115 " ccccccccc == ddddddddddd;"); 4116 4117 verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n" 4118 " aaaaaa) &&\n" 4119 " bbbbbb && cccccc;"); 4120 verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n" 4121 " aaaaaa) >>\n" 4122 " bbbbbb;"); 4123 verifyFormat("aa = Whitespaces.addUntouchableComment(\n" 4124 " SourceMgr.getSpellingColumnNumber(\n" 4125 " TheLine.Last->FormatTok.Tok.getLocation()) -\n" 4126 " 1);"); 4127 4128 verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 4129 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaaaaaaa\n" 4130 " cccccc) {\n}"); 4131 verifyFormat("if constexpr ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 4132 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaa\n" 4133 " cccccc) {\n}"); 4134 verifyFormat("if CONSTEXPR ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 4135 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaa\n" 4136 " cccccc) {\n}"); 4137 verifyFormat("b = a &&\n" 4138 " // Comment\n" 4139 " b.c && d;"); 4140 4141 // If the LHS of a comparison is not a binary expression itself, the 4142 // additional linebreak confuses many people. 4143 verifyFormat( 4144 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4145 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) > 5) {\n" 4146 "}"); 4147 verifyFormat( 4148 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4149 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n" 4150 "}"); 4151 verifyFormat( 4152 "if (aaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaa(\n" 4153 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n" 4154 "}"); 4155 verifyFormat( 4156 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4157 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) <=> 5) {\n" 4158 "}"); 4159 // Even explicit parentheses stress the precedence enough to make the 4160 // additional break unnecessary. 4161 verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4162 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n" 4163 "}"); 4164 // This cases is borderline, but with the indentation it is still readable. 4165 verifyFormat( 4166 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4167 " aaaaaaaaaaaaaaa) > aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4168 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 4169 "}", 4170 getLLVMStyleWithColumns(75)); 4171 4172 // If the LHS is a binary expression, we should still use the additional break 4173 // as otherwise the formatting hides the operator precedence. 4174 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4175 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 4176 " 5) {\n" 4177 "}"); 4178 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4179 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa <=>\n" 4180 " 5) {\n" 4181 "}"); 4182 4183 FormatStyle OnePerLine = getLLVMStyle(); 4184 OnePerLine.BinPackParameters = false; 4185 verifyFormat( 4186 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 4187 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 4188 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}", 4189 OnePerLine); 4190 4191 verifyFormat("int i = someFunction(aaaaaaa, 0)\n" 4192 " .aaa(aaaaaaaaaaaaa) *\n" 4193 " aaaaaaa +\n" 4194 " aaaaaaa;", 4195 getLLVMStyleWithColumns(40)); 4196 } 4197 4198 TEST_F(FormatTest, ExpressionIndentation) { 4199 verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4200 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4201 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 4202 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 4203 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb +\n" 4204 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb &&\n" 4205 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 4206 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >\n" 4207 " ccccccccccccccccccccccccccccccccccccccccc;"); 4208 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 4209 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4210 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 4211 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); 4212 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4213 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 4214 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 4215 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); 4216 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 4217 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 4218 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4219 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); 4220 verifyFormat("if () {\n" 4221 "} else if (aaaaa && bbbbb > // break\n" 4222 " ccccc) {\n" 4223 "}"); 4224 verifyFormat("if () {\n" 4225 "} else if constexpr (aaaaa && bbbbb > // break\n" 4226 " ccccc) {\n" 4227 "}"); 4228 verifyFormat("if () {\n" 4229 "} else if CONSTEXPR (aaaaa && bbbbb > // break\n" 4230 " ccccc) {\n" 4231 "}"); 4232 verifyFormat("if () {\n" 4233 "} else if (aaaaa &&\n" 4234 " bbbbb > // break\n" 4235 " ccccc &&\n" 4236 " ddddd) {\n" 4237 "}"); 4238 4239 // Presence of a trailing comment used to change indentation of b. 4240 verifyFormat("return aaaaaaaaaaaaaaaaaaa +\n" 4241 " b;\n" 4242 "return aaaaaaaaaaaaaaaaaaa +\n" 4243 " b; //", 4244 getLLVMStyleWithColumns(30)); 4245 } 4246 4247 TEST_F(FormatTest, ExpressionIndentationBreakingBeforeOperators) { 4248 // Not sure what the best system is here. Like this, the LHS can be found 4249 // immediately above an operator (everything with the same or a higher 4250 // indent). The RHS is aligned right of the operator and so compasses 4251 // everything until something with the same indent as the operator is found. 4252 // FIXME: Is this a good system? 4253 FormatStyle Style = getLLVMStyle(); 4254 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 4255 verifyFormat( 4256 "bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4257 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4258 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4259 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4260 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4261 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4262 " && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4263 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4264 " > ccccccccccccccccccccccccccccccccccccccccc;", 4265 Style); 4266 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4267 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4268 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4269 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 4270 Style); 4271 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4272 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4273 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4274 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 4275 Style); 4276 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4277 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4278 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4279 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 4280 Style); 4281 verifyFormat("if () {\n" 4282 "} else if (aaaaa\n" 4283 " && bbbbb // break\n" 4284 " > ccccc) {\n" 4285 "}", 4286 Style); 4287 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4288 " && bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;", 4289 Style); 4290 verifyFormat("return (a)\n" 4291 " // comment\n" 4292 " + b;", 4293 Style); 4294 verifyFormat( 4295 "int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4296 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4297 " + cc;", 4298 Style); 4299 4300 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4301 " = aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 4302 Style); 4303 4304 // Forced by comments. 4305 verifyFormat( 4306 "unsigned ContentSize =\n" 4307 " sizeof(int16_t) // DWARF ARange version number\n" 4308 " + sizeof(int32_t) // Offset of CU in the .debug_info section\n" 4309 " + sizeof(int8_t) // Pointer Size (in bytes)\n" 4310 " + sizeof(int8_t); // Segment Size (in bytes)"); 4311 4312 verifyFormat("return boost::fusion::at_c<0>(iiii).second\n" 4313 " == boost::fusion::at_c<1>(iiii).second;", 4314 Style); 4315 4316 Style.ColumnLimit = 60; 4317 verifyFormat("zzzzzzzzzz\n" 4318 " = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4319 " >> aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa);", 4320 Style); 4321 4322 Style.ColumnLimit = 80; 4323 Style.IndentWidth = 4; 4324 Style.TabWidth = 4; 4325 Style.UseTab = FormatStyle::UT_Always; 4326 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 4327 Style.AlignOperands = FormatStyle::OAS_DontAlign; 4328 EXPECT_EQ("return someVeryVeryLongConditionThatBarelyFitsOnALine\n" 4329 "\t&& (someOtherLongishConditionPart1\n" 4330 "\t\t|| someOtherEvenLongerNestedConditionPart2);", 4331 format("return someVeryVeryLongConditionThatBarelyFitsOnALine && " 4332 "(someOtherLongishConditionPart1 || " 4333 "someOtherEvenLongerNestedConditionPart2);", 4334 Style)); 4335 } 4336 4337 TEST_F(FormatTest, ExpressionIndentationStrictAlign) { 4338 FormatStyle Style = getLLVMStyle(); 4339 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 4340 Style.AlignOperands = FormatStyle::OAS_AlignAfterOperator; 4341 4342 verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4343 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4344 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4345 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4346 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4347 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4348 " && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4349 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4350 " > ccccccccccccccccccccccccccccccccccccccccc;", 4351 Style); 4352 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4353 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4354 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4355 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 4356 Style); 4357 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4358 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4359 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4360 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 4361 Style); 4362 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4363 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4364 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4365 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 4366 Style); 4367 verifyFormat("if () {\n" 4368 "} else if (aaaaa\n" 4369 " && bbbbb // break\n" 4370 " > ccccc) {\n" 4371 "}", 4372 Style); 4373 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4374 " && bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;", 4375 Style); 4376 verifyFormat("return (a)\n" 4377 " // comment\n" 4378 " + b;", 4379 Style); 4380 verifyFormat( 4381 "int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4382 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4383 " + cc;", 4384 Style); 4385 verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n" 4386 " : bbbbbbbbbbbbbbbb ? 2222222222222222\n" 4387 " : 3333333333333333;", 4388 Style); 4389 verifyFormat( 4390 "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n" 4391 " : ccccccccccccccc ? dddddddddddddddddd\n" 4392 " : eeeeeeeeeeeeeeeeee)\n" 4393 " : bbbbbbbbbbbbbbbb ? 2222222222222222\n" 4394 " : 3333333333333333;", 4395 Style); 4396 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4397 " = aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 4398 Style); 4399 4400 verifyFormat("return boost::fusion::at_c<0>(iiii).second\n" 4401 " == boost::fusion::at_c<1>(iiii).second;", 4402 Style); 4403 4404 Style.ColumnLimit = 60; 4405 verifyFormat("zzzzzzzzzzzzz\n" 4406 " = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4407 " >> aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa);", 4408 Style); 4409 4410 // Forced by comments. 4411 Style.ColumnLimit = 80; 4412 verifyFormat( 4413 "unsigned ContentSize\n" 4414 " = sizeof(int16_t) // DWARF ARange version number\n" 4415 " + sizeof(int32_t) // Offset of CU in the .debug_info section\n" 4416 " + sizeof(int8_t) // Pointer Size (in bytes)\n" 4417 " + sizeof(int8_t); // Segment Size (in bytes)", 4418 Style); 4419 4420 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment; 4421 verifyFormat( 4422 "unsigned ContentSize =\n" 4423 " sizeof(int16_t) // DWARF ARange version number\n" 4424 " + sizeof(int32_t) // Offset of CU in the .debug_info section\n" 4425 " + sizeof(int8_t) // Pointer Size (in bytes)\n" 4426 " + sizeof(int8_t); // Segment Size (in bytes)", 4427 Style); 4428 4429 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 4430 verifyFormat( 4431 "unsigned ContentSize =\n" 4432 " sizeof(int16_t) // DWARF ARange version number\n" 4433 " + sizeof(int32_t) // Offset of CU in the .debug_info section\n" 4434 " + sizeof(int8_t) // Pointer Size (in bytes)\n" 4435 " + sizeof(int8_t); // Segment Size (in bytes)", 4436 Style); 4437 } 4438 4439 TEST_F(FormatTest, EnforcedOperatorWraps) { 4440 // Here we'd like to wrap after the || operators, but a comment is forcing an 4441 // earlier wrap. 4442 verifyFormat("bool x = aaaaa //\n" 4443 " || bbbbb\n" 4444 " //\n" 4445 " || cccc;"); 4446 } 4447 4448 TEST_F(FormatTest, NoOperandAlignment) { 4449 FormatStyle Style = getLLVMStyle(); 4450 Style.AlignOperands = FormatStyle::OAS_DontAlign; 4451 verifyFormat("aaaaaaaaaaaaaa(aaaaaaaaaaaa,\n" 4452 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4453 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 4454 Style); 4455 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment; 4456 verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4457 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4458 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4459 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4460 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4461 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4462 " && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4463 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4464 " > ccccccccccccccccccccccccccccccccccccccccc;", 4465 Style); 4466 4467 verifyFormat("int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4468 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4469 " + cc;", 4470 Style); 4471 verifyFormat("int a = aa\n" 4472 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4473 " * cccccccccccccccccccccccccccccccccccc;\n", 4474 Style); 4475 4476 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 4477 verifyFormat("return (a > b\n" 4478 " // comment1\n" 4479 " // comment2\n" 4480 " || c);", 4481 Style); 4482 } 4483 4484 TEST_F(FormatTest, BreakingBeforeNonAssigmentOperators) { 4485 FormatStyle Style = getLLVMStyle(); 4486 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment; 4487 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 4488 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4489 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;", 4490 Style); 4491 } 4492 4493 TEST_F(FormatTest, AllowBinPackingInsideArguments) { 4494 FormatStyle Style = getLLVMStyle(); 4495 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment; 4496 Style.BinPackArguments = false; 4497 Style.ColumnLimit = 40; 4498 verifyFormat("void test() {\n" 4499 " someFunction(\n" 4500 " this + argument + is + quite\n" 4501 " + long + so + it + gets + wrapped\n" 4502 " + but + remains + bin - packed);\n" 4503 "}", 4504 Style); 4505 verifyFormat("void test() {\n" 4506 " someFunction(arg1,\n" 4507 " this + argument + is\n" 4508 " + quite + long + so\n" 4509 " + it + gets + wrapped\n" 4510 " + but + remains + bin\n" 4511 " - packed,\n" 4512 " arg3);\n" 4513 "}", 4514 Style); 4515 verifyFormat("void test() {\n" 4516 " someFunction(\n" 4517 " arg1,\n" 4518 " this + argument + has\n" 4519 " + anotherFunc(nested,\n" 4520 " calls + whose\n" 4521 " + arguments\n" 4522 " + are + also\n" 4523 " + wrapped,\n" 4524 " in + addition)\n" 4525 " + to + being + bin - packed,\n" 4526 " arg3);\n" 4527 "}", 4528 Style); 4529 4530 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 4531 verifyFormat("void test() {\n" 4532 " someFunction(\n" 4533 " arg1,\n" 4534 " this + argument + has +\n" 4535 " anotherFunc(nested,\n" 4536 " calls + whose +\n" 4537 " arguments +\n" 4538 " are + also +\n" 4539 " wrapped,\n" 4540 " in + addition) +\n" 4541 " to + being + bin - packed,\n" 4542 " arg3);\n" 4543 "}", 4544 Style); 4545 } 4546 4547 TEST_F(FormatTest, ConstructorInitializers) { 4548 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}"); 4549 verifyFormat("Constructor() : Inttializer(FitsOnTheLine) {}", 4550 getLLVMStyleWithColumns(45)); 4551 verifyFormat("Constructor()\n" 4552 " : Inttializer(FitsOnTheLine) {}", 4553 getLLVMStyleWithColumns(44)); 4554 verifyFormat("Constructor()\n" 4555 " : Inttializer(FitsOnTheLine) {}", 4556 getLLVMStyleWithColumns(43)); 4557 4558 verifyFormat("template <typename T>\n" 4559 "Constructor() : Initializer(FitsOnTheLine) {}", 4560 getLLVMStyleWithColumns(45)); 4561 4562 verifyFormat( 4563 "SomeClass::Constructor()\n" 4564 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}"); 4565 4566 verifyFormat( 4567 "SomeClass::Constructor()\n" 4568 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4569 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}"); 4570 verifyFormat( 4571 "SomeClass::Constructor()\n" 4572 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4573 " aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}"); 4574 verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4575 " aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 4576 " : aaaaaaaaaa(aaaaaa) {}"); 4577 4578 verifyFormat("Constructor()\n" 4579 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4580 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4581 " aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4582 " aaaaaaaaaaaaaaaaaaaaaaa() {}"); 4583 4584 verifyFormat("Constructor()\n" 4585 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4586 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); 4587 4588 verifyFormat("Constructor(int Parameter = 0)\n" 4589 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n" 4590 " aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}"); 4591 verifyFormat("Constructor()\n" 4592 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n" 4593 "}", 4594 getLLVMStyleWithColumns(60)); 4595 verifyFormat("Constructor()\n" 4596 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4597 " aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}"); 4598 4599 // Here a line could be saved by splitting the second initializer onto two 4600 // lines, but that is not desirable. 4601 verifyFormat("Constructor()\n" 4602 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n" 4603 " aaaaaaaaaaa(aaaaaaaaaaa),\n" 4604 " aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); 4605 4606 FormatStyle OnePerLine = getLLVMStyle(); 4607 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4608 OnePerLine.AllowAllParametersOfDeclarationOnNextLine = false; 4609 verifyFormat("SomeClass::Constructor()\n" 4610 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4611 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4612 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4613 OnePerLine); 4614 verifyFormat("SomeClass::Constructor()\n" 4615 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n" 4616 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4617 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4618 OnePerLine); 4619 verifyFormat("MyClass::MyClass(int var)\n" 4620 " : some_var_(var), // 4 space indent\n" 4621 " some_other_var_(var + 1) { // lined up\n" 4622 "}", 4623 OnePerLine); 4624 verifyFormat("Constructor()\n" 4625 " : aaaaa(aaaaaa),\n" 4626 " aaaaa(aaaaaa),\n" 4627 " aaaaa(aaaaaa),\n" 4628 " aaaaa(aaaaaa),\n" 4629 " aaaaa(aaaaaa) {}", 4630 OnePerLine); 4631 verifyFormat("Constructor()\n" 4632 " : aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n" 4633 " aaaaaaaaaaaaaaaaaaaaaa) {}", 4634 OnePerLine); 4635 OnePerLine.BinPackParameters = false; 4636 verifyFormat( 4637 "Constructor()\n" 4638 " : aaaaaaaaaaaaaaaaaaaaaaaa(\n" 4639 " aaaaaaaaaaa().aaa(),\n" 4640 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4641 OnePerLine); 4642 OnePerLine.ColumnLimit = 60; 4643 verifyFormat("Constructor()\n" 4644 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4645 " bbbbbbbbbbbbbbbbbbbbbbbb(b) {}", 4646 OnePerLine); 4647 4648 EXPECT_EQ("Constructor()\n" 4649 " : // Comment forcing unwanted break.\n" 4650 " aaaa(aaaa) {}", 4651 format("Constructor() :\n" 4652 " // Comment forcing unwanted break.\n" 4653 " aaaa(aaaa) {}")); 4654 } 4655 4656 TEST_F(FormatTest, AllowAllConstructorInitializersOnNextLine) { 4657 FormatStyle Style = getLLVMStyle(); 4658 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 4659 Style.ColumnLimit = 60; 4660 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4661 Style.AllowAllConstructorInitializersOnNextLine = true; 4662 Style.BinPackParameters = false; 4663 4664 for (int i = 0; i < 4; ++i) { 4665 // Test all combinations of parameters that should not have an effect. 4666 Style.AllowAllParametersOfDeclarationOnNextLine = i & 1; 4667 Style.AllowAllArgumentsOnNextLine = i & 2; 4668 4669 Style.AllowAllConstructorInitializersOnNextLine = true; 4670 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 4671 verifyFormat("Constructor()\n" 4672 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4673 Style); 4674 verifyFormat("Constructor() : a(a), b(b) {}", Style); 4675 4676 Style.AllowAllConstructorInitializersOnNextLine = false; 4677 verifyFormat("Constructor()\n" 4678 " : aaaaaaaaaaaaaaaaaaaa(a)\n" 4679 " , bbbbbbbbbbbbbbbbbbbbb(b) {}", 4680 Style); 4681 verifyFormat("Constructor() : a(a), b(b) {}", Style); 4682 4683 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon; 4684 Style.AllowAllConstructorInitializersOnNextLine = true; 4685 verifyFormat("Constructor()\n" 4686 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4687 Style); 4688 4689 Style.AllowAllConstructorInitializersOnNextLine = false; 4690 verifyFormat("Constructor()\n" 4691 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4692 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4693 Style); 4694 4695 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 4696 Style.AllowAllConstructorInitializersOnNextLine = true; 4697 verifyFormat("Constructor() :\n" 4698 " aaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4699 Style); 4700 4701 Style.AllowAllConstructorInitializersOnNextLine = false; 4702 verifyFormat("Constructor() :\n" 4703 " aaaaaaaaaaaaaaaaaa(a),\n" 4704 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4705 Style); 4706 } 4707 4708 // Test interactions between AllowAllParametersOfDeclarationOnNextLine and 4709 // AllowAllConstructorInitializersOnNextLine in all 4710 // BreakConstructorInitializers modes 4711 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 4712 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4713 Style.AllowAllConstructorInitializersOnNextLine = false; 4714 verifyFormat("SomeClassWithALongName::Constructor(\n" 4715 " int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb)\n" 4716 " : aaaaaaaaaaaaaaaaaaaa(a)\n" 4717 " , bbbbbbbbbbbbbbbbbbbbb(b) {}", 4718 Style); 4719 4720 Style.AllowAllConstructorInitializersOnNextLine = true; 4721 verifyFormat("SomeClassWithALongName::Constructor(\n" 4722 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4723 " int bbbbbbbbbbbbb,\n" 4724 " int cccccccccccccccc)\n" 4725 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4726 Style); 4727 4728 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4729 Style.AllowAllConstructorInitializersOnNextLine = false; 4730 verifyFormat("SomeClassWithALongName::Constructor(\n" 4731 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4732 " int bbbbbbbbbbbbb)\n" 4733 " : aaaaaaaaaaaaaaaaaaaa(a)\n" 4734 " , bbbbbbbbbbbbbbbbbbbbb(b) {}", 4735 Style); 4736 4737 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon; 4738 4739 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4740 verifyFormat("SomeClassWithALongName::Constructor(\n" 4741 " int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb)\n" 4742 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4743 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4744 Style); 4745 4746 Style.AllowAllConstructorInitializersOnNextLine = true; 4747 verifyFormat("SomeClassWithALongName::Constructor(\n" 4748 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4749 " int bbbbbbbbbbbbb,\n" 4750 " int cccccccccccccccc)\n" 4751 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4752 Style); 4753 4754 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4755 Style.AllowAllConstructorInitializersOnNextLine = false; 4756 verifyFormat("SomeClassWithALongName::Constructor(\n" 4757 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4758 " int bbbbbbbbbbbbb)\n" 4759 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4760 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4761 Style); 4762 4763 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 4764 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4765 verifyFormat("SomeClassWithALongName::Constructor(\n" 4766 " int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb) :\n" 4767 " aaaaaaaaaaaaaaaaaaaa(a),\n" 4768 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4769 Style); 4770 4771 Style.AllowAllConstructorInitializersOnNextLine = true; 4772 verifyFormat("SomeClassWithALongName::Constructor(\n" 4773 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4774 " int bbbbbbbbbbbbb,\n" 4775 " int cccccccccccccccc) :\n" 4776 " aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4777 Style); 4778 4779 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4780 Style.AllowAllConstructorInitializersOnNextLine = false; 4781 verifyFormat("SomeClassWithALongName::Constructor(\n" 4782 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4783 " int bbbbbbbbbbbbb) :\n" 4784 " aaaaaaaaaaaaaaaaaaaa(a),\n" 4785 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4786 Style); 4787 } 4788 4789 TEST_F(FormatTest, AllowAllArgumentsOnNextLine) { 4790 FormatStyle Style = getLLVMStyle(); 4791 Style.ColumnLimit = 60; 4792 Style.BinPackArguments = false; 4793 for (int i = 0; i < 4; ++i) { 4794 // Test all combinations of parameters that should not have an effect. 4795 Style.AllowAllParametersOfDeclarationOnNextLine = i & 1; 4796 Style.AllowAllConstructorInitializersOnNextLine = i & 2; 4797 4798 Style.AllowAllArgumentsOnNextLine = true; 4799 verifyFormat("void foo() {\n" 4800 " FunctionCallWithReallyLongName(\n" 4801 " aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbb);\n" 4802 "}", 4803 Style); 4804 Style.AllowAllArgumentsOnNextLine = false; 4805 verifyFormat("void foo() {\n" 4806 " FunctionCallWithReallyLongName(\n" 4807 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4808 " bbbbbbbbbbbb);\n" 4809 "}", 4810 Style); 4811 4812 Style.AllowAllArgumentsOnNextLine = true; 4813 verifyFormat("void foo() {\n" 4814 " auto VariableWithReallyLongName = {\n" 4815 " aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbb};\n" 4816 "}", 4817 Style); 4818 Style.AllowAllArgumentsOnNextLine = false; 4819 verifyFormat("void foo() {\n" 4820 " auto VariableWithReallyLongName = {\n" 4821 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4822 " bbbbbbbbbbbb};\n" 4823 "}", 4824 Style); 4825 } 4826 4827 // This parameter should not affect declarations. 4828 Style.BinPackParameters = false; 4829 Style.AllowAllArgumentsOnNextLine = false; 4830 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4831 verifyFormat("void FunctionCallWithReallyLongName(\n" 4832 " int aaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbb);", 4833 Style); 4834 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4835 verifyFormat("void FunctionCallWithReallyLongName(\n" 4836 " int aaaaaaaaaaaaaaaaaaaaaaa,\n" 4837 " int bbbbbbbbbbbb);", 4838 Style); 4839 } 4840 4841 TEST_F(FormatTest, BreakConstructorInitializersAfterColon) { 4842 FormatStyle Style = getLLVMStyle(); 4843 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 4844 4845 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}"); 4846 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}", 4847 getStyleWithColumns(Style, 45)); 4848 verifyFormat("Constructor() :\n" 4849 " Initializer(FitsOnTheLine) {}", 4850 getStyleWithColumns(Style, 44)); 4851 verifyFormat("Constructor() :\n" 4852 " Initializer(FitsOnTheLine) {}", 4853 getStyleWithColumns(Style, 43)); 4854 4855 verifyFormat("template <typename T>\n" 4856 "Constructor() : Initializer(FitsOnTheLine) {}", 4857 getStyleWithColumns(Style, 50)); 4858 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4859 verifyFormat( 4860 "SomeClass::Constructor() :\n" 4861 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}", 4862 Style); 4863 4864 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = false; 4865 verifyFormat( 4866 "SomeClass::Constructor() :\n" 4867 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}", 4868 Style); 4869 4870 verifyFormat( 4871 "SomeClass::Constructor() :\n" 4872 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4873 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4874 Style); 4875 verifyFormat( 4876 "SomeClass::Constructor() :\n" 4877 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4878 " aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}", 4879 Style); 4880 verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4881 " aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n" 4882 " aaaaaaaaaa(aaaaaa) {}", 4883 Style); 4884 4885 verifyFormat("Constructor() :\n" 4886 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4887 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4888 " aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4889 " aaaaaaaaaaaaaaaaaaaaaaa() {}", 4890 Style); 4891 4892 verifyFormat("Constructor() :\n" 4893 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4894 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4895 Style); 4896 4897 verifyFormat("Constructor(int Parameter = 0) :\n" 4898 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n" 4899 " aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}", 4900 Style); 4901 verifyFormat("Constructor() :\n" 4902 " aaaaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n" 4903 "}", 4904 getStyleWithColumns(Style, 60)); 4905 verifyFormat("Constructor() :\n" 4906 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4907 " aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}", 4908 Style); 4909 4910 // Here a line could be saved by splitting the second initializer onto two 4911 // lines, but that is not desirable. 4912 verifyFormat("Constructor() :\n" 4913 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n" 4914 " aaaaaaaaaaa(aaaaaaaaaaa),\n" 4915 " aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4916 Style); 4917 4918 FormatStyle OnePerLine = Style; 4919 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4920 OnePerLine.AllowAllConstructorInitializersOnNextLine = false; 4921 verifyFormat("SomeClass::Constructor() :\n" 4922 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4923 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4924 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4925 OnePerLine); 4926 verifyFormat("SomeClass::Constructor() :\n" 4927 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n" 4928 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4929 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4930 OnePerLine); 4931 verifyFormat("MyClass::MyClass(int var) :\n" 4932 " some_var_(var), // 4 space indent\n" 4933 " some_other_var_(var + 1) { // lined up\n" 4934 "}", 4935 OnePerLine); 4936 verifyFormat("Constructor() :\n" 4937 " aaaaa(aaaaaa),\n" 4938 " aaaaa(aaaaaa),\n" 4939 " aaaaa(aaaaaa),\n" 4940 " aaaaa(aaaaaa),\n" 4941 " aaaaa(aaaaaa) {}", 4942 OnePerLine); 4943 verifyFormat("Constructor() :\n" 4944 " aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n" 4945 " aaaaaaaaaaaaaaaaaaaaaa) {}", 4946 OnePerLine); 4947 OnePerLine.BinPackParameters = false; 4948 verifyFormat("Constructor() :\n" 4949 " aaaaaaaaaaaaaaaaaaaaaaaa(\n" 4950 " aaaaaaaaaaa().aaa(),\n" 4951 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4952 OnePerLine); 4953 OnePerLine.ColumnLimit = 60; 4954 verifyFormat("Constructor() :\n" 4955 " aaaaaaaaaaaaaaaaaaaa(a),\n" 4956 " bbbbbbbbbbbbbbbbbbbbbbbb(b) {}", 4957 OnePerLine); 4958 4959 EXPECT_EQ("Constructor() :\n" 4960 " // Comment forcing unwanted break.\n" 4961 " aaaa(aaaa) {}", 4962 format("Constructor() :\n" 4963 " // Comment forcing unwanted break.\n" 4964 " aaaa(aaaa) {}", 4965 Style)); 4966 4967 Style.ColumnLimit = 0; 4968 verifyFormat("SomeClass::Constructor() :\n" 4969 " a(a) {}", 4970 Style); 4971 verifyFormat("SomeClass::Constructor() noexcept :\n" 4972 " a(a) {}", 4973 Style); 4974 verifyFormat("SomeClass::Constructor() :\n" 4975 " a(a), b(b), c(c) {}", 4976 Style); 4977 verifyFormat("SomeClass::Constructor() :\n" 4978 " a(a) {\n" 4979 " foo();\n" 4980 " bar();\n" 4981 "}", 4982 Style); 4983 4984 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 4985 verifyFormat("SomeClass::Constructor() :\n" 4986 " a(a), b(b), c(c) {\n" 4987 "}", 4988 Style); 4989 verifyFormat("SomeClass::Constructor() :\n" 4990 " a(a) {\n" 4991 "}", 4992 Style); 4993 4994 Style.ColumnLimit = 80; 4995 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 4996 Style.ConstructorInitializerIndentWidth = 2; 4997 verifyFormat("SomeClass::Constructor() : a(a), b(b), c(c) {}", Style); 4998 verifyFormat("SomeClass::Constructor() :\n" 4999 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5000 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {}", 5001 Style); 5002 5003 // `ConstructorInitializerIndentWidth` actually applies to InheritanceList as 5004 // well 5005 Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon; 5006 verifyFormat( 5007 "class SomeClass\n" 5008 " : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5009 " public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};", 5010 Style); 5011 Style.BreakInheritanceList = FormatStyle::BILS_BeforeComma; 5012 verifyFormat( 5013 "class SomeClass\n" 5014 " : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5015 " , public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};", 5016 Style); 5017 Style.BreakInheritanceList = FormatStyle::BILS_AfterColon; 5018 verifyFormat( 5019 "class SomeClass :\n" 5020 " public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5021 " public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};", 5022 Style); 5023 } 5024 5025 #ifndef EXPENSIVE_CHECKS 5026 // Expensive checks enables libstdc++ checking which includes validating the 5027 // state of ranges used in std::priority_queue - this blows out the 5028 // runtime/scalability of the function and makes this test unacceptably slow. 5029 TEST_F(FormatTest, MemoizationTests) { 5030 // This breaks if the memoization lookup does not take \c Indent and 5031 // \c LastSpace into account. 5032 verifyFormat( 5033 "extern CFRunLoopTimerRef\n" 5034 "CFRunLoopTimerCreate(CFAllocatorRef allocato, CFAbsoluteTime fireDate,\n" 5035 " CFTimeInterval interval, CFOptionFlags flags,\n" 5036 " CFIndex order, CFRunLoopTimerCallBack callout,\n" 5037 " CFRunLoopTimerContext *context) {}"); 5038 5039 // Deep nesting somewhat works around our memoization. 5040 verifyFormat( 5041 "aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 5042 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 5043 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 5044 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 5045 " aaaaa())))))))))))))))))))))))))))))))))))))));", 5046 getLLVMStyleWithColumns(65)); 5047 verifyFormat( 5048 "aaaaa(\n" 5049 " aaaaa,\n" 5050 " aaaaa(\n" 5051 " aaaaa,\n" 5052 " aaaaa(\n" 5053 " aaaaa,\n" 5054 " aaaaa(\n" 5055 " aaaaa,\n" 5056 " aaaaa(\n" 5057 " aaaaa,\n" 5058 " aaaaa(\n" 5059 " aaaaa,\n" 5060 " aaaaa(\n" 5061 " aaaaa,\n" 5062 " aaaaa(\n" 5063 " aaaaa,\n" 5064 " aaaaa(\n" 5065 " aaaaa,\n" 5066 " aaaaa(\n" 5067 " aaaaa,\n" 5068 " aaaaa(\n" 5069 " aaaaa,\n" 5070 " aaaaa(\n" 5071 " aaaaa,\n" 5072 " aaaaa))))))))))));", 5073 getLLVMStyleWithColumns(65)); 5074 verifyFormat( 5075 "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" 5076 " a),\n" 5077 " a),\n" 5078 " a),\n" 5079 " a),\n" 5080 " a),\n" 5081 " a),\n" 5082 " a),\n" 5083 " a),\n" 5084 " a),\n" 5085 " a),\n" 5086 " a),\n" 5087 " a),\n" 5088 " a),\n" 5089 " a),\n" 5090 " a),\n" 5091 " a),\n" 5092 " a)", 5093 getLLVMStyleWithColumns(65)); 5094 5095 // This test takes VERY long when memoization is broken. 5096 FormatStyle OnePerLine = getLLVMStyle(); 5097 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 5098 OnePerLine.BinPackParameters = false; 5099 std::string input = "Constructor()\n" 5100 " : aaaa(a,\n"; 5101 for (unsigned i = 0, e = 80; i != e; ++i) { 5102 input += " a,\n"; 5103 } 5104 input += " a) {}"; 5105 verifyFormat(input, OnePerLine); 5106 } 5107 #endif 5108 5109 TEST_F(FormatTest, BreaksAsHighAsPossible) { 5110 verifyFormat( 5111 "void f() {\n" 5112 " if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaaaaaaaa) ||\n" 5113 " (bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb && bbbbbbbbbbbbbbbbbbbbbbbbbb))\n" 5114 " f();\n" 5115 "}"); 5116 verifyFormat("if (Intervals[i].getRange().getFirst() <\n" 5117 " Intervals[i - 1].getRange().getLast()) {\n}"); 5118 } 5119 5120 TEST_F(FormatTest, BreaksFunctionDeclarations) { 5121 // Principially, we break function declarations in a certain order: 5122 // 1) break amongst arguments. 5123 verifyFormat("Aaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccc,\n" 5124 " Cccccccccccccc cccccccccccccc);"); 5125 verifyFormat("template <class TemplateIt>\n" 5126 "SomeReturnType SomeFunction(TemplateIt begin, TemplateIt end,\n" 5127 " TemplateIt *stop) {}"); 5128 5129 // 2) break after return type. 5130 verifyFormat( 5131 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5132 "bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccccccccccccccc);", 5133 getGoogleStyle()); 5134 5135 // 3) break after (. 5136 verifyFormat( 5137 "Aaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbb(\n" 5138 " Cccccccccccccccccccccccccccccc cccccccccccccccccccccccccccccccc);", 5139 getGoogleStyle()); 5140 5141 // 4) break before after nested name specifiers. 5142 verifyFormat( 5143 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5144 "SomeClasssssssssssssssssssssssssssssssssssssss::\n" 5145 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc);", 5146 getGoogleStyle()); 5147 5148 // However, there are exceptions, if a sufficient amount of lines can be 5149 // saved. 5150 // FIXME: The precise cut-offs wrt. the number of saved lines might need some 5151 // more adjusting. 5152 verifyFormat("Aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n" 5153 " Cccccccccccccc cccccccccc,\n" 5154 " Cccccccccccccc cccccccccc,\n" 5155 " Cccccccccccccc cccccccccc,\n" 5156 " Cccccccccccccc cccccccccc);"); 5157 verifyFormat( 5158 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5159 "bbbbbbbbbbb(Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 5160 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 5161 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);", 5162 getGoogleStyle()); 5163 verifyFormat( 5164 "Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n" 5165 " Cccccccccccccc cccccccccc,\n" 5166 " Cccccccccccccc cccccccccc,\n" 5167 " Cccccccccccccc cccccccccc,\n" 5168 " Cccccccccccccc cccccccccc,\n" 5169 " Cccccccccccccc cccccccccc,\n" 5170 " Cccccccccccccc cccccccccc);"); 5171 verifyFormat("Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 5172 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 5173 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 5174 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 5175 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);"); 5176 5177 // Break after multi-line parameters. 5178 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5179 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5180 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5181 " bbbb bbbb);"); 5182 verifyFormat("void SomeLoooooooooooongFunction(\n" 5183 " std::unique_ptr<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n" 5184 " aaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5185 " int bbbbbbbbbbbbb);"); 5186 5187 // Treat overloaded operators like other functions. 5188 verifyFormat("SomeLoooooooooooooooooooooooooogType\n" 5189 "operator>(const SomeLoooooooooooooooooooooooooogType &other);"); 5190 verifyFormat("SomeLoooooooooooooooooooooooooogType\n" 5191 "operator>>(const SomeLooooooooooooooooooooooooogType &other);"); 5192 verifyFormat("SomeLoooooooooooooooooooooooooogType\n" 5193 "operator<<(const SomeLooooooooooooooooooooooooogType &other);"); 5194 verifyGoogleFormat( 5195 "SomeLoooooooooooooooooooooooooooooogType operator>>(\n" 5196 " const SomeLooooooooogType &a, const SomeLooooooooogType &b);"); 5197 verifyGoogleFormat( 5198 "SomeLoooooooooooooooooooooooooooooogType operator<<(\n" 5199 " const SomeLooooooooogType &a, const SomeLooooooooogType &b);"); 5200 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5201 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = 1);"); 5202 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa\n" 5203 "aaaaaaaaaaaaaaaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaa = 1);"); 5204 verifyGoogleFormat( 5205 "typename aaaaaaaaaa<aaaaaa>::aaaaaaaaaaa\n" 5206 "aaaaaaaaaa<aaaaaa>::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5207 " bool *aaaaaaaaaaaaaaaaaa, bool *aa) {}"); 5208 verifyGoogleFormat("template <typename T>\n" 5209 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5210 "aaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaaaaa(\n" 5211 " aaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaa);"); 5212 5213 FormatStyle Style = getLLVMStyle(); 5214 Style.PointerAlignment = FormatStyle::PAS_Left; 5215 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5216 " aaaaaaaaaaaaaaaaaaaaaaaaa* const aaaaaaaaaaaa) {}", 5217 Style); 5218 verifyFormat("void aaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*\n" 5219 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 5220 Style); 5221 } 5222 5223 TEST_F(FormatTest, DontBreakBeforeQualifiedOperator) { 5224 // Regression test for https://bugs.llvm.org/show_bug.cgi?id=40516: 5225 // Prefer keeping `::` followed by `operator` together. 5226 EXPECT_EQ("const aaaa::bbbbbbb &\n" 5227 "ccccccccc::operator++() {\n" 5228 " stuff();\n" 5229 "}", 5230 format("const aaaa::bbbbbbb\n" 5231 "&ccccccccc::operator++() { stuff(); }", 5232 getLLVMStyleWithColumns(40))); 5233 } 5234 5235 TEST_F(FormatTest, TrailingReturnType) { 5236 verifyFormat("auto foo() -> int;\n"); 5237 // correct trailing return type spacing 5238 verifyFormat("auto operator->() -> int;\n"); 5239 verifyFormat("auto operator++(int) -> int;\n"); 5240 5241 verifyFormat("struct S {\n" 5242 " auto bar() const -> int;\n" 5243 "};"); 5244 verifyFormat("template <size_t Order, typename T>\n" 5245 "auto load_img(const std::string &filename)\n" 5246 " -> alias::tensor<Order, T, mem::tag::cpu> {}"); 5247 verifyFormat("auto SomeFunction(A aaaaaaaaaaaaaaaaaaaaa) const\n" 5248 " -> decltype(f(aaaaaaaaaaaaaaaaaaaaa)) {}"); 5249 verifyFormat("auto doSomething(Aaaaaa *aaaaaa) -> decltype(aaaaaa->f()) {}"); 5250 verifyFormat("template <typename T>\n" 5251 "auto aaaaaaaaaaaaaaaaaaaaaa(T t)\n" 5252 " -> decltype(eaaaaaaaaaaaaaaa<T>(t.a).aaaaaaaa());"); 5253 5254 // Not trailing return types. 5255 verifyFormat("void f() { auto a = b->c(); }"); 5256 } 5257 5258 TEST_F(FormatTest, DeductionGuides) { 5259 verifyFormat("template <class T> A(const T &, const T &) -> A<T &>;"); 5260 verifyFormat("template <class T> explicit A(T &, T &&) -> A<T>;"); 5261 verifyFormat("template <class... Ts> S(Ts...) -> S<Ts...>;"); 5262 verifyFormat( 5263 "template <class... T>\n" 5264 "array(T &&... t) -> array<std::common_type_t<T...>, sizeof...(T)>;"); 5265 verifyFormat("template <class T> A() -> A<decltype(p->foo<3>())>;"); 5266 verifyFormat("template <class T> A() -> A<decltype(foo<traits<1>>)>;"); 5267 verifyFormat("template <class T> A() -> A<sizeof(p->foo<1>)>;"); 5268 verifyFormat("template <class T> A() -> A<(3 < 2)>;"); 5269 verifyFormat("template <class T> A() -> A<((3) < (2))>;"); 5270 verifyFormat("template <class T> x() -> x<1>;"); 5271 verifyFormat("template <class T> explicit x(T &) -> x<1>;"); 5272 5273 // Ensure not deduction guides. 5274 verifyFormat("c()->f<int>();"); 5275 verifyFormat("x()->foo<1>;"); 5276 verifyFormat("x = p->foo<3>();"); 5277 verifyFormat("x()->x<1>();"); 5278 verifyFormat("x()->x<1>;"); 5279 } 5280 5281 TEST_F(FormatTest, BreaksFunctionDeclarationsWithTrailingTokens) { 5282 // Avoid breaking before trailing 'const' or other trailing annotations, if 5283 // they are not function-like. 5284 FormatStyle Style = getGoogleStyle(); 5285 Style.ColumnLimit = 47; 5286 verifyFormat("void someLongFunction(\n" 5287 " int someLoooooooooooooongParameter) const {\n}", 5288 getLLVMStyleWithColumns(47)); 5289 verifyFormat("LoooooongReturnType\n" 5290 "someLoooooooongFunction() const {}", 5291 getLLVMStyleWithColumns(47)); 5292 verifyFormat("LoooooongReturnType someLoooooooongFunction()\n" 5293 " const {}", 5294 Style); 5295 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n" 5296 " aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE;"); 5297 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n" 5298 " aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE FINAL;"); 5299 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n" 5300 " aaaaa aaaaaaaaaaaaaaaaaaaa) override final;"); 5301 verifyFormat("virtual void aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa,\n" 5302 " aaaaaaaaaaa aaaaa) const override;"); 5303 verifyGoogleFormat( 5304 "virtual void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5305 " const override;"); 5306 5307 // Even if the first parameter has to be wrapped. 5308 verifyFormat("void someLongFunction(\n" 5309 " int someLongParameter) const {}", 5310 getLLVMStyleWithColumns(46)); 5311 verifyFormat("void someLongFunction(\n" 5312 " int someLongParameter) const {}", 5313 Style); 5314 verifyFormat("void someLongFunction(\n" 5315 " int someLongParameter) override {}", 5316 Style); 5317 verifyFormat("void someLongFunction(\n" 5318 " int someLongParameter) OVERRIDE {}", 5319 Style); 5320 verifyFormat("void someLongFunction(\n" 5321 " int someLongParameter) final {}", 5322 Style); 5323 verifyFormat("void someLongFunction(\n" 5324 " int someLongParameter) FINAL {}", 5325 Style); 5326 verifyFormat("void someLongFunction(\n" 5327 " int parameter) const override {}", 5328 Style); 5329 5330 Style.BreakBeforeBraces = FormatStyle::BS_Allman; 5331 verifyFormat("void someLongFunction(\n" 5332 " int someLongParameter) const\n" 5333 "{\n" 5334 "}", 5335 Style); 5336 5337 Style.BreakBeforeBraces = FormatStyle::BS_Whitesmiths; 5338 verifyFormat("void someLongFunction(\n" 5339 " int someLongParameter) const\n" 5340 " {\n" 5341 " }", 5342 Style); 5343 5344 // Unless these are unknown annotations. 5345 verifyFormat("void SomeFunction(aaaaaaaaaa aaaaaaaaaaaaaaa,\n" 5346 " aaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5347 " LONG_AND_UGLY_ANNOTATION;"); 5348 5349 // Breaking before function-like trailing annotations is fine to keep them 5350 // close to their arguments. 5351 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5352 " LOCKS_EXCLUDED(aaaaaaaaaaaaa);"); 5353 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n" 5354 " LOCKS_EXCLUDED(aaaaaaaaaaaaa);"); 5355 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n" 5356 " LOCKS_EXCLUDED(aaaaaaaaaaaaa) {}"); 5357 verifyGoogleFormat("void aaaaaaaaaaaaaa(aaaaaaaa aaa) override\n" 5358 " AAAAAAAAAAAAAAAAAAAAAAAA(aaaaaaaaaaaaaaa);"); 5359 verifyFormat("SomeFunction([](int i) LOCKS_EXCLUDED(a) {});"); 5360 5361 verifyFormat( 5362 "void aaaaaaaaaaaaaaaaaa()\n" 5363 " __attribute__((aaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaa,\n" 5364 " aaaaaaaaaaaaaaaaaaaaaaaaa));"); 5365 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5366 " __attribute__((unused));"); 5367 verifyGoogleFormat( 5368 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5369 " GUARDED_BY(aaaaaaaaaaaa);"); 5370 verifyGoogleFormat( 5371 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5372 " GUARDED_BY(aaaaaaaaaaaa);"); 5373 verifyGoogleFormat( 5374 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n" 5375 " aaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5376 verifyGoogleFormat( 5377 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n" 5378 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5379 } 5380 5381 TEST_F(FormatTest, FunctionAnnotations) { 5382 verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n" 5383 "int OldFunction(const string ¶meter) {}"); 5384 verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n" 5385 "string OldFunction(const string ¶meter) {}"); 5386 verifyFormat("template <typename T>\n" 5387 "DEPRECATED(\"Use NewClass::NewFunction instead.\")\n" 5388 "string OldFunction(const string ¶meter) {}"); 5389 5390 // Not function annotations. 5391 verifyFormat("ASSERT(\"aaaaa\") << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5392 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"); 5393 verifyFormat("TEST_F(ThisIsATestFixtureeeeeeeeeeeee,\n" 5394 " ThisIsATestWithAReallyReallyReallyReallyLongName) {}"); 5395 verifyFormat("MACRO(abc).function() // wrap\n" 5396 " << abc;"); 5397 verifyFormat("MACRO(abc)->function() // wrap\n" 5398 " << abc;"); 5399 verifyFormat("MACRO(abc)::function() // wrap\n" 5400 " << abc;"); 5401 } 5402 5403 TEST_F(FormatTest, BreaksDesireably) { 5404 verifyFormat("if (aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n" 5405 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n" 5406 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa)) {\n}"); 5407 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5408 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n" 5409 "}"); 5410 5411 verifyFormat( 5412 "aaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5413 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); 5414 5415 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5416 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5417 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 5418 5419 verifyFormat( 5420 "aaaaaaaa(aaaaaaaaaaaaa,\n" 5421 " aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5422 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n" 5423 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5424 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));"); 5425 5426 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 5427 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5428 5429 verifyFormat( 5430 "void f() {\n" 5431 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&\n" 5432 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 5433 "}"); 5434 verifyFormat( 5435 "aaaaaa(new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5436 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 5437 verifyFormat( 5438 "aaaaaa(aaa, new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5439 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 5440 verifyFormat( 5441 "aaaaaa(aaa,\n" 5442 " new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5443 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5444 " aaaa);"); 5445 verifyFormat("aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5446 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5447 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5448 5449 // Indent consistently independent of call expression and unary operator. 5450 verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 5451 " dddddddddddddddddddddddddddddd));"); 5452 verifyFormat("aaaaaaaaaaa(!bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 5453 " dddddddddddddddddddddddddddddd));"); 5454 verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbb.ccccccccccccccccc(\n" 5455 " dddddddddddddddddddddddddddddd));"); 5456 5457 // This test case breaks on an incorrect memoization, i.e. an optimization not 5458 // taking into account the StopAt value. 5459 verifyFormat( 5460 "return aaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 5461 " aaaaaaaaaaa(aaaaaaaaa) || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 5462 " aaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 5463 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5464 5465 verifyFormat("{\n {\n {\n" 5466 " Annotation.SpaceRequiredBefore =\n" 5467 " Line.Tokens[i - 1].Tok.isNot(tok::l_paren) &&\n" 5468 " Line.Tokens[i - 1].Tok.isNot(tok::l_square);\n" 5469 " }\n }\n}"); 5470 5471 // Break on an outer level if there was a break on an inner level. 5472 EXPECT_EQ("f(g(h(a, // comment\n" 5473 " b, c),\n" 5474 " d, e),\n" 5475 " x, y);", 5476 format("f(g(h(a, // comment\n" 5477 " b, c), d, e), x, y);")); 5478 5479 // Prefer breaking similar line breaks. 5480 verifyFormat( 5481 "const int kTrackingOptions = NSTrackingMouseMoved |\n" 5482 " NSTrackingMouseEnteredAndExited |\n" 5483 " NSTrackingActiveAlways;"); 5484 } 5485 5486 TEST_F(FormatTest, FormatsDeclarationsOnePerLine) { 5487 FormatStyle NoBinPacking = getGoogleStyle(); 5488 NoBinPacking.BinPackParameters = false; 5489 NoBinPacking.BinPackArguments = true; 5490 verifyFormat("void f() {\n" 5491 " f(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa,\n" 5492 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 5493 "}", 5494 NoBinPacking); 5495 verifyFormat("void f(int aaaaaaaaaaaaaaaaaaaa,\n" 5496 " int aaaaaaaaaaaaaaaaaaaa,\n" 5497 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 5498 NoBinPacking); 5499 5500 NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false; 5501 verifyFormat("void aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5502 " vector<int> bbbbbbbbbbbbbbb);", 5503 NoBinPacking); 5504 // FIXME: This behavior difference is probably not wanted. However, currently 5505 // we cannot distinguish BreakBeforeParameter being set because of the wrapped 5506 // template arguments from BreakBeforeParameter being set because of the 5507 // one-per-line formatting. 5508 verifyFormat( 5509 "void fffffffffff(aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa,\n" 5510 " aaaaaaaaaa> aaaaaaaaaa);", 5511 NoBinPacking); 5512 verifyFormat( 5513 "void fffffffffff(\n" 5514 " aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaa>\n" 5515 " aaaaaaaaaa);"); 5516 } 5517 5518 TEST_F(FormatTest, FormatsOneParameterPerLineIfNecessary) { 5519 FormatStyle NoBinPacking = getGoogleStyle(); 5520 NoBinPacking.BinPackParameters = false; 5521 NoBinPacking.BinPackArguments = false; 5522 verifyFormat("f(aaaaaaaaaaaaaaaaaaaa,\n" 5523 " aaaaaaaaaaaaaaaaaaaa,\n" 5524 " aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaa);", 5525 NoBinPacking); 5526 verifyFormat("aaaaaaa(aaaaaaaaaaaaa,\n" 5527 " aaaaaaaaaaaaa,\n" 5528 " aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));", 5529 NoBinPacking); 5530 verifyFormat( 5531 "aaaaaaaa(aaaaaaaaaaaaa,\n" 5532 " aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5533 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n" 5534 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5535 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));", 5536 NoBinPacking); 5537 verifyFormat("aaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n" 5538 " .aaaaaaaaaaaaaaaaaa();", 5539 NoBinPacking); 5540 verifyFormat("void f() {\n" 5541 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5542 " aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaa);\n" 5543 "}", 5544 NoBinPacking); 5545 5546 verifyFormat( 5547 "aaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5548 " aaaaaaaaaaaa,\n" 5549 " aaaaaaaaaaaa);", 5550 NoBinPacking); 5551 verifyFormat( 5552 "somefunction(someotherFunction(ddddddddddddddddddddddddddddddddddd,\n" 5553 " ddddddddddddddddddddddddddddd),\n" 5554 " test);", 5555 NoBinPacking); 5556 5557 verifyFormat("std::vector<aaaaaaaaaaaaaaaaaaaaaaa,\n" 5558 " aaaaaaaaaaaaaaaaaaaaaaa,\n" 5559 " aaaaaaaaaaaaaaaaaaaaaaa>\n" 5560 " aaaaaaaaaaaaaaaaaa;", 5561 NoBinPacking); 5562 verifyFormat("a(\"a\"\n" 5563 " \"a\",\n" 5564 " a);"); 5565 5566 NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false; 5567 verifyFormat("void aaaaaaaaaa(aaaaaaaaa,\n" 5568 " aaaaaaaaa,\n" 5569 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5570 NoBinPacking); 5571 verifyFormat( 5572 "void f() {\n" 5573 " aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n" 5574 " .aaaaaaa();\n" 5575 "}", 5576 NoBinPacking); 5577 verifyFormat( 5578 "template <class SomeType, class SomeOtherType>\n" 5579 "SomeType SomeFunction(SomeType Type, SomeOtherType OtherType) {}", 5580 NoBinPacking); 5581 } 5582 5583 TEST_F(FormatTest, AdaptiveOnePerLineFormatting) { 5584 FormatStyle Style = getLLVMStyleWithColumns(15); 5585 Style.ExperimentalAutoDetectBinPacking = true; 5586 EXPECT_EQ("aaa(aaaa,\n" 5587 " aaaa,\n" 5588 " aaaa);\n" 5589 "aaa(aaaa,\n" 5590 " aaaa,\n" 5591 " aaaa);", 5592 format("aaa(aaaa,\n" // one-per-line 5593 " aaaa,\n" 5594 " aaaa );\n" 5595 "aaa(aaaa, aaaa, aaaa);", // inconclusive 5596 Style)); 5597 EXPECT_EQ("aaa(aaaa, aaaa,\n" 5598 " aaaa);\n" 5599 "aaa(aaaa, aaaa,\n" 5600 " aaaa);", 5601 format("aaa(aaaa, aaaa,\n" // bin-packed 5602 " aaaa );\n" 5603 "aaa(aaaa, aaaa, aaaa);", // inconclusive 5604 Style)); 5605 } 5606 5607 TEST_F(FormatTest, FormatsBuilderPattern) { 5608 verifyFormat("return llvm::StringSwitch<Reference::Kind>(name)\n" 5609 " .StartsWith(\".eh_frame_hdr\", ORDER_EH_FRAMEHDR)\n" 5610 " .StartsWith(\".eh_frame\", ORDER_EH_FRAME)\n" 5611 " .StartsWith(\".init\", ORDER_INIT)\n" 5612 " .StartsWith(\".fini\", ORDER_FINI)\n" 5613 " .StartsWith(\".hash\", ORDER_HASH)\n" 5614 " .Default(ORDER_TEXT);\n"); 5615 5616 verifyFormat("return aaaaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa() <\n" 5617 " aaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa();"); 5618 verifyFormat("aaaaaaa->aaaaaaa\n" 5619 " ->aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5620 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5621 " ->aaaaaaaa(aaaaaaaaaaaaaaa);"); 5622 verifyFormat( 5623 "aaaaaaa->aaaaaaa\n" 5624 " ->aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5625 " ->aaaaaaaa(aaaaaaaaaaaaaaa);"); 5626 verifyFormat( 5627 "aaaaaaaaaaaaaaaaaaa()->aaaaaa(bbbbb)->aaaaaaaaaaaaaaaaaaa( // break\n" 5628 " aaaaaaaaaaaaaa);"); 5629 verifyFormat( 5630 "aaaaaaaaaaaaaaaaaaaaaaa *aaaaaaaaa =\n" 5631 " aaaaaa->aaaaaaaaaaaa()\n" 5632 " ->aaaaaaaaaaaaaaaa(\n" 5633 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5634 " ->aaaaaaaaaaaaaaaaa();"); 5635 verifyGoogleFormat( 5636 "void f() {\n" 5637 " someo->Add((new util::filetools::Handler(dir))\n" 5638 " ->OnEvent1(NewPermanentCallback(\n" 5639 " this, &HandlerHolderClass::EventHandlerCBA))\n" 5640 " ->OnEvent2(NewPermanentCallback(\n" 5641 " this, &HandlerHolderClass::EventHandlerCBB))\n" 5642 " ->OnEvent3(NewPermanentCallback(\n" 5643 " this, &HandlerHolderClass::EventHandlerCBC))\n" 5644 " ->OnEvent5(NewPermanentCallback(\n" 5645 " this, &HandlerHolderClass::EventHandlerCBD))\n" 5646 " ->OnEvent6(NewPermanentCallback(\n" 5647 " this, &HandlerHolderClass::EventHandlerCBE)));\n" 5648 "}"); 5649 5650 verifyFormat( 5651 "aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa();"); 5652 verifyFormat("aaaaaaaaaaaaaaa()\n" 5653 " .aaaaaaaaaaaaaaa()\n" 5654 " .aaaaaaaaaaaaaaa()\n" 5655 " .aaaaaaaaaaaaaaa()\n" 5656 " .aaaaaaaaaaaaaaa();"); 5657 verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n" 5658 " .aaaaaaaaaaaaaaa()\n" 5659 " .aaaaaaaaaaaaaaa()\n" 5660 " .aaaaaaaaaaaaaaa();"); 5661 verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n" 5662 " .aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n" 5663 " .aaaaaaaaaaaaaaa();"); 5664 verifyFormat("aaaaaaaaaaaaa->aaaaaaaaaaaaaaaaaaaaaaaa()\n" 5665 " ->aaaaaaaaaaaaaae(0)\n" 5666 " ->aaaaaaaaaaaaaaa();"); 5667 5668 // Don't linewrap after very short segments. 5669 verifyFormat("a().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5670 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5671 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 5672 verifyFormat("aa().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5673 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5674 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 5675 verifyFormat("aaa()\n" 5676 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5677 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5678 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 5679 5680 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n" 5681 " .aaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5682 " .has<bbbbbbbbbbbbbbbbbbbbb>();"); 5683 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n" 5684 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n" 5685 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>();"); 5686 5687 // Prefer not to break after empty parentheses. 5688 verifyFormat("FirstToken->WhitespaceRange.getBegin().getLocWithOffset(\n" 5689 " First->LastNewlineOffset);"); 5690 5691 // Prefer not to create "hanging" indents. 5692 verifyFormat( 5693 "return !soooooooooooooome_map\n" 5694 " .insert(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5695 " .second;"); 5696 verifyFormat( 5697 "return aaaaaaaaaaaaaaaa\n" 5698 " .aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa)\n" 5699 " .aaaa(aaaaaaaaaaaaaa);"); 5700 // No hanging indent here. 5701 verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa.aaaaaaaaaaaaaaa(\n" 5702 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5703 verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa().aaaaaaaaaaaaaaa(\n" 5704 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5705 verifyFormat("aaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n" 5706 " .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5707 getLLVMStyleWithColumns(60)); 5708 verifyFormat("aaaaaaaaaaaaaaaaaa\n" 5709 " .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n" 5710 " .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5711 getLLVMStyleWithColumns(59)); 5712 verifyFormat("aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5713 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5714 " .aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5715 5716 // Dont break if only closing statements before member call 5717 verifyFormat("test() {\n" 5718 " ([]() -> {\n" 5719 " int b = 32;\n" 5720 " return 3;\n" 5721 " }).foo();\n" 5722 "}"); 5723 verifyFormat("test() {\n" 5724 " (\n" 5725 " []() -> {\n" 5726 " int b = 32;\n" 5727 " return 3;\n" 5728 " },\n" 5729 " foo, bar)\n" 5730 " .foo();\n" 5731 "}"); 5732 verifyFormat("test() {\n" 5733 " ([]() -> {\n" 5734 " int b = 32;\n" 5735 " return 3;\n" 5736 " })\n" 5737 " .foo()\n" 5738 " .bar();\n" 5739 "}"); 5740 verifyFormat("test() {\n" 5741 " ([]() -> {\n" 5742 " int b = 32;\n" 5743 " return 3;\n" 5744 " })\n" 5745 " .foo(\"aaaaaaaaaaaaaaaaa\"\n" 5746 " \"bbbb\");\n" 5747 "}", 5748 getLLVMStyleWithColumns(30)); 5749 } 5750 5751 TEST_F(FormatTest, BreaksAccordingToOperatorPrecedence) { 5752 verifyFormat( 5753 "if (aaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 5754 " bbbbbbbbbbbbbbbbbbbbbbbbb && ccccccccccccccccccccccccc) {\n}"); 5755 verifyFormat( 5756 "if (aaaaaaaaaaaaaaaaaaaaaaaaa or\n" 5757 " bbbbbbbbbbbbbbbbbbbbbbbbb and cccccccccccccccccccccccc) {\n}"); 5758 5759 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa && bbbbbbbbbbbbbbbbbbbbbbbbb ||\n" 5760 " ccccccccccccccccccccccccc) {\n}"); 5761 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa and bbbbbbbbbbbbbbbbbbbbbbbb or\n" 5762 " ccccccccccccccccccccccccc) {\n}"); 5763 5764 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb ||\n" 5765 " ccccccccccccccccccccccccc) {\n}"); 5766 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb or\n" 5767 " ccccccccccccccccccccccccc) {\n}"); 5768 5769 verifyFormat( 5770 "if ((aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb) &&\n" 5771 " ccccccccccccccccccccccccc) {\n}"); 5772 verifyFormat( 5773 "if ((aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb) and\n" 5774 " ccccccccccccccccccccccccc) {\n}"); 5775 5776 verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA ||\n" 5777 " bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB ||\n" 5778 " cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC ||\n" 5779 " dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;"); 5780 verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA or\n" 5781 " bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB or\n" 5782 " cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC or\n" 5783 " dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;"); 5784 5785 verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa ||\n" 5786 " aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) &&\n" 5787 " aaaaaaaaaaaaaaa != aa) {\n}"); 5788 verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa or\n" 5789 " aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) and\n" 5790 " aaaaaaaaaaaaaaa != aa) {\n}"); 5791 } 5792 5793 TEST_F(FormatTest, BreaksAfterAssignments) { 5794 verifyFormat( 5795 "unsigned Cost =\n" 5796 " TTI.getMemoryOpCost(I->getOpcode(), VectorTy, SI->getAlignment(),\n" 5797 " SI->getPointerAddressSpaceee());\n"); 5798 verifyFormat( 5799 "CharSourceRange LineRange = CharSourceRange::getTokenRange(\n" 5800 " Line.Tokens.front().Tok.getLo(), Line.Tokens.back().Tok.getLoc());"); 5801 5802 verifyFormat( 5803 "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa = aaaaaaaaaaaaaa(0).aaaa().aaaaaaaaa(\n" 5804 " aaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaa);"); 5805 verifyFormat("unsigned OriginalStartColumn =\n" 5806 " SourceMgr.getSpellingColumnNumber(\n" 5807 " Current.FormatTok.getStartOfNonWhitespace()) -\n" 5808 " 1;"); 5809 } 5810 5811 TEST_F(FormatTest, ConfigurableBreakAssignmentPenalty) { 5812 FormatStyle Style = getLLVMStyle(); 5813 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 5814 " bbbbbbbbbbbbbbbbbbbbbbbbbb + cccccccccccccccccccccccccc;", 5815 Style); 5816 5817 Style.PenaltyBreakAssignment = 20; 5818 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa = bbbbbbbbbbbbbbbbbbbbbbbbbb +\n" 5819 " cccccccccccccccccccccccccc;", 5820 Style); 5821 } 5822 5823 TEST_F(FormatTest, AlignsAfterAssignments) { 5824 verifyFormat( 5825 "int Result = aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5826 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5827 verifyFormat( 5828 "Result += aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5829 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5830 verifyFormat( 5831 "Result >>= aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5832 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5833 verifyFormat( 5834 "int Result = (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5835 " aaaaaaaaaaaaaaaaaaaaaaaaa);"); 5836 verifyFormat( 5837 "double LooooooooooooooooooooooooongResult = aaaaaaaaaaaaaaaaaaaaaaaa +\n" 5838 " aaaaaaaaaaaaaaaaaaaaaaaa +\n" 5839 " aaaaaaaaaaaaaaaaaaaaaaaa;"); 5840 } 5841 5842 TEST_F(FormatTest, AlignsAfterReturn) { 5843 verifyFormat( 5844 "return aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5845 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5846 verifyFormat( 5847 "return (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5848 " aaaaaaaaaaaaaaaaaaaaaaaaa);"); 5849 verifyFormat( 5850 "return aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n" 5851 " aaaaaaaaaaaaaaaaaaaaaa();"); 5852 verifyFormat( 5853 "return (aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n" 5854 " aaaaaaaaaaaaaaaaaaaaaa());"); 5855 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5856 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5857 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5858 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) &&\n" 5859 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5860 verifyFormat("return\n" 5861 " // true if code is one of a or b.\n" 5862 " code == a || code == b;"); 5863 } 5864 5865 TEST_F(FormatTest, AlignsAfterOpenBracket) { 5866 verifyFormat( 5867 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n" 5868 " aaaaaaaaa aaaaaaa) {}"); 5869 verifyFormat( 5870 "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n" 5871 " aaaaaaaaaaa aaaaaaaaa);"); 5872 verifyFormat( 5873 "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n" 5874 " aaaaaaaaaaaaaaaaaaaaa));"); 5875 FormatStyle Style = getLLVMStyle(); 5876 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 5877 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5878 " aaaaaaaaaaa aaaaaaaa, aaaaaaaaa aaaaaaa) {}", 5879 Style); 5880 verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n" 5881 " aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaa aaaaaaaaa);", 5882 Style); 5883 verifyFormat("SomeLongVariableName->someFunction(\n" 5884 " foooooooo(aaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa));", 5885 Style); 5886 verifyFormat( 5887 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n" 5888 " aaaaaaaaa aaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 5889 Style); 5890 verifyFormat( 5891 "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n" 5892 " aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5893 Style); 5894 verifyFormat( 5895 "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n" 5896 " aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));", 5897 Style); 5898 5899 verifyFormat("bbbbbbbbbbbb(aaaaaaaaaaaaaaaaaaaaaaaa, //\n" 5900 " ccccccc(aaaaaaaaaaaaaaaaa, //\n" 5901 " b));", 5902 Style); 5903 5904 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 5905 Style.BinPackArguments = false; 5906 Style.BinPackParameters = false; 5907 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5908 " aaaaaaaaaaa aaaaaaaa,\n" 5909 " aaaaaaaaa aaaaaaa,\n" 5910 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 5911 Style); 5912 verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n" 5913 " aaaaaaaaaaa aaaaaaaaa,\n" 5914 " aaaaaaaaaaa aaaaaaaaa,\n" 5915 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5916 Style); 5917 verifyFormat("SomeLongVariableName->someFunction(foooooooo(\n" 5918 " aaaaaaaaaaaaaaa,\n" 5919 " aaaaaaaaaaaaaaaaaaaaa,\n" 5920 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));", 5921 Style); 5922 verifyFormat( 5923 "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa(\n" 5924 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));", 5925 Style); 5926 verifyFormat( 5927 "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaa.aaaaaaaaaa(\n" 5928 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));", 5929 Style); 5930 verifyFormat( 5931 "aaaaaaaaaaaaaaaaaaaaaaaa(\n" 5932 " aaaaaaaaaaaaaaaaaaaaa(\n" 5933 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)),\n" 5934 " aaaaaaaaaaaaaaaa);", 5935 Style); 5936 verifyFormat( 5937 "aaaaaaaaaaaaaaaaaaaaaaaa(\n" 5938 " aaaaaaaaaaaaaaaaaaaaa(\n" 5939 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)) &&\n" 5940 " aaaaaaaaaaaaaaaa);", 5941 Style); 5942 } 5943 5944 TEST_F(FormatTest, ParenthesesAndOperandAlignment) { 5945 FormatStyle Style = getLLVMStyleWithColumns(40); 5946 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5947 " bbbbbbbbbbbbbbbbbbbbbb);", 5948 Style); 5949 Style.AlignAfterOpenBracket = FormatStyle::BAS_Align; 5950 Style.AlignOperands = FormatStyle::OAS_DontAlign; 5951 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5952 " bbbbbbbbbbbbbbbbbbbbbb);", 5953 Style); 5954 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 5955 Style.AlignOperands = FormatStyle::OAS_Align; 5956 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5957 " bbbbbbbbbbbbbbbbbbbbbb);", 5958 Style); 5959 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 5960 Style.AlignOperands = FormatStyle::OAS_DontAlign; 5961 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5962 " bbbbbbbbbbbbbbbbbbbbbb);", 5963 Style); 5964 } 5965 5966 TEST_F(FormatTest, BreaksConditionalExpressions) { 5967 verifyFormat( 5968 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5969 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5970 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5971 verifyFormat( 5972 "aaaa(aaaaaaaaaa, aaaaaaaa,\n" 5973 " aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5974 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5975 verifyFormat( 5976 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5977 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5978 verifyFormat("aaaa(aaaaaaaaa, aaaaaaaaa,\n" 5979 " aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5980 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5981 verifyFormat( 5982 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa)\n" 5983 " : aaaaaaaaaaaaa);"); 5984 verifyFormat( 5985 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5986 " aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5987 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5988 " aaaaaaaaaaaaa);"); 5989 verifyFormat( 5990 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5991 " aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5992 " aaaaaaaaaaaaa);"); 5993 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5994 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5995 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5996 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5997 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5998 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5999 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6000 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6001 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6002 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6003 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 6004 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6005 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6006 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6007 " ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6008 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 6009 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6010 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6011 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6012 " : aaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6013 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n" 6014 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6015 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6016 " : aaaaaaaaaaaaaaaa;"); 6017 verifyFormat( 6018 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6019 " ? aaaaaaaaaaaaaaa\n" 6020 " : aaaaaaaaaaaaaaa;"); 6021 verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n" 6022 " aaaaaaaaa\n" 6023 " ? b\n" 6024 " : c);"); 6025 verifyFormat("return aaaa == bbbb\n" 6026 " // comment\n" 6027 " ? aaaa\n" 6028 " : bbbb;"); 6029 verifyFormat("unsigned Indent =\n" 6030 " format(TheLine.First,\n" 6031 " IndentForLevel[TheLine.Level] >= 0\n" 6032 " ? IndentForLevel[TheLine.Level]\n" 6033 " : TheLine * 2,\n" 6034 " TheLine.InPPDirective, PreviousEndOfLineColumn);", 6035 getLLVMStyleWithColumns(60)); 6036 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n" 6037 " ? aaaaaaaaaaaaaaa\n" 6038 " : bbbbbbbbbbbbbbb //\n" 6039 " ? ccccccccccccccc\n" 6040 " : ddddddddddddddd;"); 6041 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n" 6042 " ? aaaaaaaaaaaaaaa\n" 6043 " : (bbbbbbbbbbbbbbb //\n" 6044 " ? ccccccccccccccc\n" 6045 " : ddddddddddddddd);"); 6046 verifyFormat( 6047 "int aaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6048 " ? aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 6049 " aaaaaaaaaaaaaaaaaaaaa +\n" 6050 " aaaaaaaaaaaaaaaaaaaaa\n" 6051 " : aaaaaaaaaa;"); 6052 verifyFormat( 6053 "aaaaaa = aaaaaaaaaaaa ? aaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6054 " : aaaaaaaaaaaaaaaaaaaaaa\n" 6055 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6056 6057 FormatStyle NoBinPacking = getLLVMStyle(); 6058 NoBinPacking.BinPackArguments = false; 6059 verifyFormat( 6060 "void f() {\n" 6061 " g(aaa,\n" 6062 " aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n" 6063 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6064 " ? aaaaaaaaaaaaaaa\n" 6065 " : aaaaaaaaaaaaaaa);\n" 6066 "}", 6067 NoBinPacking); 6068 verifyFormat( 6069 "void f() {\n" 6070 " g(aaa,\n" 6071 " aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n" 6072 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6073 " ?: aaaaaaaaaaaaaaa);\n" 6074 "}", 6075 NoBinPacking); 6076 6077 verifyFormat("SomeFunction(aaaaaaaaaaaaaaaaa,\n" 6078 " // comment.\n" 6079 " ccccccccccccccccccccccccccccccccccccccc\n" 6080 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6081 " : bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);"); 6082 6083 // Assignments in conditional expressions. Apparently not uncommon :-(. 6084 verifyFormat("return a != b\n" 6085 " // comment\n" 6086 " ? a = b\n" 6087 " : a = b;"); 6088 verifyFormat("return a != b\n" 6089 " // comment\n" 6090 " ? a = a != b\n" 6091 " // comment\n" 6092 " ? a = b\n" 6093 " : a\n" 6094 " : a;\n"); 6095 verifyFormat("return a != b\n" 6096 " // comment\n" 6097 " ? a\n" 6098 " : a = a != b\n" 6099 " // comment\n" 6100 " ? a = b\n" 6101 " : a;"); 6102 6103 // Chained conditionals 6104 FormatStyle Style = getLLVMStyle(); 6105 Style.ColumnLimit = 70; 6106 Style.AlignOperands = FormatStyle::OAS_Align; 6107 verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n" 6108 " : bbbbbbbbbbbbbb ? 2222222222222222\n" 6109 " : 3333333333333333;", 6110 Style); 6111 verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n" 6112 " : bbbbbbbbbb ? 2222222222222222\n" 6113 " : 3333333333333333;", 6114 Style); 6115 verifyFormat("return aaaaaaaaaa ? 1111111111111111\n" 6116 " : bbbbbbbbbbbbbbbb ? 2222222222222222\n" 6117 " : 3333333333333333;", 6118 Style); 6119 verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n" 6120 " : bbbbbbbbbbbbbb ? 222222\n" 6121 " : 333333;", 6122 Style); 6123 verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n" 6124 " : bbbbbbbbbbbbbb ? 2222222222222222\n" 6125 " : cccccccccccccc ? 3333333333333333\n" 6126 " : 4444444444444444;", 6127 Style); 6128 verifyFormat("return aaaaaaaaaaaaaaaa ? (aaa ? bbb : ccc)\n" 6129 " : bbbbbbbbbbbbbb ? 2222222222222222\n" 6130 " : 3333333333333333;", 6131 Style); 6132 verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n" 6133 " : bbbbbbbbbbbbbb ? 2222222222222222\n" 6134 " : (aaa ? bbb : ccc);", 6135 Style); 6136 verifyFormat( 6137 "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n" 6138 " : cccccccccccccccccc)\n" 6139 " : bbbbbbbbbbbbbb ? 2222222222222222\n" 6140 " : 3333333333333333;", 6141 Style); 6142 verifyFormat( 6143 "return aaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n" 6144 " : cccccccccccccccccc)\n" 6145 " : bbbbbbbbbbbbbb ? 2222222222222222\n" 6146 " : 3333333333333333;", 6147 Style); 6148 verifyFormat( 6149 "return aaaaaaaaa ? a = (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n" 6150 " : dddddddddddddddddd)\n" 6151 " : bbbbbbbbbbbbbb ? 2222222222222222\n" 6152 " : 3333333333333333;", 6153 Style); 6154 verifyFormat( 6155 "return aaaaaaaaa ? a + (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n" 6156 " : dddddddddddddddddd)\n" 6157 " : bbbbbbbbbbbbbb ? 2222222222222222\n" 6158 " : 3333333333333333;", 6159 Style); 6160 verifyFormat( 6161 "return aaaaaaaaa ? 1111111111111111\n" 6162 " : bbbbbbbbbbbbbb ? 2222222222222222\n" 6163 " : a + (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n" 6164 " : dddddddddddddddddd)\n", 6165 Style); 6166 verifyFormat( 6167 "return aaaaaaaaaaaaaaaa ? 1111111111111111\n" 6168 " : bbbbbbbbbbbbbb ? 2222222222222222\n" 6169 " : (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n" 6170 " : cccccccccccccccccc);", 6171 Style); 6172 verifyFormat( 6173 "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n" 6174 " : ccccccccccccccc ? dddddddddddddddddd\n" 6175 " : eeeeeeeeeeeeeeeeee)\n" 6176 " : bbbbbbbbbbbbbb ? 2222222222222222\n" 6177 " : 3333333333333333;", 6178 Style); 6179 verifyFormat( 6180 "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n" 6181 " : ccccccccccccccc ? dddddddddddddddddd\n" 6182 " : eeeeeeeeeeeeeeeeee)\n" 6183 " : bbbbbbbbbbbbbb ? 2222222222222222\n" 6184 " : 3333333333333333;", 6185 Style); 6186 verifyFormat( 6187 "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n" 6188 " : cccccccccccc ? dddddddddddddddddd\n" 6189 " : eeeeeeeeeeeeeeeeee)\n" 6190 " : bbbbbbbbbbbbbb ? 2222222222222222\n" 6191 " : 3333333333333333;", 6192 Style); 6193 verifyFormat( 6194 "return aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n" 6195 " : cccccccccccccccccc\n" 6196 " : bbbbbbbbbbbbbb ? 2222222222222222\n" 6197 " : 3333333333333333;", 6198 Style); 6199 verifyFormat( 6200 "return aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n" 6201 " : cccccccccccccccc ? dddddddddddddddddd\n" 6202 " : eeeeeeeeeeeeeeeeee\n" 6203 " : bbbbbbbbbbbbbb ? 2222222222222222\n" 6204 " : 3333333333333333;", 6205 Style); 6206 verifyFormat("return aaaaaaaaaaaaaaaaaaaaa\n" 6207 " ? (aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n" 6208 " : cccccccccccccccccc ? dddddddddddddddddd\n" 6209 " : eeeeeeeeeeeeeeeeee)\n" 6210 " : bbbbbbbbbbbbbbbbbbb ? 2222222222222222\n" 6211 " : 3333333333333333;", 6212 Style); 6213 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaa\n" 6214 " ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n" 6215 " : cccccccccccccccc ? dddddddddddddddddd\n" 6216 " : eeeeeeeeeeeeeeeeee\n" 6217 " : bbbbbbbbbbbbbbbbbbbbbbb ? 2222222222222222\n" 6218 " : 3333333333333333;", 6219 Style); 6220 } 6221 6222 TEST_F(FormatTest, BreaksConditionalExpressionsAfterOperator) { 6223 FormatStyle Style = getLLVMStyle(); 6224 Style.BreakBeforeTernaryOperators = false; 6225 Style.ColumnLimit = 70; 6226 verifyFormat( 6227 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 6228 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 6229 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 6230 Style); 6231 verifyFormat( 6232 "aaaa(aaaaaaaaaa, aaaaaaaa,\n" 6233 " aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 6234 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 6235 Style); 6236 verifyFormat( 6237 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 6238 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 6239 Style); 6240 verifyFormat("aaaa(aaaaaaaa, aaaaaaaaaa,\n" 6241 " aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 6242 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 6243 Style); 6244 verifyFormat( 6245 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa) :\n" 6246 " aaaaaaaaaaaaa);", 6247 Style); 6248 verifyFormat( 6249 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6250 " aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 6251 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6252 " aaaaaaaaaaaaa);", 6253 Style); 6254 verifyFormat( 6255 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6256 " aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6257 " aaaaaaaaaaaaa);", 6258 Style); 6259 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 6260 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6261 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n" 6262 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6263 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 6264 Style); 6265 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6266 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 6267 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6268 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n" 6269 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6270 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 6271 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);", 6272 Style); 6273 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6274 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?:\n" 6275 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6276 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 6277 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);", 6278 Style); 6279 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 6280 " aaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 6281 " aaaaaaaaaaaaaaaaaaaaaaaaaaa;", 6282 Style); 6283 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n" 6284 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 6285 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 6286 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 6287 Style); 6288 verifyFormat( 6289 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 6290 " aaaaaaaaaaaaaaa :\n" 6291 " aaaaaaaaaaaaaaa;", 6292 Style); 6293 verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n" 6294 " aaaaaaaaa ?\n" 6295 " b :\n" 6296 " c);", 6297 Style); 6298 verifyFormat("unsigned Indent =\n" 6299 " format(TheLine.First,\n" 6300 " IndentForLevel[TheLine.Level] >= 0 ?\n" 6301 " IndentForLevel[TheLine.Level] :\n" 6302 " TheLine * 2,\n" 6303 " TheLine.InPPDirective, PreviousEndOfLineColumn);", 6304 Style); 6305 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n" 6306 " aaaaaaaaaaaaaaa :\n" 6307 " bbbbbbbbbbbbbbb ? //\n" 6308 " ccccccccccccccc :\n" 6309 " ddddddddddddddd;", 6310 Style); 6311 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n" 6312 " aaaaaaaaaaaaaaa :\n" 6313 " (bbbbbbbbbbbbbbb ? //\n" 6314 " ccccccccccccccc :\n" 6315 " ddddddddddddddd);", 6316 Style); 6317 verifyFormat("int i = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 6318 " /*bbbbbbbbbbbbbbb=*/bbbbbbbbbbbbbbbbbbbbbbbbb :\n" 6319 " ccccccccccccccccccccccccccc;", 6320 Style); 6321 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 6322 " aaaaa :\n" 6323 " bbbbbbbbbbbbbbb + cccccccccccccccc;", 6324 Style); 6325 6326 // Chained conditionals 6327 verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n" 6328 " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n" 6329 " 3333333333333333;", 6330 Style); 6331 verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n" 6332 " bbbbbbbbbb ? 2222222222222222 :\n" 6333 " 3333333333333333;", 6334 Style); 6335 verifyFormat("return aaaaaaaaaa ? 1111111111111111 :\n" 6336 " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n" 6337 " 3333333333333333;", 6338 Style); 6339 verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n" 6340 " bbbbbbbbbbbbbbbb ? 222222 :\n" 6341 " 333333;", 6342 Style); 6343 verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n" 6344 " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n" 6345 " cccccccccccccccc ? 3333333333333333 :\n" 6346 " 4444444444444444;", 6347 Style); 6348 verifyFormat("return aaaaaaaaaaaaaaaa ? (aaa ? bbb : ccc) :\n" 6349 " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n" 6350 " 3333333333333333;", 6351 Style); 6352 verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n" 6353 " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n" 6354 " (aaa ? bbb : ccc);", 6355 Style); 6356 verifyFormat( 6357 "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n" 6358 " cccccccccccccccccc) :\n" 6359 " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n" 6360 " 3333333333333333;", 6361 Style); 6362 verifyFormat( 6363 "return aaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n" 6364 " cccccccccccccccccc) :\n" 6365 " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n" 6366 " 3333333333333333;", 6367 Style); 6368 verifyFormat( 6369 "return aaaaaaaaa ? a = (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n" 6370 " dddddddddddddddddd) :\n" 6371 " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n" 6372 " 3333333333333333;", 6373 Style); 6374 verifyFormat( 6375 "return aaaaaaaaa ? a + (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n" 6376 " dddddddddddddddddd) :\n" 6377 " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n" 6378 " 3333333333333333;", 6379 Style); 6380 verifyFormat( 6381 "return aaaaaaaaa ? 1111111111111111 :\n" 6382 " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n" 6383 " a + (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n" 6384 " dddddddddddddddddd)\n", 6385 Style); 6386 verifyFormat( 6387 "return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n" 6388 " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n" 6389 " (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n" 6390 " cccccccccccccccccc);", 6391 Style); 6392 verifyFormat( 6393 "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n" 6394 " ccccccccccccccccc ? dddddddddddddddddd :\n" 6395 " eeeeeeeeeeeeeeeeee) :\n" 6396 " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n" 6397 " 3333333333333333;", 6398 Style); 6399 verifyFormat( 6400 "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n" 6401 " ccccccccccccc ? dddddddddddddddddd :\n" 6402 " eeeeeeeeeeeeeeeeee) :\n" 6403 " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n" 6404 " 3333333333333333;", 6405 Style); 6406 verifyFormat( 6407 "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n" 6408 " ccccccccccccccccc ? dddddddddddddddddd :\n" 6409 " eeeeeeeeeeeeeeeeee) :\n" 6410 " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n" 6411 " 3333333333333333;", 6412 Style); 6413 verifyFormat( 6414 "return aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n" 6415 " cccccccccccccccccc :\n" 6416 " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n" 6417 " 3333333333333333;", 6418 Style); 6419 verifyFormat( 6420 "return aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n" 6421 " cccccccccccccccccc ? dddddddddddddddddd :\n" 6422 " eeeeeeeeeeeeeeeeee :\n" 6423 " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n" 6424 " 3333333333333333;", 6425 Style); 6426 verifyFormat("return aaaaaaaaaaaaaaaaaaaaa ?\n" 6427 " (aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n" 6428 " cccccccccccccccccc ? dddddddddddddddddd :\n" 6429 " eeeeeeeeeeeeeeeeee) :\n" 6430 " bbbbbbbbbbbbbbbbbbbbb ? 2222222222222222 :\n" 6431 " 3333333333333333;", 6432 Style); 6433 verifyFormat("return aaaaaaaaaaaaaaaaaaaaa ?\n" 6434 " aaaaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n" 6435 " cccccccccccccccccccc ? dddddddddddddddddd :\n" 6436 " eeeeeeeeeeeeeeeeee :\n" 6437 " bbbbbbbbbbbbbbbbbbbbb ? 2222222222222222 :\n" 6438 " 3333333333333333;", 6439 Style); 6440 } 6441 6442 TEST_F(FormatTest, DeclarationsOfMultipleVariables) { 6443 verifyFormat("bool aaaaaaaaaaaaaaaaa = aaaaaa->aaaaaaaaaaaaaaaaa(),\n" 6444 " aaaaaaaaaaa = aaaaaa->aaaaaaaaaaa();"); 6445 verifyFormat("bool a = true, b = false;"); 6446 6447 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaa =\n" 6448 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa),\n" 6449 " bbbbbbbbbbbbbbbbbbbbbbbbb =\n" 6450 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(bbbbbbbbbbbbbbbb);"); 6451 verifyFormat( 6452 "bool aaaaaaaaaaaaaaaaaaaaa =\n" 6453 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb && cccccccccccccccccccccccccccc,\n" 6454 " d = e && f;"); 6455 verifyFormat("aaaaaaaaa a = aaaaaaaaaaaaaaaaaaaa, b = bbbbbbbbbbbbbbbbbbbb,\n" 6456 " c = cccccccccccccccccccc, d = dddddddddddddddddddd;"); 6457 verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n" 6458 " *c = ccccccccccccccccccc, *d = ddddddddddddddddddd;"); 6459 verifyFormat("aaaaaaaaa ***a = aaaaaaaaaaaaaaaaaaa, ***b = bbbbbbbbbbbbbbb,\n" 6460 " ***c = ccccccccccccccccccc, ***d = ddddddddddddddd;"); 6461 6462 FormatStyle Style = getGoogleStyle(); 6463 Style.PointerAlignment = FormatStyle::PAS_Left; 6464 Style.DerivePointerAlignment = false; 6465 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6466 " *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaa,\n" 6467 " *b = bbbbbbbbbbbbbbbbbbb;", 6468 Style); 6469 verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n" 6470 " *b = bbbbbbbbbbbbbbbbbbb, *d = ddddddddddddddddddd;", 6471 Style); 6472 verifyFormat("vector<int*> a, b;", Style); 6473 verifyFormat("for (int *p, *q; p != q; p = p->next) {\n}", Style); 6474 } 6475 6476 TEST_F(FormatTest, ConditionalExpressionsInBrackets) { 6477 verifyFormat("arr[foo ? bar : baz];"); 6478 verifyFormat("f()[foo ? bar : baz];"); 6479 verifyFormat("(a + b)[foo ? bar : baz];"); 6480 verifyFormat("arr[foo ? (4 > 5 ? 4 : 5) : 5 < 5 ? 5 : 7];"); 6481 } 6482 6483 TEST_F(FormatTest, AlignsStringLiterals) { 6484 verifyFormat("loooooooooooooooooooooooooongFunction(\"short literal \"\n" 6485 " \"short literal\");"); 6486 verifyFormat( 6487 "looooooooooooooooooooooooongFunction(\n" 6488 " \"short literal\"\n" 6489 " \"looooooooooooooooooooooooooooooooooooooooooooooooong literal\");"); 6490 verifyFormat("someFunction(\"Always break between multi-line\"\n" 6491 " \" string literals\",\n" 6492 " and, other, parameters);"); 6493 EXPECT_EQ("fun + \"1243\" /* comment */\n" 6494 " \"5678\";", 6495 format("fun + \"1243\" /* comment */\n" 6496 " \"5678\";", 6497 getLLVMStyleWithColumns(28))); 6498 EXPECT_EQ( 6499 "aaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 6500 " \"aaaaaaaaaaaaaaaaaaaaa\"\n" 6501 " \"aaaaaaaaaaaaaaaa\";", 6502 format("aaaaaa =" 6503 "\"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa " 6504 "aaaaaaaaaaaaaaaaaaaaa\" " 6505 "\"aaaaaaaaaaaaaaaa\";")); 6506 verifyFormat("a = a + \"a\"\n" 6507 " \"a\"\n" 6508 " \"a\";"); 6509 verifyFormat("f(\"a\", \"b\"\n" 6510 " \"c\");"); 6511 6512 verifyFormat( 6513 "#define LL_FORMAT \"ll\"\n" 6514 "printf(\"aaaaa: %d, bbbbbb: %\" LL_FORMAT \"d, cccccccc: %\" LL_FORMAT\n" 6515 " \"d, ddddddddd: %\" LL_FORMAT \"d\");"); 6516 6517 verifyFormat("#define A(X) \\\n" 6518 " \"aaaaa\" #X \"bbbbbb\" \\\n" 6519 " \"ccccc\"", 6520 getLLVMStyleWithColumns(23)); 6521 verifyFormat("#define A \"def\"\n" 6522 "f(\"abc\" A \"ghi\"\n" 6523 " \"jkl\");"); 6524 6525 verifyFormat("f(L\"a\"\n" 6526 " L\"b\");"); 6527 verifyFormat("#define A(X) \\\n" 6528 " L\"aaaaa\" #X L\"bbbbbb\" \\\n" 6529 " L\"ccccc\"", 6530 getLLVMStyleWithColumns(25)); 6531 6532 verifyFormat("f(@\"a\"\n" 6533 " @\"b\");"); 6534 verifyFormat("NSString s = @\"a\"\n" 6535 " @\"b\"\n" 6536 " @\"c\";"); 6537 verifyFormat("NSString s = @\"a\"\n" 6538 " \"b\"\n" 6539 " \"c\";"); 6540 } 6541 6542 TEST_F(FormatTest, ReturnTypeBreakingStyle) { 6543 FormatStyle Style = getLLVMStyle(); 6544 // No declarations or definitions should be moved to own line. 6545 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_None; 6546 verifyFormat("class A {\n" 6547 " int f() { return 1; }\n" 6548 " int g();\n" 6549 "};\n" 6550 "int f() { return 1; }\n" 6551 "int g();\n", 6552 Style); 6553 6554 // All declarations and definitions should have the return type moved to its 6555 // own 6556 // line. 6557 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All; 6558 verifyFormat("class E {\n" 6559 " int\n" 6560 " f() {\n" 6561 " return 1;\n" 6562 " }\n" 6563 " int\n" 6564 " g();\n" 6565 "};\n" 6566 "int\n" 6567 "f() {\n" 6568 " return 1;\n" 6569 "}\n" 6570 "int\n" 6571 "g();\n", 6572 Style); 6573 6574 // Top-level definitions, and no kinds of declarations should have the 6575 // return type moved to its own line. 6576 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevelDefinitions; 6577 verifyFormat("class B {\n" 6578 " int f() { return 1; }\n" 6579 " int g();\n" 6580 "};\n" 6581 "int\n" 6582 "f() {\n" 6583 " return 1;\n" 6584 "}\n" 6585 "int g();\n", 6586 Style); 6587 6588 // Top-level definitions and declarations should have the return type moved 6589 // to its own line. 6590 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevel; 6591 verifyFormat("class C {\n" 6592 " int f() { return 1; }\n" 6593 " int g();\n" 6594 "};\n" 6595 "int\n" 6596 "f() {\n" 6597 " return 1;\n" 6598 "}\n" 6599 "int\n" 6600 "g();\n", 6601 Style); 6602 6603 // All definitions should have the return type moved to its own line, but no 6604 // kinds of declarations. 6605 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions; 6606 verifyFormat("class D {\n" 6607 " int\n" 6608 " f() {\n" 6609 " return 1;\n" 6610 " }\n" 6611 " int g();\n" 6612 "};\n" 6613 "int\n" 6614 "f() {\n" 6615 " return 1;\n" 6616 "}\n" 6617 "int g();\n", 6618 Style); 6619 verifyFormat("const char *\n" 6620 "f(void) {\n" // Break here. 6621 " return \"\";\n" 6622 "}\n" 6623 "const char *bar(void);\n", // No break here. 6624 Style); 6625 verifyFormat("template <class T>\n" 6626 "T *\n" 6627 "f(T &c) {\n" // Break here. 6628 " return NULL;\n" 6629 "}\n" 6630 "template <class T> T *f(T &c);\n", // No break here. 6631 Style); 6632 verifyFormat("class C {\n" 6633 " int\n" 6634 " operator+() {\n" 6635 " return 1;\n" 6636 " }\n" 6637 " int\n" 6638 " operator()() {\n" 6639 " return 1;\n" 6640 " }\n" 6641 "};\n", 6642 Style); 6643 verifyFormat("void\n" 6644 "A::operator()() {}\n" 6645 "void\n" 6646 "A::operator>>() {}\n" 6647 "void\n" 6648 "A::operator+() {}\n" 6649 "void\n" 6650 "A::operator*() {}\n" 6651 "void\n" 6652 "A::operator->() {}\n" 6653 "void\n" 6654 "A::operator void *() {}\n" 6655 "void\n" 6656 "A::operator void &() {}\n" 6657 "void\n" 6658 "A::operator void &&() {}\n" 6659 "void\n" 6660 "A::operator char *() {}\n" 6661 "void\n" 6662 "A::operator[]() {}\n" 6663 "void\n" 6664 "A::operator!() {}\n" 6665 "void\n" 6666 "A::operator**() {}\n" 6667 "void\n" 6668 "A::operator<Foo> *() {}\n" 6669 "void\n" 6670 "A::operator<Foo> **() {}\n" 6671 "void\n" 6672 "A::operator<Foo> &() {}\n" 6673 "void\n" 6674 "A::operator void **() {}\n", 6675 Style); 6676 verifyFormat("constexpr auto\n" 6677 "operator()() const -> reference {}\n" 6678 "constexpr auto\n" 6679 "operator>>() const -> reference {}\n" 6680 "constexpr auto\n" 6681 "operator+() const -> reference {}\n" 6682 "constexpr auto\n" 6683 "operator*() const -> reference {}\n" 6684 "constexpr auto\n" 6685 "operator->() const -> reference {}\n" 6686 "constexpr auto\n" 6687 "operator++() const -> reference {}\n" 6688 "constexpr auto\n" 6689 "operator void *() const -> reference {}\n" 6690 "constexpr auto\n" 6691 "operator void **() const -> reference {}\n" 6692 "constexpr auto\n" 6693 "operator void *() const -> reference {}\n" 6694 "constexpr auto\n" 6695 "operator void &() const -> reference {}\n" 6696 "constexpr auto\n" 6697 "operator void &&() const -> reference {}\n" 6698 "constexpr auto\n" 6699 "operator char *() const -> reference {}\n" 6700 "constexpr auto\n" 6701 "operator!() const -> reference {}\n" 6702 "constexpr auto\n" 6703 "operator[]() const -> reference {}\n", 6704 Style); 6705 verifyFormat("void *operator new(std::size_t s);", // No break here. 6706 Style); 6707 verifyFormat("void *\n" 6708 "operator new(std::size_t s) {}", 6709 Style); 6710 verifyFormat("void *\n" 6711 "operator delete[](void *ptr) {}", 6712 Style); 6713 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 6714 verifyFormat("const char *\n" 6715 "f(void)\n" // Break here. 6716 "{\n" 6717 " return \"\";\n" 6718 "}\n" 6719 "const char *bar(void);\n", // No break here. 6720 Style); 6721 verifyFormat("template <class T>\n" 6722 "T *\n" // Problem here: no line break 6723 "f(T &c)\n" // Break here. 6724 "{\n" 6725 " return NULL;\n" 6726 "}\n" 6727 "template <class T> T *f(T &c);\n", // No break here. 6728 Style); 6729 verifyFormat("int\n" 6730 "foo(A<bool> a)\n" 6731 "{\n" 6732 " return a;\n" 6733 "}\n", 6734 Style); 6735 verifyFormat("int\n" 6736 "foo(A<8> a)\n" 6737 "{\n" 6738 " return a;\n" 6739 "}\n", 6740 Style); 6741 verifyFormat("int\n" 6742 "foo(A<B<bool>, 8> a)\n" 6743 "{\n" 6744 " return a;\n" 6745 "}\n", 6746 Style); 6747 verifyFormat("int\n" 6748 "foo(A<B<8>, bool> a)\n" 6749 "{\n" 6750 " return a;\n" 6751 "}\n", 6752 Style); 6753 verifyFormat("int\n" 6754 "foo(A<B<bool>, bool> a)\n" 6755 "{\n" 6756 " return a;\n" 6757 "}\n", 6758 Style); 6759 verifyFormat("int\n" 6760 "foo(A<B<8>, 8> a)\n" 6761 "{\n" 6762 " return a;\n" 6763 "}\n", 6764 Style); 6765 6766 Style = getGNUStyle(); 6767 6768 // Test for comments at the end of function declarations. 6769 verifyFormat("void\n" 6770 "foo (int a, /*abc*/ int b) // def\n" 6771 "{\n" 6772 "}\n", 6773 Style); 6774 6775 verifyFormat("void\n" 6776 "foo (int a, /* abc */ int b) /* def */\n" 6777 "{\n" 6778 "}\n", 6779 Style); 6780 6781 // Definitions that should not break after return type 6782 verifyFormat("void foo (int a, int b); // def\n", Style); 6783 verifyFormat("void foo (int a, int b); /* def */\n", Style); 6784 verifyFormat("void foo (int a, int b);\n", Style); 6785 } 6786 6787 TEST_F(FormatTest, AlwaysBreakBeforeMultilineStrings) { 6788 FormatStyle NoBreak = getLLVMStyle(); 6789 NoBreak.AlwaysBreakBeforeMultilineStrings = false; 6790 FormatStyle Break = getLLVMStyle(); 6791 Break.AlwaysBreakBeforeMultilineStrings = true; 6792 verifyFormat("aaaa = \"bbbb\"\n" 6793 " \"cccc\";", 6794 NoBreak); 6795 verifyFormat("aaaa =\n" 6796 " \"bbbb\"\n" 6797 " \"cccc\";", 6798 Break); 6799 verifyFormat("aaaa(\"bbbb\"\n" 6800 " \"cccc\");", 6801 NoBreak); 6802 verifyFormat("aaaa(\n" 6803 " \"bbbb\"\n" 6804 " \"cccc\");", 6805 Break); 6806 verifyFormat("aaaa(qqq, \"bbbb\"\n" 6807 " \"cccc\");", 6808 NoBreak); 6809 verifyFormat("aaaa(qqq,\n" 6810 " \"bbbb\"\n" 6811 " \"cccc\");", 6812 Break); 6813 verifyFormat("aaaa(qqq,\n" 6814 " L\"bbbb\"\n" 6815 " L\"cccc\");", 6816 Break); 6817 verifyFormat("aaaaa(aaaaaa, aaaaaaa(\"aaaa\"\n" 6818 " \"bbbb\"));", 6819 Break); 6820 verifyFormat("string s = someFunction(\n" 6821 " \"abc\"\n" 6822 " \"abc\");", 6823 Break); 6824 6825 // As we break before unary operators, breaking right after them is bad. 6826 verifyFormat("string foo = abc ? \"x\"\n" 6827 " \"blah blah blah blah blah blah\"\n" 6828 " : \"y\";", 6829 Break); 6830 6831 // Don't break if there is no column gain. 6832 verifyFormat("f(\"aaaa\"\n" 6833 " \"bbbb\");", 6834 Break); 6835 6836 // Treat literals with escaped newlines like multi-line string literals. 6837 EXPECT_EQ("x = \"a\\\n" 6838 "b\\\n" 6839 "c\";", 6840 format("x = \"a\\\n" 6841 "b\\\n" 6842 "c\";", 6843 NoBreak)); 6844 EXPECT_EQ("xxxx =\n" 6845 " \"a\\\n" 6846 "b\\\n" 6847 "c\";", 6848 format("xxxx = \"a\\\n" 6849 "b\\\n" 6850 "c\";", 6851 Break)); 6852 6853 EXPECT_EQ("NSString *const kString =\n" 6854 " @\"aaaa\"\n" 6855 " @\"bbbb\";", 6856 format("NSString *const kString = @\"aaaa\"\n" 6857 "@\"bbbb\";", 6858 Break)); 6859 6860 Break.ColumnLimit = 0; 6861 verifyFormat("const char *hello = \"hello llvm\";", Break); 6862 } 6863 6864 TEST_F(FormatTest, AlignsPipes) { 6865 verifyFormat( 6866 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6867 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6868 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6869 verifyFormat( 6870 "aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa\n" 6871 " << aaaaaaaaaaaaaaaaaaaa;"); 6872 verifyFormat( 6873 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6874 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6875 verifyFormat( 6876 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 6877 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6878 verifyFormat( 6879 "llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"\n" 6880 " \"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\"\n" 6881 " << \"ccccccccccccccccccccccccccccccccccccccccccccccccc\";"); 6882 verifyFormat( 6883 "aaaaaaaa << (aaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6884 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6885 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6886 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6887 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6888 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6889 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 6890 verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaaaaaa: \"\n" 6891 " << aaaaaaaaaaaaaaaaa(aaaaaaaa, aaaaaaaaaaa);"); 6892 verifyFormat( 6893 "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6894 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6895 verifyFormat( 6896 "auto Diag = diag() << aaaaaaaaaaaaaaaa(aaaaaaaaaaaa, aaaaaaaaaaaaa,\n" 6897 " aaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6898 6899 verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \"\n" 6900 " << aaaaaaaa.aaaaaaaaaaaa(aaa)->aaaaaaaaaaaaaa();"); 6901 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6902 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6903 " aaaaaaaaaaaaaaaaaaaaa)\n" 6904 " << aaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6905 verifyFormat("LOG_IF(aaa == //\n" 6906 " bbb)\n" 6907 " << a << b;"); 6908 6909 // But sometimes, breaking before the first "<<" is desirable. 6910 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n" 6911 " << aaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaa);"); 6912 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbb)\n" 6913 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6914 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6915 verifyFormat("SemaRef.Diag(Loc, diag::note_for_range_begin_end)\n" 6916 " << BEF << IsTemplate << Description << E->getType();"); 6917 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n" 6918 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6919 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6920 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n" 6921 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6922 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6923 " << aaa;"); 6924 6925 verifyFormat( 6926 "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6927 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6928 6929 // Incomplete string literal. 6930 EXPECT_EQ("llvm::errs() << \"\n" 6931 " << a;", 6932 format("llvm::errs() << \"\n<<a;")); 6933 6934 verifyFormat("void f() {\n" 6935 " CHECK_EQ(aaaa, (*bbbbbbbbb)->cccccc)\n" 6936 " << \"qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\";\n" 6937 "}"); 6938 6939 // Handle 'endl'. 6940 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << endl\n" 6941 " << bbbbbbbbbbbbbbbbbbbbbb << endl;"); 6942 verifyFormat("llvm::errs() << endl << bbbbbbbbbbbbbbbbbbbbbb << endl;"); 6943 6944 // Handle '\n'. 6945 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \"\\n\"\n" 6946 " << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";"); 6947 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \'\\n\'\n" 6948 " << bbbbbbbbbbbbbbbbbbbbbb << \'\\n\';"); 6949 verifyFormat("llvm::errs() << aaaa << \"aaaaaaaaaaaaaaaaaa\\n\"\n" 6950 " << bbbb << \"bbbbbbbbbbbbbbbbbb\\n\";"); 6951 verifyFormat("llvm::errs() << \"\\n\" << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";"); 6952 } 6953 6954 TEST_F(FormatTest, KeepStringLabelValuePairsOnALine) { 6955 verifyFormat("return out << \"somepacket = {\\n\"\n" 6956 " << \" aaaaaa = \" << pkt.aaaaaa << \"\\n\"\n" 6957 " << \" bbbb = \" << pkt.bbbb << \"\\n\"\n" 6958 " << \" cccccc = \" << pkt.cccccc << \"\\n\"\n" 6959 " << \" ddd = [\" << pkt.ddd << \"]\\n\"\n" 6960 " << \"}\";"); 6961 6962 verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n" 6963 " << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n" 6964 " << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa;"); 6965 verifyFormat( 6966 "llvm::outs() << \"aaaaaaaaaaaaaaaaa = \" << aaaaaaaaaaaaaaaaa\n" 6967 " << \"bbbbbbbbbbbbbbbbb = \" << bbbbbbbbbbbbbbbbb\n" 6968 " << \"ccccccccccccccccc = \" << ccccccccccccccccc\n" 6969 " << \"ddddddddddddddddd = \" << ddddddddddddddddd\n" 6970 " << \"eeeeeeeeeeeeeeeee = \" << eeeeeeeeeeeeeeeee;"); 6971 verifyFormat("llvm::outs() << aaaaaaaaaaaaaaaaaaaaaaaa << \"=\"\n" 6972 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 6973 verifyFormat( 6974 "void f() {\n" 6975 " llvm::outs() << \"aaaaaaaaaaaaaaaaaaaa: \"\n" 6976 " << aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 6977 "}"); 6978 6979 // Breaking before the first "<<" is generally not desirable. 6980 verifyFormat( 6981 "llvm::errs()\n" 6982 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6983 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6984 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6985 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 6986 getLLVMStyleWithColumns(70)); 6987 verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaa: \"\n" 6988 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6989 " << \"aaaaaaaaaaaaaaaaaaa: \"\n" 6990 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6991 " << \"aaaaaaaaaaaaaaaaaaa: \"\n" 6992 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 6993 getLLVMStyleWithColumns(70)); 6994 6995 verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n" 6996 " \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n" 6997 " \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa;"); 6998 verifyFormat("string v = StrCat(\"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n" 6999 " \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n" 7000 " \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa);"); 7001 verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" +\n" 7002 " (aaaa + aaaa);", 7003 getLLVMStyleWithColumns(40)); 7004 verifyFormat("string v = StrCat(\"aaaaaaaaaaaa: \" +\n" 7005 " (aaaaaaa + aaaaa));", 7006 getLLVMStyleWithColumns(40)); 7007 verifyFormat( 7008 "string v = StrCat(\"aaaaaaaaaaaaaaaaaaaaaaaaaaa: \",\n" 7009 " SomeFunction(aaaaaaaaaaaa, aaaaaaaa.aaaaaaa),\n" 7010 " bbbbbbbbbbbbbbbbbbbbbbb);"); 7011 } 7012 7013 TEST_F(FormatTest, UnderstandsEquals) { 7014 verifyFormat( 7015 "aaaaaaaaaaaaaaaaa =\n" 7016 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 7017 verifyFormat( 7018 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 7019 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 7020 verifyFormat( 7021 "if (a) {\n" 7022 " f();\n" 7023 "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 7024 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 7025 "}"); 7026 7027 verifyFormat("if (int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 7028 " 100000000 + 10000000) {\n}"); 7029 } 7030 7031 TEST_F(FormatTest, WrapsAtFunctionCallsIfNecessary) { 7032 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n" 7033 " .looooooooooooooooooooooooooooooooooooooongFunction();"); 7034 7035 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n" 7036 " ->looooooooooooooooooooooooooooooooooooooongFunction();"); 7037 7038 verifyFormat( 7039 "LooooooooooooooooooooooooooooooooongObject->shortFunction(Parameter1,\n" 7040 " Parameter2);"); 7041 7042 verifyFormat( 7043 "ShortObject->shortFunction(\n" 7044 " LooooooooooooooooooooooooooooooooooooooooooooooongParameter1,\n" 7045 " LooooooooooooooooooooooooooooooooooooooooooooooongParameter2);"); 7046 7047 verifyFormat("loooooooooooooongFunction(\n" 7048 " LoooooooooooooongObject->looooooooooooooooongFunction());"); 7049 7050 verifyFormat( 7051 "function(LoooooooooooooooooooooooooooooooooooongObject\n" 7052 " ->loooooooooooooooooooooooooooooooooooooooongFunction());"); 7053 7054 verifyFormat("EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n" 7055 " .WillRepeatedly(Return(SomeValue));"); 7056 verifyFormat("void f() {\n" 7057 " EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n" 7058 " .Times(2)\n" 7059 " .WillRepeatedly(Return(SomeValue));\n" 7060 "}"); 7061 verifyFormat("SomeMap[std::pair(aaaaaaaaaaaa, bbbbbbbbbbbbbbb)].insert(\n" 7062 " ccccccccccccccccccccccc);"); 7063 verifyFormat("aaaaa(aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 7064 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 7065 " .aaaaa(aaaaa),\n" 7066 " aaaaaaaaaaaaaaaaaaaaa);"); 7067 verifyFormat("void f() {\n" 7068 " aaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7069 " aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa)->aaaaaaaaa());\n" 7070 "}"); 7071 verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 7072 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 7073 " .aaaaaaaaaaaaaaa(aa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 7074 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 7075 " aaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 7076 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7077 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7078 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7079 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()) {\n" 7080 "}"); 7081 7082 // Here, it is not necessary to wrap at "." or "->". 7083 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaa) ||\n" 7084 " aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 7085 verifyFormat( 7086 "aaaaaaaaaaa->aaaaaaaaa(\n" 7087 " aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 7088 " aaaaaaaaaaaaaaaaaa->aaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa));\n"); 7089 7090 verifyFormat( 7091 "aaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7092 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa().aaaaaaaaaaaaaaaaa());"); 7093 verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() *\n" 7094 " aaaaaaaaa()->aaaaaa()->aaaaa());"); 7095 verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() ||\n" 7096 " aaaaaaaaa()->aaaaaa()->aaaaa());"); 7097 7098 verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 7099 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 7100 " .a();"); 7101 7102 FormatStyle NoBinPacking = getLLVMStyle(); 7103 NoBinPacking.BinPackParameters = false; 7104 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n" 7105 " .aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n" 7106 " .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa,\n" 7107 " aaaaaaaaaaaaaaaaaaa,\n" 7108 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 7109 NoBinPacking); 7110 7111 // If there is a subsequent call, change to hanging indentation. 7112 verifyFormat( 7113 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7114 " aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa))\n" 7115 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 7116 verifyFormat( 7117 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7118 " aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa));"); 7119 verifyFormat("aaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7120 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 7121 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 7122 verifyFormat("aaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7123 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 7124 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());"); 7125 } 7126 7127 TEST_F(FormatTest, WrapsTemplateDeclarations) { 7128 verifyFormat("template <typename T>\n" 7129 "virtual void loooooooooooongFunction(int Param1, int Param2);"); 7130 verifyFormat("template <typename T>\n" 7131 "// T should be one of {A, B}.\n" 7132 "virtual void loooooooooooongFunction(int Param1, int Param2);"); 7133 verifyFormat( 7134 "template <typename T>\n" 7135 "using comment_to_xml_conversion = comment_to_xml_conversion<T, int>;"); 7136 verifyFormat("template <typename T>\n" 7137 "void f(int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram1,\n" 7138 " int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram2);"); 7139 verifyFormat( 7140 "template <typename T>\n" 7141 "void looooooooooooooooooooongFunction(int Paaaaaaaaaaaaaaaaaaaaram1,\n" 7142 " int Paaaaaaaaaaaaaaaaaaaaram2);"); 7143 verifyFormat( 7144 "template <typename T>\n" 7145 "aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaa,\n" 7146 " aaaaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaa,\n" 7147 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 7148 verifyFormat("template <typename T>\n" 7149 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7150 " int aaaaaaaaaaaaaaaaaaaaaa);"); 7151 verifyFormat( 7152 "template <typename T1, typename T2 = char, typename T3 = char,\n" 7153 " typename T4 = char>\n" 7154 "void f();"); 7155 verifyFormat("template <typename aaaaaaaaaaa, typename bbbbbbbbbbbbb,\n" 7156 " template <typename> class cccccccccccccccccccccc,\n" 7157 " typename ddddddddddddd>\n" 7158 "class C {};"); 7159 verifyFormat( 7160 "aaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>(\n" 7161 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 7162 7163 verifyFormat("void f() {\n" 7164 " a<aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaa>(\n" 7165 " a(aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));\n" 7166 "}"); 7167 7168 verifyFormat("template <typename T> class C {};"); 7169 verifyFormat("template <typename T> void f();"); 7170 verifyFormat("template <typename T> void f() {}"); 7171 verifyFormat( 7172 "aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n" 7173 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 7174 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> *aaaa =\n" 7175 " new aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n" 7176 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 7177 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>(\n" 7178 " bbbbbbbbbbbbbbbbbbbbbbbb);", 7179 getLLVMStyleWithColumns(72)); 7180 EXPECT_EQ("static_cast<A< //\n" 7181 " B> *>(\n" 7182 "\n" 7183 ");", 7184 format("static_cast<A<//\n" 7185 " B>*>(\n" 7186 "\n" 7187 " );")); 7188 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7189 " const typename aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaa);"); 7190 7191 FormatStyle AlwaysBreak = getLLVMStyle(); 7192 AlwaysBreak.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes; 7193 verifyFormat("template <typename T>\nclass C {};", AlwaysBreak); 7194 verifyFormat("template <typename T>\nvoid f();", AlwaysBreak); 7195 verifyFormat("template <typename T>\nvoid f() {}", AlwaysBreak); 7196 verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 7197 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n" 7198 " ccccccccccccccccccccccccccccccccccccccccccccccc);"); 7199 verifyFormat("template <template <typename> class Fooooooo,\n" 7200 " template <typename> class Baaaaaaar>\n" 7201 "struct C {};", 7202 AlwaysBreak); 7203 verifyFormat("template <typename T> // T can be A, B or C.\n" 7204 "struct C {};", 7205 AlwaysBreak); 7206 verifyFormat("template <enum E> class A {\n" 7207 "public:\n" 7208 " E *f();\n" 7209 "};"); 7210 7211 FormatStyle NeverBreak = getLLVMStyle(); 7212 NeverBreak.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_No; 7213 verifyFormat("template <typename T> class C {};", NeverBreak); 7214 verifyFormat("template <typename T> void f();", NeverBreak); 7215 verifyFormat("template <typename T> void f() {}", NeverBreak); 7216 verifyFormat("template <typename T>\nvoid foo(aaaaaaaaaaaaaaaaaaaaaaaaaa " 7217 "bbbbbbbbbbbbbbbbbbbb) {}", 7218 NeverBreak); 7219 verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 7220 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n" 7221 " ccccccccccccccccccccccccccccccccccccccccccccccc);", 7222 NeverBreak); 7223 verifyFormat("template <template <typename> class Fooooooo,\n" 7224 " template <typename> class Baaaaaaar>\n" 7225 "struct C {};", 7226 NeverBreak); 7227 verifyFormat("template <typename T> // T can be A, B or C.\n" 7228 "struct C {};", 7229 NeverBreak); 7230 verifyFormat("template <enum E> class A {\n" 7231 "public:\n" 7232 " E *f();\n" 7233 "};", 7234 NeverBreak); 7235 NeverBreak.PenaltyBreakTemplateDeclaration = 100; 7236 verifyFormat("template <typename T> void\nfoo(aaaaaaaaaaaaaaaaaaaaaaaaaa " 7237 "bbbbbbbbbbbbbbbbbbbb) {}", 7238 NeverBreak); 7239 } 7240 7241 TEST_F(FormatTest, WrapsTemplateDeclarationsWithComments) { 7242 FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp); 7243 Style.ColumnLimit = 60; 7244 EXPECT_EQ("// Baseline - no comments.\n" 7245 "template <\n" 7246 " typename aaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbbb>::value>\n" 7247 "void f() {}", 7248 format("// Baseline - no comments.\n" 7249 "template <\n" 7250 " typename aaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbbb>::value>\n" 7251 "void f() {}", 7252 Style)); 7253 7254 EXPECT_EQ("template <\n" 7255 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 7256 "void f() {}", 7257 format("template <\n" 7258 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 7259 "void f() {}", 7260 Style)); 7261 7262 EXPECT_EQ( 7263 "template <\n" 7264 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> /* line */\n" 7265 "void f() {}", 7266 format("template <typename aaaaaaaaaa<bbbbbbbbbbbb>::value> /* line */\n" 7267 "void f() {}", 7268 Style)); 7269 7270 EXPECT_EQ( 7271 "template <\n" 7272 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 7273 " // multiline\n" 7274 "void f() {}", 7275 format("template <\n" 7276 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 7277 " // multiline\n" 7278 "void f() {}", 7279 Style)); 7280 7281 EXPECT_EQ( 7282 "template <typename aaaaaaaaaa<\n" 7283 " bbbbbbbbbbbb>::value> // trailing loooong\n" 7284 "void f() {}", 7285 format( 7286 "template <\n" 7287 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing loooong\n" 7288 "void f() {}", 7289 Style)); 7290 } 7291 7292 TEST_F(FormatTest, WrapsTemplateParameters) { 7293 FormatStyle Style = getLLVMStyle(); 7294 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 7295 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 7296 verifyFormat( 7297 "template <typename... a> struct q {};\n" 7298 "extern q<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n" 7299 " aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n" 7300 " y;", 7301 Style); 7302 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 7303 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 7304 verifyFormat( 7305 "template <typename... a> struct r {};\n" 7306 "extern r<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n" 7307 " aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n" 7308 " y;", 7309 Style); 7310 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 7311 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 7312 verifyFormat("template <typename... a> struct s {};\n" 7313 "extern s<\n" 7314 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, " 7315 "aaaaaaaaaaaaaaaaaaaaaa,\n" 7316 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, " 7317 "aaaaaaaaaaaaaaaaaaaaaa>\n" 7318 " y;", 7319 Style); 7320 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 7321 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 7322 verifyFormat("template <typename... a> struct t {};\n" 7323 "extern t<\n" 7324 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, " 7325 "aaaaaaaaaaaaaaaaaaaaaa,\n" 7326 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, " 7327 "aaaaaaaaaaaaaaaaaaaaaa>\n" 7328 " y;", 7329 Style); 7330 } 7331 7332 TEST_F(FormatTest, WrapsAtNestedNameSpecifiers) { 7333 verifyFormat( 7334 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 7335 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 7336 verifyFormat( 7337 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 7338 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7339 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());"); 7340 7341 // FIXME: Should we have the extra indent after the second break? 7342 verifyFormat( 7343 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 7344 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 7345 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 7346 7347 verifyFormat( 7348 "aaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb::\n" 7349 " cccccccccccccccccccccccccccccccccccccccccccccc());"); 7350 7351 // Breaking at nested name specifiers is generally not desirable. 7352 verifyFormat( 7353 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7354 " aaaaaaaaaaaaaaaaaaaaaaa);"); 7355 7356 verifyFormat("aaaaaaaaaaaaaaaaaa(aaaaaaaa,\n" 7357 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 7358 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 7359 " aaaaaaaaaaaaaaaaaaaaa);", 7360 getLLVMStyleWithColumns(74)); 7361 7362 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 7363 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7364 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 7365 } 7366 7367 TEST_F(FormatTest, UnderstandsTemplateParameters) { 7368 verifyFormat("A<int> a;"); 7369 verifyFormat("A<A<A<int>>> a;"); 7370 verifyFormat("A<A<A<int, 2>, 3>, 4> a;"); 7371 verifyFormat("bool x = a < 1 || 2 > a;"); 7372 verifyFormat("bool x = 5 < f<int>();"); 7373 verifyFormat("bool x = f<int>() > 5;"); 7374 verifyFormat("bool x = 5 < a<int>::x;"); 7375 verifyFormat("bool x = a < 4 ? a > 2 : false;"); 7376 verifyFormat("bool x = f() ? a < 2 : a > 2;"); 7377 7378 verifyGoogleFormat("A<A<int>> a;"); 7379 verifyGoogleFormat("A<A<A<int>>> a;"); 7380 verifyGoogleFormat("A<A<A<A<int>>>> a;"); 7381 verifyGoogleFormat("A<A<int> > a;"); 7382 verifyGoogleFormat("A<A<A<int> > > a;"); 7383 verifyGoogleFormat("A<A<A<A<int> > > > a;"); 7384 verifyGoogleFormat("A<::A<int>> a;"); 7385 verifyGoogleFormat("A<::A> a;"); 7386 verifyGoogleFormat("A< ::A> a;"); 7387 verifyGoogleFormat("A< ::A<int> > a;"); 7388 EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A> >> a;", getGoogleStyle())); 7389 EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A>> > a;", getGoogleStyle())); 7390 EXPECT_EQ("A<::A<int>> a;", format("A< ::A<int>> a;", getGoogleStyle())); 7391 EXPECT_EQ("A<::A<int>> a;", format("A<::A<int> > a;", getGoogleStyle())); 7392 EXPECT_EQ("auto x = [] { A<A<A<A>>> a; };", 7393 format("auto x=[]{A<A<A<A> >> a;};", getGoogleStyle())); 7394 7395 verifyFormat("A<A<int>> a;", getChromiumStyle(FormatStyle::LK_Cpp)); 7396 7397 // template closer followed by a token that starts with > or = 7398 verifyFormat("bool b = a<1> > 1;"); 7399 verifyFormat("bool b = a<1> >= 1;"); 7400 verifyFormat("int i = a<1> >> 1;"); 7401 FormatStyle Style = getLLVMStyle(); 7402 Style.SpaceBeforeAssignmentOperators = false; 7403 verifyFormat("bool b= a<1> == 1;", Style); 7404 verifyFormat("a<int> = 1;", Style); 7405 verifyFormat("a<int> >>= 1;", Style); 7406 7407 verifyFormat("test >> a >> b;"); 7408 verifyFormat("test << a >> b;"); 7409 7410 verifyFormat("f<int>();"); 7411 verifyFormat("template <typename T> void f() {}"); 7412 verifyFormat("struct A<std::enable_if<sizeof(T2) < sizeof(int32)>::type>;"); 7413 verifyFormat("struct A<std::enable_if<sizeof(T2) ? sizeof(int32) : " 7414 "sizeof(char)>::type>;"); 7415 verifyFormat("template <class T> struct S<std::is_arithmetic<T>{}> {};"); 7416 verifyFormat("f(a.operator()<A>());"); 7417 verifyFormat("f(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7418 " .template operator()<A>());", 7419 getLLVMStyleWithColumns(35)); 7420 7421 // Not template parameters. 7422 verifyFormat("return a < b && c > d;"); 7423 verifyFormat("void f() {\n" 7424 " while (a < b && c > d) {\n" 7425 " }\n" 7426 "}"); 7427 verifyFormat("template <typename... Types>\n" 7428 "typename enable_if<0 < sizeof...(Types)>::type Foo() {}"); 7429 7430 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7431 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa >> aaaaa);", 7432 getLLVMStyleWithColumns(60)); 7433 verifyFormat("static_assert(is_convertible<A &&, B>::value, \"AAA\");"); 7434 verifyFormat("Constructor(A... a) : a_(X<A>{std::forward<A>(a)}...) {}"); 7435 verifyFormat("< < < < < < < < < < < < < < < < < < < < < < < < < < < < < <"); 7436 } 7437 7438 TEST_F(FormatTest, BitshiftOperatorWidth) { 7439 EXPECT_EQ("int a = 1 << 2; /* foo\n" 7440 " bar */", 7441 format("int a=1<<2; /* foo\n" 7442 " bar */")); 7443 7444 EXPECT_EQ("int b = 256 >> 1; /* foo\n" 7445 " bar */", 7446 format("int b =256>>1 ; /* foo\n" 7447 " bar */")); 7448 } 7449 7450 TEST_F(FormatTest, UnderstandsBinaryOperators) { 7451 verifyFormat("COMPARE(a, ==, b);"); 7452 verifyFormat("auto s = sizeof...(Ts) - 1;"); 7453 } 7454 7455 TEST_F(FormatTest, UnderstandsPointersToMembers) { 7456 verifyFormat("int A::*x;"); 7457 verifyFormat("int (S::*func)(void *);"); 7458 verifyFormat("void f() { int (S::*func)(void *); }"); 7459 verifyFormat("typedef bool *(Class::*Member)() const;"); 7460 verifyFormat("void f() {\n" 7461 " (a->*f)();\n" 7462 " a->*x;\n" 7463 " (a.*f)();\n" 7464 " ((*a).*f)();\n" 7465 " a.*x;\n" 7466 "}"); 7467 verifyFormat("void f() {\n" 7468 " (a->*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n" 7469 " aaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);\n" 7470 "}"); 7471 verifyFormat( 7472 "(aaaaaaaaaa->*bbbbbbb)(\n" 7473 " aaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 7474 FormatStyle Style = getLLVMStyle(); 7475 Style.PointerAlignment = FormatStyle::PAS_Left; 7476 verifyFormat("typedef bool* (Class::*Member)() const;", Style); 7477 } 7478 7479 TEST_F(FormatTest, UnderstandsUnaryOperators) { 7480 verifyFormat("int a = -2;"); 7481 verifyFormat("f(-1, -2, -3);"); 7482 verifyFormat("a[-1] = 5;"); 7483 verifyFormat("int a = 5 + -2;"); 7484 verifyFormat("if (i == -1) {\n}"); 7485 verifyFormat("if (i != -1) {\n}"); 7486 verifyFormat("if (i > -1) {\n}"); 7487 verifyFormat("if (i < -1) {\n}"); 7488 verifyFormat("++(a->f());"); 7489 verifyFormat("--(a->f());"); 7490 verifyFormat("(a->f())++;"); 7491 verifyFormat("a[42]++;"); 7492 verifyFormat("if (!(a->f())) {\n}"); 7493 verifyFormat("if (!+i) {\n}"); 7494 verifyFormat("~&a;"); 7495 7496 verifyFormat("a-- > b;"); 7497 verifyFormat("b ? -a : c;"); 7498 verifyFormat("n * sizeof char16;"); 7499 verifyFormat("n * alignof char16;", getGoogleStyle()); 7500 verifyFormat("sizeof(char);"); 7501 verifyFormat("alignof(char);", getGoogleStyle()); 7502 7503 verifyFormat("return -1;"); 7504 verifyFormat("throw -1;"); 7505 verifyFormat("switch (a) {\n" 7506 "case -1:\n" 7507 " break;\n" 7508 "}"); 7509 verifyFormat("#define X -1"); 7510 verifyFormat("#define X -kConstant"); 7511 7512 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {-5, +3};"); 7513 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {+5, -3};"); 7514 7515 verifyFormat("int a = /* confusing comment */ -1;"); 7516 // FIXME: The space after 'i' is wrong, but hopefully, this is a rare case. 7517 verifyFormat("int a = i /* confusing comment */++;"); 7518 7519 verifyFormat("co_yield -1;"); 7520 verifyFormat("co_return -1;"); 7521 } 7522 7523 TEST_F(FormatTest, DoesNotIndentRelativeToUnaryOperators) { 7524 verifyFormat("if (!aaaaaaaaaa( // break\n" 7525 " aaaaa)) {\n" 7526 "}"); 7527 verifyFormat("aaaaaaaaaa(!aaaaaaaaaa( // break\n" 7528 " aaaaa));"); 7529 verifyFormat("*aaa = aaaaaaa( // break\n" 7530 " bbbbbb);"); 7531 } 7532 7533 TEST_F(FormatTest, UnderstandsOverloadedOperators) { 7534 verifyFormat("bool operator<();"); 7535 verifyFormat("bool operator>();"); 7536 verifyFormat("bool operator=();"); 7537 verifyFormat("bool operator==();"); 7538 verifyFormat("bool operator!=();"); 7539 verifyFormat("int operator+();"); 7540 verifyFormat("int operator++();"); 7541 verifyFormat("int operator++(int) volatile noexcept;"); 7542 verifyFormat("bool operator,();"); 7543 verifyFormat("bool operator();"); 7544 verifyFormat("bool operator()();"); 7545 verifyFormat("bool operator[]();"); 7546 verifyFormat("operator bool();"); 7547 verifyFormat("operator int();"); 7548 verifyFormat("operator void *();"); 7549 verifyFormat("operator SomeType<int>();"); 7550 verifyFormat("operator SomeType<int, int>();"); 7551 verifyFormat("operator SomeType<SomeType<int>>();"); 7552 verifyFormat("void *operator new(std::size_t size);"); 7553 verifyFormat("void *operator new[](std::size_t size);"); 7554 verifyFormat("void operator delete(void *ptr);"); 7555 verifyFormat("void operator delete[](void *ptr);"); 7556 verifyFormat("template <typename AAAAAAA, typename BBBBBBB>\n" 7557 "AAAAAAA operator/(const AAAAAAA &a, BBBBBBB &b);"); 7558 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa operator,(\n" 7559 " aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaaaaaaaaaaaaaaaaaaa) const;"); 7560 7561 verifyFormat( 7562 "ostream &operator<<(ostream &OutputStream,\n" 7563 " SomeReallyLongType WithSomeReallyLongValue);"); 7564 verifyFormat("bool operator<(const aaaaaaaaaaaaaaaaaaaaa &left,\n" 7565 " const aaaaaaaaaaaaaaaaaaaaa &right) {\n" 7566 " return left.group < right.group;\n" 7567 "}"); 7568 verifyFormat("SomeType &operator=(const SomeType &S);"); 7569 verifyFormat("f.template operator()<int>();"); 7570 7571 verifyGoogleFormat("operator void*();"); 7572 verifyGoogleFormat("operator SomeType<SomeType<int>>();"); 7573 verifyGoogleFormat("operator ::A();"); 7574 7575 verifyFormat("using A::operator+;"); 7576 verifyFormat("inline A operator^(const A &lhs, const A &rhs) {}\n" 7577 "int i;"); 7578 } 7579 7580 TEST_F(FormatTest, UnderstandsFunctionRefQualification) { 7581 verifyFormat("Deleted &operator=(const Deleted &) & = default;"); 7582 verifyFormat("Deleted &operator=(const Deleted &) && = delete;"); 7583 verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;"); 7584 verifyFormat("SomeType MemberFunction(const Deleted &) && = delete;"); 7585 verifyFormat("Deleted &operator=(const Deleted &) &;"); 7586 verifyFormat("Deleted &operator=(const Deleted &) &&;"); 7587 verifyFormat("SomeType MemberFunction(const Deleted &) &;"); 7588 verifyFormat("SomeType MemberFunction(const Deleted &) &&;"); 7589 verifyFormat("SomeType MemberFunction(const Deleted &) && {}"); 7590 verifyFormat("SomeType MemberFunction(const Deleted &) && final {}"); 7591 verifyFormat("SomeType MemberFunction(const Deleted &) && override {}"); 7592 verifyFormat("void Fn(T const &) const &;"); 7593 verifyFormat("void Fn(T const volatile &&) const volatile &&;"); 7594 verifyFormat("template <typename T>\n" 7595 "void F(T) && = delete;", 7596 getGoogleStyle()); 7597 7598 FormatStyle AlignLeft = getLLVMStyle(); 7599 AlignLeft.PointerAlignment = FormatStyle::PAS_Left; 7600 verifyFormat("void A::b() && {}", AlignLeft); 7601 verifyFormat("Deleted& operator=(const Deleted&) & = default;", AlignLeft); 7602 verifyFormat("SomeType MemberFunction(const Deleted&) & = delete;", 7603 AlignLeft); 7604 verifyFormat("Deleted& operator=(const Deleted&) &;", AlignLeft); 7605 verifyFormat("SomeType MemberFunction(const Deleted&) &;", AlignLeft); 7606 verifyFormat("auto Function(T t) & -> void {}", AlignLeft); 7607 verifyFormat("auto Function(T... t) & -> void {}", AlignLeft); 7608 verifyFormat("auto Function(T) & -> void {}", AlignLeft); 7609 verifyFormat("auto Function(T) & -> void;", AlignLeft); 7610 verifyFormat("void Fn(T const&) const&;", AlignLeft); 7611 verifyFormat("void Fn(T const volatile&&) const volatile&&;", AlignLeft); 7612 7613 FormatStyle Spaces = getLLVMStyle(); 7614 Spaces.SpacesInCStyleCastParentheses = true; 7615 verifyFormat("Deleted &operator=(const Deleted &) & = default;", Spaces); 7616 verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;", Spaces); 7617 verifyFormat("Deleted &operator=(const Deleted &) &;", Spaces); 7618 verifyFormat("SomeType MemberFunction(const Deleted &) &;", Spaces); 7619 7620 Spaces.SpacesInCStyleCastParentheses = false; 7621 Spaces.SpacesInParentheses = true; 7622 verifyFormat("Deleted &operator=( const Deleted & ) & = default;", Spaces); 7623 verifyFormat("SomeType MemberFunction( const Deleted & ) & = delete;", 7624 Spaces); 7625 verifyFormat("Deleted &operator=( const Deleted & ) &;", Spaces); 7626 verifyFormat("SomeType MemberFunction( const Deleted & ) &;", Spaces); 7627 7628 FormatStyle BreakTemplate = getLLVMStyle(); 7629 BreakTemplate.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes; 7630 7631 verifyFormat("struct f {\n" 7632 " template <class T>\n" 7633 " int &foo(const std::string &str) &noexcept {}\n" 7634 "};", 7635 BreakTemplate); 7636 7637 verifyFormat("struct f {\n" 7638 " template <class T>\n" 7639 " int &foo(const std::string &str) &&noexcept {}\n" 7640 "};", 7641 BreakTemplate); 7642 7643 verifyFormat("struct f {\n" 7644 " template <class T>\n" 7645 " int &foo(const std::string &str) const &noexcept {}\n" 7646 "};", 7647 BreakTemplate); 7648 7649 verifyFormat("struct f {\n" 7650 " template <class T>\n" 7651 " int &foo(const std::string &str) const &noexcept {}\n" 7652 "};", 7653 BreakTemplate); 7654 7655 verifyFormat("struct f {\n" 7656 " template <class T>\n" 7657 " auto foo(const std::string &str) &&noexcept -> int & {}\n" 7658 "};", 7659 BreakTemplate); 7660 7661 FormatStyle AlignLeftBreakTemplate = getLLVMStyle(); 7662 AlignLeftBreakTemplate.AlwaysBreakTemplateDeclarations = 7663 FormatStyle::BTDS_Yes; 7664 AlignLeftBreakTemplate.PointerAlignment = FormatStyle::PAS_Left; 7665 7666 verifyFormat("struct f {\n" 7667 " template <class T>\n" 7668 " int& foo(const std::string& str) & noexcept {}\n" 7669 "};", 7670 AlignLeftBreakTemplate); 7671 7672 verifyFormat("struct f {\n" 7673 " template <class T>\n" 7674 " int& foo(const std::string& str) && noexcept {}\n" 7675 "};", 7676 AlignLeftBreakTemplate); 7677 7678 verifyFormat("struct f {\n" 7679 " template <class T>\n" 7680 " int& foo(const std::string& str) const& noexcept {}\n" 7681 "};", 7682 AlignLeftBreakTemplate); 7683 7684 verifyFormat("struct f {\n" 7685 " template <class T>\n" 7686 " int& foo(const std::string& str) const&& noexcept {}\n" 7687 "};", 7688 AlignLeftBreakTemplate); 7689 7690 verifyFormat("struct f {\n" 7691 " template <class T>\n" 7692 " auto foo(const std::string& str) && noexcept -> int& {}\n" 7693 "};", 7694 AlignLeftBreakTemplate); 7695 7696 // The `&` in `Type&` should not be confused with a trailing `&` of 7697 // DEPRECATED(reason) member function. 7698 verifyFormat("struct f {\n" 7699 " template <class T>\n" 7700 " DEPRECATED(reason)\n" 7701 " Type &foo(arguments) {}\n" 7702 "};", 7703 BreakTemplate); 7704 7705 verifyFormat("struct f {\n" 7706 " template <class T>\n" 7707 " DEPRECATED(reason)\n" 7708 " Type& foo(arguments) {}\n" 7709 "};", 7710 AlignLeftBreakTemplate); 7711 7712 verifyFormat("void (*foopt)(int) = &func;"); 7713 } 7714 7715 TEST_F(FormatTest, UnderstandsNewAndDelete) { 7716 verifyFormat("void f() {\n" 7717 " A *a = new A;\n" 7718 " A *a = new (placement) A;\n" 7719 " delete a;\n" 7720 " delete (A *)a;\n" 7721 "}"); 7722 verifyFormat("new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n" 7723 " typename aaaaaaaaaaaaaaaaaaaaaaaa();"); 7724 verifyFormat("auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 7725 " new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n" 7726 " typename aaaaaaaaaaaaaaaaaaaaaaaa();"); 7727 verifyFormat("delete[] h->p;"); 7728 } 7729 7730 TEST_F(FormatTest, UnderstandsUsesOfStarAndAmp) { 7731 verifyFormat("int *f(int *a) {}"); 7732 verifyFormat("int main(int argc, char **argv) {}"); 7733 verifyFormat("Test::Test(int b) : a(b * b) {}"); 7734 verifyIndependentOfContext("f(a, *a);"); 7735 verifyFormat("void g() { f(*a); }"); 7736 verifyIndependentOfContext("int a = b * 10;"); 7737 verifyIndependentOfContext("int a = 10 * b;"); 7738 verifyIndependentOfContext("int a = b * c;"); 7739 verifyIndependentOfContext("int a += b * c;"); 7740 verifyIndependentOfContext("int a -= b * c;"); 7741 verifyIndependentOfContext("int a *= b * c;"); 7742 verifyIndependentOfContext("int a /= b * c;"); 7743 verifyIndependentOfContext("int a = *b;"); 7744 verifyIndependentOfContext("int a = *b * c;"); 7745 verifyIndependentOfContext("int a = b * *c;"); 7746 verifyIndependentOfContext("int a = b * (10);"); 7747 verifyIndependentOfContext("S << b * (10);"); 7748 verifyIndependentOfContext("return 10 * b;"); 7749 verifyIndependentOfContext("return *b * *c;"); 7750 verifyIndependentOfContext("return a & ~b;"); 7751 verifyIndependentOfContext("f(b ? *c : *d);"); 7752 verifyIndependentOfContext("int a = b ? *c : *d;"); 7753 verifyIndependentOfContext("*b = a;"); 7754 verifyIndependentOfContext("a * ~b;"); 7755 verifyIndependentOfContext("a * !b;"); 7756 verifyIndependentOfContext("a * +b;"); 7757 verifyIndependentOfContext("a * -b;"); 7758 verifyIndependentOfContext("a * ++b;"); 7759 verifyIndependentOfContext("a * --b;"); 7760 verifyIndependentOfContext("a[4] * b;"); 7761 verifyIndependentOfContext("a[a * a] = 1;"); 7762 verifyIndependentOfContext("f() * b;"); 7763 verifyIndependentOfContext("a * [self dostuff];"); 7764 verifyIndependentOfContext("int x = a * (a + b);"); 7765 verifyIndependentOfContext("(a *)(a + b);"); 7766 verifyIndependentOfContext("*(int *)(p & ~3UL) = 0;"); 7767 verifyIndependentOfContext("int *pa = (int *)&a;"); 7768 verifyIndependentOfContext("return sizeof(int **);"); 7769 verifyIndependentOfContext("return sizeof(int ******);"); 7770 verifyIndependentOfContext("return (int **&)a;"); 7771 verifyIndependentOfContext("f((*PointerToArray)[10]);"); 7772 verifyFormat("void f(Type (*parameter)[10]) {}"); 7773 verifyFormat("void f(Type (¶meter)[10]) {}"); 7774 verifyGoogleFormat("return sizeof(int**);"); 7775 verifyIndependentOfContext("Type **A = static_cast<Type **>(P);"); 7776 verifyGoogleFormat("Type** A = static_cast<Type**>(P);"); 7777 verifyFormat("auto a = [](int **&, int ***) {};"); 7778 verifyFormat("auto PointerBinding = [](const char *S) {};"); 7779 verifyFormat("typedef typeof(int(int, int)) *MyFunc;"); 7780 verifyFormat("[](const decltype(*a) &value) {}"); 7781 verifyFormat("decltype(a * b) F();"); 7782 verifyFormat("#define MACRO() [](A *a) { return 1; }"); 7783 verifyFormat("Constructor() : member([](A *a, B *b) {}) {}"); 7784 verifyIndependentOfContext("typedef void (*f)(int *a);"); 7785 verifyIndependentOfContext("int i{a * b};"); 7786 verifyIndependentOfContext("aaa && aaa->f();"); 7787 verifyIndependentOfContext("int x = ~*p;"); 7788 verifyFormat("Constructor() : a(a), area(width * height) {}"); 7789 verifyFormat("Constructor() : a(a), area(a, width * height) {}"); 7790 verifyGoogleFormat("MACRO Constructor(const int& i) : a(a), b(b) {}"); 7791 verifyFormat("void f() { f(a, c * d); }"); 7792 verifyFormat("void f() { f(new a(), c * d); }"); 7793 verifyFormat("void f(const MyOverride &override);"); 7794 verifyFormat("void f(const MyFinal &final);"); 7795 verifyIndependentOfContext("bool a = f() && override.f();"); 7796 verifyIndependentOfContext("bool a = f() && final.f();"); 7797 7798 verifyIndependentOfContext("InvalidRegions[*R] = 0;"); 7799 7800 verifyIndependentOfContext("A<int *> a;"); 7801 verifyIndependentOfContext("A<int **> a;"); 7802 verifyIndependentOfContext("A<int *, int *> a;"); 7803 verifyIndependentOfContext("A<int *[]> a;"); 7804 verifyIndependentOfContext( 7805 "const char *const p = reinterpret_cast<const char *const>(q);"); 7806 verifyIndependentOfContext("A<int **, int **> a;"); 7807 verifyIndependentOfContext("void f(int *a = d * e, int *b = c * d);"); 7808 verifyFormat("for (char **a = b; *a; ++a) {\n}"); 7809 verifyFormat("for (; a && b;) {\n}"); 7810 verifyFormat("bool foo = true && [] { return false; }();"); 7811 7812 verifyFormat( 7813 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7814 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa, *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 7815 7816 verifyGoogleFormat("int const* a = &b;"); 7817 verifyGoogleFormat("**outparam = 1;"); 7818 verifyGoogleFormat("*outparam = a * b;"); 7819 verifyGoogleFormat("int main(int argc, char** argv) {}"); 7820 verifyGoogleFormat("A<int*> a;"); 7821 verifyGoogleFormat("A<int**> a;"); 7822 verifyGoogleFormat("A<int*, int*> a;"); 7823 verifyGoogleFormat("A<int**, int**> a;"); 7824 verifyGoogleFormat("f(b ? *c : *d);"); 7825 verifyGoogleFormat("int a = b ? *c : *d;"); 7826 verifyGoogleFormat("Type* t = **x;"); 7827 verifyGoogleFormat("Type* t = *++*x;"); 7828 verifyGoogleFormat("*++*x;"); 7829 verifyGoogleFormat("Type* t = const_cast<T*>(&*x);"); 7830 verifyGoogleFormat("Type* t = x++ * y;"); 7831 verifyGoogleFormat( 7832 "const char* const p = reinterpret_cast<const char* const>(q);"); 7833 verifyGoogleFormat("void f(int i = 0, SomeType** temps = NULL);"); 7834 verifyGoogleFormat("void f(Bar* a = nullptr, Bar* b);"); 7835 verifyGoogleFormat("template <typename T>\n" 7836 "void f(int i = 0, SomeType** temps = NULL);"); 7837 7838 FormatStyle Left = getLLVMStyle(); 7839 Left.PointerAlignment = FormatStyle::PAS_Left; 7840 verifyFormat("x = *a(x) = *a(y);", Left); 7841 verifyFormat("for (;; *a = b) {\n}", Left); 7842 verifyFormat("return *this += 1;", Left); 7843 verifyFormat("throw *x;", Left); 7844 verifyFormat("delete *x;", Left); 7845 verifyFormat("typedef typeof(int(int, int))* MyFuncPtr;", Left); 7846 verifyFormat("[](const decltype(*a)* ptr) {}", Left); 7847 verifyFormat("typedef typeof /*comment*/ (int(int, int))* MyFuncPtr;", Left); 7848 verifyFormat("auto x(A&&, B&&, C&&) -> D;", Left); 7849 verifyFormat("auto x = [](A&&, B&&, C&&) -> D {};", Left); 7850 verifyFormat("template <class T> X(T&&, T&&, T&&) -> X<T>;", Left); 7851 7852 verifyIndependentOfContext("a = *(x + y);"); 7853 verifyIndependentOfContext("a = &(x + y);"); 7854 verifyIndependentOfContext("*(x + y).call();"); 7855 verifyIndependentOfContext("&(x + y)->call();"); 7856 verifyFormat("void f() { &(*I).first; }"); 7857 7858 verifyIndependentOfContext("f(b * /* confusing comment */ ++c);"); 7859 verifyFormat( 7860 "int *MyValues = {\n" 7861 " *A, // Operator detection might be confused by the '{'\n" 7862 " *BB // Operator detection might be confused by previous comment\n" 7863 "};"); 7864 7865 verifyIndependentOfContext("if (int *a = &b)"); 7866 verifyIndependentOfContext("if (int &a = *b)"); 7867 verifyIndependentOfContext("if (a & b[i])"); 7868 verifyIndependentOfContext("if constexpr (a & b[i])"); 7869 verifyIndependentOfContext("if CONSTEXPR (a & b[i])"); 7870 verifyIndependentOfContext("if (a * (b * c))"); 7871 verifyIndependentOfContext("if constexpr (a * (b * c))"); 7872 verifyIndependentOfContext("if CONSTEXPR (a * (b * c))"); 7873 verifyIndependentOfContext("if (a::b::c::d & b[i])"); 7874 verifyIndependentOfContext("if (*b[i])"); 7875 verifyIndependentOfContext("if (int *a = (&b))"); 7876 verifyIndependentOfContext("while (int *a = &b)"); 7877 verifyIndependentOfContext("while (a * (b * c))"); 7878 verifyIndependentOfContext("size = sizeof *a;"); 7879 verifyIndependentOfContext("if (a && (b = c))"); 7880 verifyFormat("void f() {\n" 7881 " for (const int &v : Values) {\n" 7882 " }\n" 7883 "}"); 7884 verifyFormat("for (int i = a * a; i < 10; ++i) {\n}"); 7885 verifyFormat("for (int i = 0; i < a * a; ++i) {\n}"); 7886 verifyGoogleFormat("for (int i = 0; i * 2 < z; i *= 2) {\n}"); 7887 7888 verifyFormat("#define A (!a * b)"); 7889 verifyFormat("#define MACRO \\\n" 7890 " int *i = a * b; \\\n" 7891 " void f(a *b);", 7892 getLLVMStyleWithColumns(19)); 7893 7894 verifyIndependentOfContext("A = new SomeType *[Length];"); 7895 verifyIndependentOfContext("A = new SomeType *[Length]();"); 7896 verifyIndependentOfContext("T **t = new T *;"); 7897 verifyIndependentOfContext("T **t = new T *();"); 7898 verifyGoogleFormat("A = new SomeType*[Length]();"); 7899 verifyGoogleFormat("A = new SomeType*[Length];"); 7900 verifyGoogleFormat("T** t = new T*;"); 7901 verifyGoogleFormat("T** t = new T*();"); 7902 7903 verifyFormat("STATIC_ASSERT((a & b) == 0);"); 7904 verifyFormat("STATIC_ASSERT(0 == (a & b));"); 7905 verifyFormat("template <bool a, bool b> " 7906 "typename t::if<x && y>::type f() {}"); 7907 verifyFormat("template <int *y> f() {}"); 7908 verifyFormat("vector<int *> v;"); 7909 verifyFormat("vector<int *const> v;"); 7910 verifyFormat("vector<int *const **const *> v;"); 7911 verifyFormat("vector<int *volatile> v;"); 7912 verifyFormat("vector<a * b> v;"); 7913 verifyFormat("foo<b && false>();"); 7914 verifyFormat("foo<b & 1>();"); 7915 verifyFormat("decltype(*::std::declval<const T &>()) void F();"); 7916 verifyFormat( 7917 "template <class T, class = typename std::enable_if<\n" 7918 " std::is_integral<T>::value &&\n" 7919 " (sizeof(T) > 1 || sizeof(T) < 8)>::type>\n" 7920 "void F();", 7921 getLLVMStyleWithColumns(70)); 7922 verifyFormat("template <class T,\n" 7923 " class = typename std::enable_if<\n" 7924 " std::is_integral<T>::value &&\n" 7925 " (sizeof(T) > 1 || sizeof(T) < 8)>::type,\n" 7926 " class U>\n" 7927 "void F();", 7928 getLLVMStyleWithColumns(70)); 7929 verifyFormat( 7930 "template <class T,\n" 7931 " class = typename ::std::enable_if<\n" 7932 " ::std::is_array<T>{} && ::std::is_array<T>{}>::type>\n" 7933 "void F();", 7934 getGoogleStyleWithColumns(68)); 7935 7936 verifyIndependentOfContext("MACRO(int *i);"); 7937 verifyIndependentOfContext("MACRO(auto *a);"); 7938 verifyIndependentOfContext("MACRO(const A *a);"); 7939 verifyIndependentOfContext("MACRO(A *const a);"); 7940 verifyIndependentOfContext("MACRO('0' <= c && c <= '9');"); 7941 verifyFormat("void f() { f(float{1}, a * a); }"); 7942 // FIXME: Is there a way to make this work? 7943 // verifyIndependentOfContext("MACRO(A *a);"); 7944 7945 verifyFormat("DatumHandle const *operator->() const { return input_; }"); 7946 verifyFormat("return options != nullptr && operator==(*options);"); 7947 7948 EXPECT_EQ("#define OP(x) \\\n" 7949 " ostream &operator<<(ostream &s, const A &a) { \\\n" 7950 " return s << a.DebugString(); \\\n" 7951 " }", 7952 format("#define OP(x) \\\n" 7953 " ostream &operator<<(ostream &s, const A &a) { \\\n" 7954 " return s << a.DebugString(); \\\n" 7955 " }", 7956 getLLVMStyleWithColumns(50))); 7957 7958 // FIXME: We cannot handle this case yet; we might be able to figure out that 7959 // foo<x> d > v; doesn't make sense. 7960 verifyFormat("foo<a<b && c> d> v;"); 7961 7962 FormatStyle PointerMiddle = getLLVMStyle(); 7963 PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle; 7964 verifyFormat("delete *x;", PointerMiddle); 7965 verifyFormat("int * x;", PointerMiddle); 7966 verifyFormat("int *[] x;", PointerMiddle); 7967 verifyFormat("template <int * y> f() {}", PointerMiddle); 7968 verifyFormat("int * f(int * a) {}", PointerMiddle); 7969 verifyFormat("int main(int argc, char ** argv) {}", PointerMiddle); 7970 verifyFormat("Test::Test(int b) : a(b * b) {}", PointerMiddle); 7971 verifyFormat("A<int *> a;", PointerMiddle); 7972 verifyFormat("A<int **> a;", PointerMiddle); 7973 verifyFormat("A<int *, int *> a;", PointerMiddle); 7974 verifyFormat("A<int *[]> a;", PointerMiddle); 7975 verifyFormat("A = new SomeType *[Length]();", PointerMiddle); 7976 verifyFormat("A = new SomeType *[Length];", PointerMiddle); 7977 verifyFormat("T ** t = new T *;", PointerMiddle); 7978 7979 // Member function reference qualifiers aren't binary operators. 7980 verifyFormat("string // break\n" 7981 "operator()() & {}"); 7982 verifyFormat("string // break\n" 7983 "operator()() && {}"); 7984 verifyGoogleFormat("template <typename T>\n" 7985 "auto x() & -> int {}"); 7986 } 7987 7988 TEST_F(FormatTest, UnderstandsAttributes) { 7989 verifyFormat("SomeType s __attribute__((unused)) (InitValue);"); 7990 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa __attribute__((unused))\n" 7991 "aaaaaaaaaaaaaaaaaaaaaaa(int i);"); 7992 FormatStyle AfterType = getLLVMStyle(); 7993 AfterType.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions; 7994 verifyFormat("__attribute__((nodebug)) void\n" 7995 "foo() {}\n", 7996 AfterType); 7997 } 7998 7999 TEST_F(FormatTest, UnderstandsSquareAttributes) { 8000 verifyFormat("SomeType s [[unused]] (InitValue);"); 8001 verifyFormat("SomeType s [[gnu::unused]] (InitValue);"); 8002 verifyFormat("SomeType s [[using gnu: unused]] (InitValue);"); 8003 verifyFormat("[[gsl::suppress(\"clang-tidy-check-name\")]] void f() {}"); 8004 verifyFormat("void f() [[deprecated(\"so sorry\")]];"); 8005 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 8006 " [[unused]] aaaaaaaaaaaaaaaaaaaaaaa(int i);"); 8007 verifyFormat("[[nodiscard]] bool f() { return false; }"); 8008 verifyFormat("class [[nodiscard]] f {\npublic:\n f() {}\n}"); 8009 verifyFormat("class [[deprecated(\"so sorry\")]] f {\npublic:\n f() {}\n}"); 8010 verifyFormat("class [[gnu::unused]] f {\npublic:\n f() {}\n}"); 8011 8012 // Make sure we do not mistake attributes for array subscripts. 8013 verifyFormat("int a() {}\n" 8014 "[[unused]] int b() {}\n"); 8015 verifyFormat("NSArray *arr;\n" 8016 "arr[[Foo() bar]];"); 8017 8018 // On the other hand, we still need to correctly find array subscripts. 8019 verifyFormat("int a = std::vector<int>{1, 2, 3}[0];"); 8020 8021 // Make sure that we do not mistake Objective-C method inside array literals 8022 // as attributes, even if those method names are also keywords. 8023 verifyFormat("@[ [foo bar] ];"); 8024 verifyFormat("@[ [NSArray class] ];"); 8025 verifyFormat("@[ [foo enum] ];"); 8026 8027 verifyFormat("template <typename T> [[nodiscard]] int a() { return 1; }"); 8028 8029 // Make sure we do not parse attributes as lambda introducers. 8030 FormatStyle MultiLineFunctions = getLLVMStyle(); 8031 MultiLineFunctions.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 8032 verifyFormat("[[unused]] int b() {\n" 8033 " return 42;\n" 8034 "}\n", 8035 MultiLineFunctions); 8036 } 8037 8038 TEST_F(FormatTest, AttributeClass) { 8039 FormatStyle Style = getChromiumStyle(FormatStyle::LK_Cpp); 8040 verifyFormat("class S {\n" 8041 " S(S&&) = default;\n" 8042 "};", 8043 Style); 8044 verifyFormat("class [[nodiscard]] S {\n" 8045 " S(S&&) = default;\n" 8046 "};", 8047 Style); 8048 verifyFormat("class __attribute((maybeunused)) S {\n" 8049 " S(S&&) = default;\n" 8050 "};", 8051 Style); 8052 verifyFormat("struct S {\n" 8053 " S(S&&) = default;\n" 8054 "};", 8055 Style); 8056 verifyFormat("struct [[nodiscard]] S {\n" 8057 " S(S&&) = default;\n" 8058 "};", 8059 Style); 8060 } 8061 8062 TEST_F(FormatTest, AttributesAfterMacro) { 8063 FormatStyle Style = getLLVMStyle(); 8064 verifyFormat("MACRO;\n" 8065 "__attribute__((maybe_unused)) int foo() {\n" 8066 " //...\n" 8067 "}"); 8068 8069 verifyFormat("MACRO;\n" 8070 "[[nodiscard]] int foo() {\n" 8071 " //...\n" 8072 "}"); 8073 8074 EXPECT_EQ("MACRO\n\n" 8075 "__attribute__((maybe_unused)) int foo() {\n" 8076 " //...\n" 8077 "}", 8078 format("MACRO\n\n" 8079 "__attribute__((maybe_unused)) int foo() {\n" 8080 " //...\n" 8081 "}")); 8082 8083 EXPECT_EQ("MACRO\n\n" 8084 "[[nodiscard]] int foo() {\n" 8085 " //...\n" 8086 "}", 8087 format("MACRO\n\n" 8088 "[[nodiscard]] int foo() {\n" 8089 " //...\n" 8090 "}")); 8091 } 8092 8093 TEST_F(FormatTest, AttributePenaltyBreaking) { 8094 FormatStyle Style = getLLVMStyle(); 8095 verifyFormat("void ABCDEFGH::ABCDEFGHIJKLMN(\n" 8096 " [[maybe_unused]] const shared_ptr<ALongTypeName> &C d) {}", 8097 Style); 8098 verifyFormat("void ABCDEFGH::ABCDEFGHIJK(\n" 8099 " [[maybe_unused]] const shared_ptr<ALongTypeName> &C d) {}", 8100 Style); 8101 verifyFormat("void ABCDEFGH::ABCDEFGH([[maybe_unused]] const " 8102 "shared_ptr<ALongTypeName> &C d) {\n}", 8103 Style); 8104 } 8105 8106 TEST_F(FormatTest, UnderstandsEllipsis) { 8107 verifyFormat("int printf(const char *fmt, ...);"); 8108 verifyFormat("template <class... Ts> void Foo(Ts... ts) { Foo(ts...); }"); 8109 verifyFormat("template <class... Ts> void Foo(Ts *... ts) {}"); 8110 8111 FormatStyle PointersLeft = getLLVMStyle(); 8112 PointersLeft.PointerAlignment = FormatStyle::PAS_Left; 8113 verifyFormat("template <class... Ts> void Foo(Ts*... ts) {}", PointersLeft); 8114 } 8115 8116 TEST_F(FormatTest, AdaptivelyFormatsPointersAndReferences) { 8117 EXPECT_EQ("int *a;\n" 8118 "int *a;\n" 8119 "int *a;", 8120 format("int *a;\n" 8121 "int* a;\n" 8122 "int *a;", 8123 getGoogleStyle())); 8124 EXPECT_EQ("int* a;\n" 8125 "int* a;\n" 8126 "int* a;", 8127 format("int* a;\n" 8128 "int* a;\n" 8129 "int *a;", 8130 getGoogleStyle())); 8131 EXPECT_EQ("int *a;\n" 8132 "int *a;\n" 8133 "int *a;", 8134 format("int *a;\n" 8135 "int * a;\n" 8136 "int * a;", 8137 getGoogleStyle())); 8138 EXPECT_EQ("auto x = [] {\n" 8139 " int *a;\n" 8140 " int *a;\n" 8141 " int *a;\n" 8142 "};", 8143 format("auto x=[]{int *a;\n" 8144 "int * a;\n" 8145 "int * a;};", 8146 getGoogleStyle())); 8147 } 8148 8149 TEST_F(FormatTest, UnderstandsRvalueReferences) { 8150 verifyFormat("int f(int &&a) {}"); 8151 verifyFormat("int f(int a, char &&b) {}"); 8152 verifyFormat("void f() { int &&a = b; }"); 8153 verifyGoogleFormat("int f(int a, char&& b) {}"); 8154 verifyGoogleFormat("void f() { int&& a = b; }"); 8155 8156 verifyIndependentOfContext("A<int &&> a;"); 8157 verifyIndependentOfContext("A<int &&, int &&> a;"); 8158 verifyGoogleFormat("A<int&&> a;"); 8159 verifyGoogleFormat("A<int&&, int&&> a;"); 8160 8161 // Not rvalue references: 8162 verifyFormat("template <bool B, bool C> class A {\n" 8163 " static_assert(B && C, \"Something is wrong\");\n" 8164 "};"); 8165 verifyGoogleFormat("#define IF(a, b, c) if (a && (b == c))"); 8166 verifyGoogleFormat("#define WHILE(a, b, c) while (a && (b == c))"); 8167 verifyFormat("#define A(a, b) (a && b)"); 8168 } 8169 8170 TEST_F(FormatTest, FormatsBinaryOperatorsPrecedingEquals) { 8171 verifyFormat("void f() {\n" 8172 " x[aaaaaaaaa -\n" 8173 " b] = 23;\n" 8174 "}", 8175 getLLVMStyleWithColumns(15)); 8176 } 8177 8178 TEST_F(FormatTest, FormatsCasts) { 8179 verifyFormat("Type *A = static_cast<Type *>(P);"); 8180 verifyFormat("Type *A = (Type *)P;"); 8181 verifyFormat("Type *A = (vector<Type *, int *>)P;"); 8182 verifyFormat("int a = (int)(2.0f);"); 8183 verifyFormat("int a = (int)2.0f;"); 8184 verifyFormat("x[(int32)y];"); 8185 verifyFormat("x = (int32)y;"); 8186 verifyFormat("#define AA(X) sizeof(((X *)NULL)->a)"); 8187 verifyFormat("int a = (int)*b;"); 8188 verifyFormat("int a = (int)2.0f;"); 8189 verifyFormat("int a = (int)~0;"); 8190 verifyFormat("int a = (int)++a;"); 8191 verifyFormat("int a = (int)sizeof(int);"); 8192 verifyFormat("int a = (int)+2;"); 8193 verifyFormat("my_int a = (my_int)2.0f;"); 8194 verifyFormat("my_int a = (my_int)sizeof(int);"); 8195 verifyFormat("return (my_int)aaa;"); 8196 verifyFormat("#define x ((int)-1)"); 8197 verifyFormat("#define LENGTH(x, y) (x) - (y) + 1"); 8198 verifyFormat("#define p(q) ((int *)&q)"); 8199 verifyFormat("fn(a)(b) + 1;"); 8200 8201 verifyFormat("void f() { my_int a = (my_int)*b; }"); 8202 verifyFormat("void f() { return P ? (my_int)*P : (my_int)0; }"); 8203 verifyFormat("my_int a = (my_int)~0;"); 8204 verifyFormat("my_int a = (my_int)++a;"); 8205 verifyFormat("my_int a = (my_int)-2;"); 8206 verifyFormat("my_int a = (my_int)1;"); 8207 verifyFormat("my_int a = (my_int *)1;"); 8208 verifyFormat("my_int a = (const my_int)-1;"); 8209 verifyFormat("my_int a = (const my_int *)-1;"); 8210 verifyFormat("my_int a = (my_int)(my_int)-1;"); 8211 verifyFormat("my_int a = (ns::my_int)-2;"); 8212 verifyFormat("case (my_int)ONE:"); 8213 verifyFormat("auto x = (X)this;"); 8214 // Casts in Obj-C style calls used to not be recognized as such. 8215 verifyFormat("int a = [(type*)[((type*)val) arg] arg];", getGoogleStyle()); 8216 8217 // FIXME: single value wrapped with paren will be treated as cast. 8218 verifyFormat("void f(int i = (kValue)*kMask) {}"); 8219 8220 verifyFormat("{ (void)F; }"); 8221 8222 // Don't break after a cast's 8223 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 8224 " (aaaaaaaaaaaaaaaaaaaaaaaaaa *)(aaaaaaaaaaaaaaaaaaaaaa +\n" 8225 " bbbbbbbbbbbbbbbbbbbbbb);"); 8226 8227 // These are not casts. 8228 verifyFormat("void f(int *) {}"); 8229 verifyFormat("f(foo)->b;"); 8230 verifyFormat("f(foo).b;"); 8231 verifyFormat("f(foo)(b);"); 8232 verifyFormat("f(foo)[b];"); 8233 verifyFormat("[](foo) { return 4; }(bar);"); 8234 verifyFormat("(*funptr)(foo)[4];"); 8235 verifyFormat("funptrs[4](foo)[4];"); 8236 verifyFormat("void f(int *);"); 8237 verifyFormat("void f(int *) = 0;"); 8238 verifyFormat("void f(SmallVector<int>) {}"); 8239 verifyFormat("void f(SmallVector<int>);"); 8240 verifyFormat("void f(SmallVector<int>) = 0;"); 8241 verifyFormat("void f(int i = (kA * kB) & kMask) {}"); 8242 verifyFormat("int a = sizeof(int) * b;"); 8243 verifyFormat("int a = alignof(int) * b;", getGoogleStyle()); 8244 verifyFormat("template <> void f<int>(int i) SOME_ANNOTATION;"); 8245 verifyFormat("f(\"%\" SOME_MACRO(ll) \"d\");"); 8246 verifyFormat("aaaaa &operator=(const aaaaa &) LLVM_DELETED_FUNCTION;"); 8247 8248 // These are not casts, but at some point were confused with casts. 8249 verifyFormat("virtual void foo(int *) override;"); 8250 verifyFormat("virtual void foo(char &) const;"); 8251 verifyFormat("virtual void foo(int *a, char *) const;"); 8252 verifyFormat("int a = sizeof(int *) + b;"); 8253 verifyFormat("int a = alignof(int *) + b;", getGoogleStyle()); 8254 verifyFormat("bool b = f(g<int>) && c;"); 8255 verifyFormat("typedef void (*f)(int i) func;"); 8256 verifyFormat("void operator++(int) noexcept;"); 8257 verifyFormat("void operator++(int &) noexcept;"); 8258 verifyFormat("void operator delete(void *, std::size_t, const std::nothrow_t " 8259 "&) noexcept;"); 8260 verifyFormat( 8261 "void operator delete(std::size_t, const std::nothrow_t &) noexcept;"); 8262 verifyFormat("void operator delete(const std::nothrow_t &) noexcept;"); 8263 verifyFormat("void operator delete(std::nothrow_t &) noexcept;"); 8264 verifyFormat("void operator delete(nothrow_t &) noexcept;"); 8265 verifyFormat("void operator delete(foo &) noexcept;"); 8266 verifyFormat("void operator delete(foo) noexcept;"); 8267 verifyFormat("void operator delete(int) noexcept;"); 8268 verifyFormat("void operator delete(int &) noexcept;"); 8269 verifyFormat("void operator delete(int &) volatile noexcept;"); 8270 verifyFormat("void operator delete(int &) const"); 8271 verifyFormat("void operator delete(int &) = default"); 8272 verifyFormat("void operator delete(int &) = delete"); 8273 verifyFormat("void operator delete(int &) [[noreturn]]"); 8274 verifyFormat("void operator delete(int &) throw();"); 8275 verifyFormat("void operator delete(int &) throw(int);"); 8276 verifyFormat("auto operator delete(int &) -> int;"); 8277 verifyFormat("auto operator delete(int &) override"); 8278 verifyFormat("auto operator delete(int &) final"); 8279 8280 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *foo = (aaaaaaaaaaaaaaaaa *)\n" 8281 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 8282 // FIXME: The indentation here is not ideal. 8283 verifyFormat( 8284 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 8285 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = (*cccccccccccccccc)\n" 8286 " [dddddddddddddddddddddddddddddddddddddddddddddddddddddddd];"); 8287 } 8288 8289 TEST_F(FormatTest, FormatsFunctionTypes) { 8290 verifyFormat("A<bool()> a;"); 8291 verifyFormat("A<SomeType()> a;"); 8292 verifyFormat("A<void (*)(int, std::string)> a;"); 8293 verifyFormat("A<void *(int)>;"); 8294 verifyFormat("void *(*a)(int *, SomeType *);"); 8295 verifyFormat("int (*func)(void *);"); 8296 verifyFormat("void f() { int (*func)(void *); }"); 8297 verifyFormat("template <class CallbackClass>\n" 8298 "using MyCallback = void (CallbackClass::*)(SomeObject *Data);"); 8299 8300 verifyGoogleFormat("A<void*(int*, SomeType*)>;"); 8301 verifyGoogleFormat("void* (*a)(int);"); 8302 verifyGoogleFormat( 8303 "template <class CallbackClass>\n" 8304 "using MyCallback = void (CallbackClass::*)(SomeObject* Data);"); 8305 8306 // Other constructs can look somewhat like function types: 8307 verifyFormat("A<sizeof(*x)> a;"); 8308 verifyFormat("#define DEREF_AND_CALL_F(x) f(*x)"); 8309 verifyFormat("some_var = function(*some_pointer_var)[0];"); 8310 verifyFormat("void f() { function(*some_pointer_var)[0] = 10; }"); 8311 verifyFormat("int x = f(&h)();"); 8312 verifyFormat("returnsFunction(¶m1, ¶m2)(param);"); 8313 verifyFormat("std::function<\n" 8314 " LooooooooooongTemplatedType<\n" 8315 " SomeType>*(\n" 8316 " LooooooooooooooooongType type)>\n" 8317 " function;", 8318 getGoogleStyleWithColumns(40)); 8319 } 8320 8321 TEST_F(FormatTest, FormatsPointersToArrayTypes) { 8322 verifyFormat("A (*foo_)[6];"); 8323 verifyFormat("vector<int> (*foo_)[6];"); 8324 } 8325 8326 TEST_F(FormatTest, BreaksLongVariableDeclarations) { 8327 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 8328 " LoooooooooooooooooooooooooooooooooooooooongVariable;"); 8329 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType const\n" 8330 " LoooooooooooooooooooooooooooooooooooooooongVariable;"); 8331 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 8332 " *LoooooooooooooooooooooooooooooooooooooooongVariable;"); 8333 8334 // Different ways of ()-initializiation. 8335 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 8336 " LoooooooooooooooooooooooooooooooooooooooongVariable(1);"); 8337 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 8338 " LoooooooooooooooooooooooooooooooooooooooongVariable(a);"); 8339 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 8340 " LoooooooooooooooooooooooooooooooooooooooongVariable({});"); 8341 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 8342 " LoooooooooooooooooooooooooooooooooooooongVariable([A a]);"); 8343 8344 // Lambdas should not confuse the variable declaration heuristic. 8345 verifyFormat("LooooooooooooooooongType\n" 8346 " variable(nullptr, [](A *a) {});", 8347 getLLVMStyleWithColumns(40)); 8348 } 8349 8350 TEST_F(FormatTest, BreaksLongDeclarations) { 8351 verifyFormat("typedef LoooooooooooooooooooooooooooooooooooooooongType\n" 8352 " AnotherNameForTheLongType;"); 8353 verifyFormat("typedef LongTemplateType<aaaaaaaaaaaaaaaaaaa()>\n" 8354 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 8355 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 8356 "LoooooooooooooooooooooooooooooooongFunctionDeclaration();"); 8357 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType *\n" 8358 "LoooooooooooooooooooooooooooooooongFunctionDeclaration();"); 8359 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 8360 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 8361 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType MACRO\n" 8362 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 8363 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType const\n" 8364 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 8365 verifyFormat("decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n" 8366 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 8367 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 8368 "LooooooooooooooooooooooooooongFunctionDeclaration(T... t);"); 8369 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 8370 "LooooooooooooooooooooooooooongFunctionDeclaration(T /*t*/) {}"); 8371 FormatStyle Indented = getLLVMStyle(); 8372 Indented.IndentWrappedFunctionNames = true; 8373 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 8374 " LoooooooooooooooooooooooooooooooongFunctionDeclaration();", 8375 Indented); 8376 verifyFormat( 8377 "LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 8378 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}", 8379 Indented); 8380 verifyFormat( 8381 "LoooooooooooooooooooooooooooooooooooooooongReturnType const\n" 8382 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}", 8383 Indented); 8384 verifyFormat( 8385 "decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n" 8386 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}", 8387 Indented); 8388 8389 // FIXME: Without the comment, this breaks after "(". 8390 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType // break\n" 8391 " (*LoooooooooooooooooooooooooooongFunctionTypeVarialbe)();", 8392 getGoogleStyle()); 8393 8394 verifyFormat("int *someFunction(int LoooooooooooooooooooongParam1,\n" 8395 " int LoooooooooooooooooooongParam2) {}"); 8396 verifyFormat( 8397 "TypeSpecDecl *TypeSpecDecl::Create(ASTContext &C, DeclContext *DC,\n" 8398 " SourceLocation L, IdentifierIn *II,\n" 8399 " Type *T) {}"); 8400 verifyFormat("ReallyLongReturnType<TemplateParam1, TemplateParam2>\n" 8401 "ReallyReaaallyLongFunctionName(\n" 8402 " const std::string &SomeParameter,\n" 8403 " const SomeType<string, SomeOtherTemplateParameter>\n" 8404 " &ReallyReallyLongParameterName,\n" 8405 " const SomeType<string, SomeOtherTemplateParameter>\n" 8406 " &AnotherLongParameterName) {}"); 8407 verifyFormat("template <typename A>\n" 8408 "SomeLoooooooooooooooooooooongType<\n" 8409 " typename some_namespace::SomeOtherType<A>::Type>\n" 8410 "Function() {}"); 8411 8412 verifyGoogleFormat( 8413 "aaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaa<aaaaaaaaaaaaa, aaaaaaaaaaaa>\n" 8414 " aaaaaaaaaaaaaaaaaaaaaaa;"); 8415 verifyGoogleFormat( 8416 "TypeSpecDecl* TypeSpecDecl::Create(ASTContext& C, DeclContext* DC,\n" 8417 " SourceLocation L) {}"); 8418 verifyGoogleFormat( 8419 "some_namespace::LongReturnType\n" 8420 "long_namespace::SomeVeryLongClass::SomeVeryLongFunction(\n" 8421 " int first_long_parameter, int second_parameter) {}"); 8422 8423 verifyGoogleFormat("template <typename T>\n" 8424 "aaaaaaaa::aaaaa::aaaaaa<T, aaaaaaaaaaaaaaaaaaaaaaaaa>\n" 8425 "aaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaa() {}"); 8426 verifyGoogleFormat("A<A<A>> aaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 8427 " int aaaaaaaaaaaaaaaaaaaaaaa);"); 8428 8429 verifyFormat("typedef size_t (*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n" 8430 " const aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 8431 " *aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 8432 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 8433 " vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n" 8434 " aaaaaaaaaaaaaaaaaaaaaaaa);"); 8435 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 8436 " vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n" 8437 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>>\n" 8438 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 8439 8440 verifyFormat("template <typename T> // Templates on own line.\n" 8441 "static int // Some comment.\n" 8442 "MyFunction(int a);", 8443 getLLVMStyle()); 8444 } 8445 8446 TEST_F(FormatTest, FormatsArrays) { 8447 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaaaaaaaaaa]\n" 8448 " [bbbbbbbbbbbbbbbbbbbbbbbbb] = c;"); 8449 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaa(aaaaaaaaaaaa)]\n" 8450 " [bbbbbbbbbbb(bbbbbbbbbbbb)] = c;"); 8451 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaa &&\n" 8452 " aaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaa][aaaaaaaaaaaaa]) {\n}"); 8453 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 8454 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;"); 8455 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 8456 " [a][bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = cccccccc;"); 8457 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 8458 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n" 8459 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;"); 8460 verifyFormat( 8461 "llvm::outs() << \"aaaaaaaaaaaa: \"\n" 8462 " << (*aaaaaaaiaaaaaaa)[aaaaaaaaaaaaaaaaaaaaaaaaa]\n" 8463 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa];"); 8464 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaa][a]\n" 8465 " .aaaaaaaaaaaaaaaaaaaaaa();"); 8466 8467 verifyGoogleFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<int>\n" 8468 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaa];"); 8469 verifyFormat( 8470 "aaaaaaaaaaa aaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaa->aaaaaaaaa[0]\n" 8471 " .aaaaaaa[0]\n" 8472 " .aaaaaaaaaaaaaaaaaaaaaa();"); 8473 verifyFormat("a[::b::c];"); 8474 8475 verifyNoCrash("a[,Y?)]", getLLVMStyleWithColumns(10)); 8476 8477 FormatStyle NoColumnLimit = getLLVMStyleWithColumns(0); 8478 verifyFormat("aaaaa[bbbbbb].cccccc()", NoColumnLimit); 8479 } 8480 8481 TEST_F(FormatTest, LineStartsWithSpecialCharacter) { 8482 verifyFormat("(a)->b();"); 8483 verifyFormat("--a;"); 8484 } 8485 8486 TEST_F(FormatTest, HandlesIncludeDirectives) { 8487 verifyFormat("#include <string>\n" 8488 "#include <a/b/c.h>\n" 8489 "#include \"a/b/string\"\n" 8490 "#include \"string.h\"\n" 8491 "#include \"string.h\"\n" 8492 "#include <a-a>\n" 8493 "#include < path with space >\n" 8494 "#include_next <test.h>" 8495 "#include \"abc.h\" // this is included for ABC\n" 8496 "#include \"some long include\" // with a comment\n" 8497 "#include \"some very long include path\"\n" 8498 "#include <some/very/long/include/path>\n", 8499 getLLVMStyleWithColumns(35)); 8500 EXPECT_EQ("#include \"a.h\"", format("#include \"a.h\"")); 8501 EXPECT_EQ("#include <a>", format("#include<a>")); 8502 8503 verifyFormat("#import <string>"); 8504 verifyFormat("#import <a/b/c.h>"); 8505 verifyFormat("#import \"a/b/string\""); 8506 verifyFormat("#import \"string.h\""); 8507 verifyFormat("#import \"string.h\""); 8508 verifyFormat("#if __has_include(<strstream>)\n" 8509 "#include <strstream>\n" 8510 "#endif"); 8511 8512 verifyFormat("#define MY_IMPORT <a/b>"); 8513 8514 verifyFormat("#if __has_include(<a/b>)"); 8515 verifyFormat("#if __has_include_next(<a/b>)"); 8516 verifyFormat("#define F __has_include(<a/b>)"); 8517 verifyFormat("#define F __has_include_next(<a/b>)"); 8518 8519 // Protocol buffer definition or missing "#". 8520 verifyFormat("import \"aaaaaaaaaaaaaaaaa/aaaaaaaaaaaaaaa\";", 8521 getLLVMStyleWithColumns(30)); 8522 8523 FormatStyle Style = getLLVMStyle(); 8524 Style.AlwaysBreakBeforeMultilineStrings = true; 8525 Style.ColumnLimit = 0; 8526 verifyFormat("#import \"abc.h\"", Style); 8527 8528 // But 'import' might also be a regular C++ namespace. 8529 verifyFormat("import::SomeFunction(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 8530 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 8531 } 8532 8533 //===----------------------------------------------------------------------===// 8534 // Error recovery tests. 8535 //===----------------------------------------------------------------------===// 8536 8537 TEST_F(FormatTest, IncompleteParameterLists) { 8538 FormatStyle NoBinPacking = getLLVMStyle(); 8539 NoBinPacking.BinPackParameters = false; 8540 verifyFormat("void aaaaaaaaaaaaaaaaaa(int level,\n" 8541 " double *min_x,\n" 8542 " double *max_x,\n" 8543 " double *min_y,\n" 8544 " double *max_y,\n" 8545 " double *min_z,\n" 8546 " double *max_z, ) {}", 8547 NoBinPacking); 8548 } 8549 8550 TEST_F(FormatTest, IncorrectCodeTrailingStuff) { 8551 verifyFormat("void f() { return; }\n42"); 8552 verifyFormat("void f() {\n" 8553 " if (0)\n" 8554 " return;\n" 8555 "}\n" 8556 "42"); 8557 verifyFormat("void f() { return }\n42"); 8558 verifyFormat("void f() {\n" 8559 " if (0)\n" 8560 " return\n" 8561 "}\n" 8562 "42"); 8563 } 8564 8565 TEST_F(FormatTest, IncorrectCodeMissingSemicolon) { 8566 EXPECT_EQ("void f() { return }", format("void f ( ) { return }")); 8567 EXPECT_EQ("void f() {\n" 8568 " if (a)\n" 8569 " return\n" 8570 "}", 8571 format("void f ( ) { if ( a ) return }")); 8572 EXPECT_EQ("namespace N {\n" 8573 "void f()\n" 8574 "}", 8575 format("namespace N { void f() }")); 8576 EXPECT_EQ("namespace N {\n" 8577 "void f() {}\n" 8578 "void g()\n" 8579 "} // namespace N", 8580 format("namespace N { void f( ) { } void g( ) }")); 8581 } 8582 8583 TEST_F(FormatTest, IndentationWithinColumnLimitNotPossible) { 8584 verifyFormat("int aaaaaaaa =\n" 8585 " // Overlylongcomment\n" 8586 " b;", 8587 getLLVMStyleWithColumns(20)); 8588 verifyFormat("function(\n" 8589 " ShortArgument,\n" 8590 " LoooooooooooongArgument);\n", 8591 getLLVMStyleWithColumns(20)); 8592 } 8593 8594 TEST_F(FormatTest, IncorrectAccessSpecifier) { 8595 verifyFormat("public:"); 8596 verifyFormat("class A {\n" 8597 "public\n" 8598 " void f() {}\n" 8599 "};"); 8600 verifyFormat("public\n" 8601 "int qwerty;"); 8602 verifyFormat("public\n" 8603 "B {}"); 8604 verifyFormat("public\n" 8605 "{}"); 8606 verifyFormat("public\n" 8607 "B { int x; }"); 8608 } 8609 8610 TEST_F(FormatTest, IncorrectCodeUnbalancedBraces) { 8611 verifyFormat("{"); 8612 verifyFormat("#})"); 8613 verifyNoCrash("(/**/[:!] ?[)."); 8614 } 8615 8616 TEST_F(FormatTest, IncorrectUnbalancedBracesInMacrosWithUnicode) { 8617 // Found by oss-fuzz: 8618 // https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=8212 8619 FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp); 8620 Style.ColumnLimit = 60; 8621 verifyNoCrash( 8622 "\x23\x47\xff\x20\x28\xff\x3c\xff\x3f\xff\x20\x2f\x7b\x7a\xff\x20" 8623 "\xff\xff\xff\xca\xb5\xff\xff\xff\xff\x3a\x7b\x7d\xff\x20\xff\x20" 8624 "\xff\x74\xff\x20\x7d\x7d\xff\x7b\x3a\xff\x20\x71\xff\x20\xff\x0a", 8625 Style); 8626 } 8627 8628 TEST_F(FormatTest, IncorrectCodeDoNoWhile) { 8629 verifyFormat("do {\n}"); 8630 verifyFormat("do {\n}\n" 8631 "f();"); 8632 verifyFormat("do {\n}\n" 8633 "wheeee(fun);"); 8634 verifyFormat("do {\n" 8635 " f();\n" 8636 "}"); 8637 } 8638 8639 TEST_F(FormatTest, IncorrectCodeMissingParens) { 8640 verifyFormat("if {\n foo;\n foo();\n}"); 8641 verifyFormat("switch {\n foo;\n foo();\n}"); 8642 verifyIncompleteFormat("for {\n foo;\n foo();\n}"); 8643 verifyFormat("while {\n foo;\n foo();\n}"); 8644 verifyFormat("do {\n foo;\n foo();\n} while;"); 8645 } 8646 8647 TEST_F(FormatTest, DoesNotTouchUnwrappedLinesWithErrors) { 8648 verifyIncompleteFormat("namespace {\n" 8649 "class Foo { Foo (\n" 8650 "};\n" 8651 "} // namespace"); 8652 } 8653 8654 TEST_F(FormatTest, IncorrectCodeErrorDetection) { 8655 EXPECT_EQ("{\n {}\n", format("{\n{\n}\n")); 8656 EXPECT_EQ("{\n {}\n", format("{\n {\n}\n")); 8657 EXPECT_EQ("{\n {}\n", format("{\n {\n }\n")); 8658 EXPECT_EQ("{\n {}\n}\n}\n", format("{\n {\n }\n }\n}\n")); 8659 8660 EXPECT_EQ("{\n" 8661 " {\n" 8662 " breakme(\n" 8663 " qwe);\n" 8664 " }\n", 8665 format("{\n" 8666 " {\n" 8667 " breakme(qwe);\n" 8668 "}\n", 8669 getLLVMStyleWithColumns(10))); 8670 } 8671 8672 TEST_F(FormatTest, LayoutCallsInsideBraceInitializers) { 8673 verifyFormat("int x = {\n" 8674 " avariable,\n" 8675 " b(alongervariable)};", 8676 getLLVMStyleWithColumns(25)); 8677 } 8678 8679 TEST_F(FormatTest, LayoutBraceInitializersInReturnStatement) { 8680 verifyFormat("return (a)(b){1, 2, 3};"); 8681 } 8682 8683 TEST_F(FormatTest, LayoutCxx11BraceInitializers) { 8684 verifyFormat("vector<int> x{1, 2, 3, 4};"); 8685 verifyFormat("vector<int> x{\n" 8686 " 1,\n" 8687 " 2,\n" 8688 " 3,\n" 8689 " 4,\n" 8690 "};"); 8691 verifyFormat("vector<T> x{{}, {}, {}, {}};"); 8692 verifyFormat("f({1, 2});"); 8693 verifyFormat("auto v = Foo{-1};"); 8694 verifyFormat("f({1, 2}, {{2, 3}, {4, 5}}, c, {d});"); 8695 verifyFormat("Class::Class : member{1, 2, 3} {}"); 8696 verifyFormat("new vector<int>{1, 2, 3};"); 8697 verifyFormat("new int[3]{1, 2, 3};"); 8698 verifyFormat("new int{1};"); 8699 verifyFormat("return {arg1, arg2};"); 8700 verifyFormat("return {arg1, SomeType{parameter}};"); 8701 verifyFormat("int count = set<int>{f(), g(), h()}.size();"); 8702 verifyFormat("new T{arg1, arg2};"); 8703 verifyFormat("f(MyMap[{composite, key}]);"); 8704 verifyFormat("class Class {\n" 8705 " T member = {arg1, arg2};\n" 8706 "};"); 8707 verifyFormat("vector<int> foo = {::SomeGlobalFunction()};"); 8708 verifyFormat("const struct A a = {.a = 1, .b = 2};"); 8709 verifyFormat("const struct A a = {[0] = 1, [1] = 2};"); 8710 verifyFormat("static_assert(std::is_integral<int>{} + 0, \"\");"); 8711 verifyFormat("int a = std::is_integral<int>{} + 0;"); 8712 8713 verifyFormat("int foo(int i) { return fo1{}(i); }"); 8714 verifyFormat("int foo(int i) { return fo1{}(i); }"); 8715 verifyFormat("auto i = decltype(x){};"); 8716 verifyFormat("std::vector<int> v = {1, 0 /* comment */};"); 8717 verifyFormat("Node n{1, Node{1000}, //\n" 8718 " 2};"); 8719 verifyFormat("Aaaa aaaaaaa{\n" 8720 " {\n" 8721 " aaaa,\n" 8722 " },\n" 8723 "};"); 8724 verifyFormat("class C : public D {\n" 8725 " SomeClass SC{2};\n" 8726 "};"); 8727 verifyFormat("class C : public A {\n" 8728 " class D : public B {\n" 8729 " void f() { int i{2}; }\n" 8730 " };\n" 8731 "};"); 8732 verifyFormat("#define A {a, a},"); 8733 8734 // Avoid breaking between equal sign and opening brace 8735 FormatStyle AvoidBreakingFirstArgument = getLLVMStyle(); 8736 AvoidBreakingFirstArgument.PenaltyBreakBeforeFirstCallParameter = 200; 8737 verifyFormat("const std::unordered_map<std::string, int> MyHashTable =\n" 8738 " {{\"aaaaaaaaaaaaaaaaaaaaa\", 0},\n" 8739 " {\"bbbbbbbbbbbbbbbbbbbbb\", 1},\n" 8740 " {\"ccccccccccccccccccccc\", 2}};", 8741 AvoidBreakingFirstArgument); 8742 8743 // Binpacking only if there is no trailing comma 8744 verifyFormat("const Aaaaaa aaaaa = {aaaaaaaaaa, bbbbbbbbbb,\n" 8745 " cccccccccc, dddddddddd};", 8746 getLLVMStyleWithColumns(50)); 8747 verifyFormat("const Aaaaaa aaaaa = {\n" 8748 " aaaaaaaaaaa,\n" 8749 " bbbbbbbbbbb,\n" 8750 " ccccccccccc,\n" 8751 " ddddddddddd,\n" 8752 "};", 8753 getLLVMStyleWithColumns(50)); 8754 8755 // Cases where distinguising braced lists and blocks is hard. 8756 verifyFormat("vector<int> v{12} GUARDED_BY(mutex);"); 8757 verifyFormat("void f() {\n" 8758 " return; // comment\n" 8759 "}\n" 8760 "SomeType t;"); 8761 verifyFormat("void f() {\n" 8762 " if (a) {\n" 8763 " f();\n" 8764 " }\n" 8765 "}\n" 8766 "SomeType t;"); 8767 8768 // In combination with BinPackArguments = false. 8769 FormatStyle NoBinPacking = getLLVMStyle(); 8770 NoBinPacking.BinPackArguments = false; 8771 verifyFormat("const Aaaaaa aaaaa = {aaaaa,\n" 8772 " bbbbb,\n" 8773 " ccccc,\n" 8774 " ddddd,\n" 8775 " eeeee,\n" 8776 " ffffff,\n" 8777 " ggggg,\n" 8778 " hhhhhh,\n" 8779 " iiiiii,\n" 8780 " jjjjjj,\n" 8781 " kkkkkk};", 8782 NoBinPacking); 8783 verifyFormat("const Aaaaaa aaaaa = {\n" 8784 " aaaaa,\n" 8785 " bbbbb,\n" 8786 " ccccc,\n" 8787 " ddddd,\n" 8788 " eeeee,\n" 8789 " ffffff,\n" 8790 " ggggg,\n" 8791 " hhhhhh,\n" 8792 " iiiiii,\n" 8793 " jjjjjj,\n" 8794 " kkkkkk,\n" 8795 "};", 8796 NoBinPacking); 8797 verifyFormat( 8798 "const Aaaaaa aaaaa = {\n" 8799 " aaaaa, bbbbb, ccccc, ddddd, eeeee, ffffff, ggggg, hhhhhh,\n" 8800 " iiiiii, jjjjjj, kkkkkk, aaaaa, bbbbb, ccccc, ddddd, eeeee,\n" 8801 " ffffff, ggggg, hhhhhh, iiiiii, jjjjjj, kkkkkk,\n" 8802 "};", 8803 NoBinPacking); 8804 8805 NoBinPacking.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 8806 EXPECT_EQ("static uint8 CddDp83848Reg[] = {\n" 8807 " CDDDP83848_BMCR_REGISTER,\n" 8808 " CDDDP83848_BMSR_REGISTER,\n" 8809 " CDDDP83848_RBR_REGISTER};", 8810 format("static uint8 CddDp83848Reg[] = {CDDDP83848_BMCR_REGISTER,\n" 8811 " CDDDP83848_BMSR_REGISTER,\n" 8812 " CDDDP83848_RBR_REGISTER};", 8813 NoBinPacking)); 8814 8815 // FIXME: The alignment of these trailing comments might be bad. Then again, 8816 // this might be utterly useless in real code. 8817 verifyFormat("Constructor::Constructor()\n" 8818 " : some_value{ //\n" 8819 " aaaaaaa, //\n" 8820 " bbbbbbb} {}"); 8821 8822 // In braced lists, the first comment is always assumed to belong to the 8823 // first element. Thus, it can be moved to the next or previous line as 8824 // appropriate. 8825 EXPECT_EQ("function({// First element:\n" 8826 " 1,\n" 8827 " // Second element:\n" 8828 " 2});", 8829 format("function({\n" 8830 " // First element:\n" 8831 " 1,\n" 8832 " // Second element:\n" 8833 " 2});")); 8834 EXPECT_EQ("std::vector<int> MyNumbers{\n" 8835 " // First element:\n" 8836 " 1,\n" 8837 " // Second element:\n" 8838 " 2};", 8839 format("std::vector<int> MyNumbers{// First element:\n" 8840 " 1,\n" 8841 " // Second element:\n" 8842 " 2};", 8843 getLLVMStyleWithColumns(30))); 8844 // A trailing comma should still lead to an enforced line break and no 8845 // binpacking. 8846 EXPECT_EQ("vector<int> SomeVector = {\n" 8847 " // aaa\n" 8848 " 1,\n" 8849 " 2,\n" 8850 "};", 8851 format("vector<int> SomeVector = { // aaa\n" 8852 " 1, 2, };")); 8853 8854 // C++11 brace initializer list l-braces should not be treated any differently 8855 // when breaking before lambda bodies is enabled 8856 FormatStyle BreakBeforeLambdaBody = getLLVMStyle(); 8857 BreakBeforeLambdaBody.BreakBeforeBraces = FormatStyle::BS_Custom; 8858 BreakBeforeLambdaBody.BraceWrapping.BeforeLambdaBody = true; 8859 BreakBeforeLambdaBody.AlwaysBreakBeforeMultilineStrings = true; 8860 verifyFormat( 8861 "std::runtime_error{\n" 8862 " \"Long string which will force a break onto the next line...\"};", 8863 BreakBeforeLambdaBody); 8864 8865 FormatStyle ExtraSpaces = getLLVMStyle(); 8866 ExtraSpaces.Cpp11BracedListStyle = false; 8867 ExtraSpaces.ColumnLimit = 75; 8868 verifyFormat("vector<int> x{ 1, 2, 3, 4 };", ExtraSpaces); 8869 verifyFormat("vector<T> x{ {}, {}, {}, {} };", ExtraSpaces); 8870 verifyFormat("f({ 1, 2 });", ExtraSpaces); 8871 verifyFormat("auto v = Foo{ 1 };", ExtraSpaces); 8872 verifyFormat("f({ 1, 2 }, { { 2, 3 }, { 4, 5 } }, c, { d });", ExtraSpaces); 8873 verifyFormat("Class::Class : member{ 1, 2, 3 } {}", ExtraSpaces); 8874 verifyFormat("new vector<int>{ 1, 2, 3 };", ExtraSpaces); 8875 verifyFormat("new int[3]{ 1, 2, 3 };", ExtraSpaces); 8876 verifyFormat("return { arg1, arg2 };", ExtraSpaces); 8877 verifyFormat("return { arg1, SomeType{ parameter } };", ExtraSpaces); 8878 verifyFormat("int count = set<int>{ f(), g(), h() }.size();", ExtraSpaces); 8879 verifyFormat("new T{ arg1, arg2 };", ExtraSpaces); 8880 verifyFormat("f(MyMap[{ composite, key }]);", ExtraSpaces); 8881 verifyFormat("class Class {\n" 8882 " T member = { arg1, arg2 };\n" 8883 "};", 8884 ExtraSpaces); 8885 verifyFormat( 8886 "foo = aaaaaaaaaaa ? vector<int>{ aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 8887 " aaaaaaaaaaaaaaaaaaaa, aaaaa }\n" 8888 " : vector<int>{ bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" 8889 " bbbbbbbbbbbbbbbbbbbb, bbbbb };", 8890 ExtraSpaces); 8891 verifyFormat("DoSomethingWithVector({} /* No data */);", ExtraSpaces); 8892 verifyFormat("DoSomethingWithVector({ {} /* No data */ }, { { 1, 2 } });", 8893 ExtraSpaces); 8894 verifyFormat( 8895 "someFunction(OtherParam,\n" 8896 " BracedList{ // comment 1 (Forcing interesting break)\n" 8897 " param1, param2,\n" 8898 " // comment 2\n" 8899 " param3, param4 });", 8900 ExtraSpaces); 8901 verifyFormat( 8902 "std::this_thread::sleep_for(\n" 8903 " std::chrono::nanoseconds{ std::chrono::seconds{ 1 } } / 5);", 8904 ExtraSpaces); 8905 verifyFormat("std::vector<MyValues> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa{\n" 8906 " aaaaaaa,\n" 8907 " aaaaaaaaaa,\n" 8908 " aaaaa,\n" 8909 " aaaaaaaaaaaaaaa,\n" 8910 " aaa,\n" 8911 " aaaaaaaaaa,\n" 8912 " a,\n" 8913 " aaaaaaaaaaaaaaaaaaaaa,\n" 8914 " aaaaaaaaaaaa,\n" 8915 " aaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaa,\n" 8916 " aaaaaaa,\n" 8917 " a};"); 8918 verifyFormat("vector<int> foo = { ::SomeGlobalFunction() };", ExtraSpaces); 8919 verifyFormat("const struct A a = { .a = 1, .b = 2 };", ExtraSpaces); 8920 verifyFormat("const struct A a = { [0] = 1, [1] = 2 };", ExtraSpaces); 8921 8922 // Avoid breaking between initializer/equal sign and opening brace 8923 ExtraSpaces.PenaltyBreakBeforeFirstCallParameter = 200; 8924 verifyFormat("const std::unordered_map<std::string, int> MyHashTable = {\n" 8925 " { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n" 8926 " { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n" 8927 " { \"ccccccccccccccccccccc\", 2 }\n" 8928 "};", 8929 ExtraSpaces); 8930 verifyFormat("const std::unordered_map<std::string, int> MyHashTable{\n" 8931 " { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n" 8932 " { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n" 8933 " { \"ccccccccccccccccccccc\", 2 }\n" 8934 "};", 8935 ExtraSpaces); 8936 8937 FormatStyle SpaceBeforeBrace = getLLVMStyle(); 8938 SpaceBeforeBrace.SpaceBeforeCpp11BracedList = true; 8939 verifyFormat("vector<int> x {1, 2, 3, 4};", SpaceBeforeBrace); 8940 verifyFormat("f({}, {{}, {}}, MyMap[{k, v}]);", SpaceBeforeBrace); 8941 8942 FormatStyle SpaceBetweenBraces = getLLVMStyle(); 8943 SpaceBetweenBraces.SpacesInAngles = true; 8944 SpaceBetweenBraces.SpacesInParentheses = true; 8945 SpaceBetweenBraces.SpacesInSquareBrackets = true; 8946 verifyFormat("vector< int > x{ 1, 2, 3, 4 };", SpaceBetweenBraces); 8947 verifyFormat("f( {}, { {}, {} }, MyMap[ { k, v } ] );", SpaceBetweenBraces); 8948 verifyFormat("vector< int > x{ // comment 1\n" 8949 " 1, 2, 3, 4 };", 8950 SpaceBetweenBraces); 8951 SpaceBetweenBraces.ColumnLimit = 20; 8952 EXPECT_EQ("vector< int > x{\n" 8953 " 1, 2, 3, 4 };", 8954 format("vector<int>x{1,2,3,4};", SpaceBetweenBraces)); 8955 SpaceBetweenBraces.ColumnLimit = 24; 8956 EXPECT_EQ("vector< int > x{ 1, 2,\n" 8957 " 3, 4 };", 8958 format("vector<int>x{1,2,3,4};", SpaceBetweenBraces)); 8959 EXPECT_EQ("vector< int > x{\n" 8960 " 1,\n" 8961 " 2,\n" 8962 " 3,\n" 8963 " 4,\n" 8964 "};", 8965 format("vector<int>x{1,2,3,4,};", SpaceBetweenBraces)); 8966 verifyFormat("vector< int > x{};", SpaceBetweenBraces); 8967 SpaceBetweenBraces.SpaceInEmptyParentheses = true; 8968 verifyFormat("vector< int > x{ };", SpaceBetweenBraces); 8969 } 8970 8971 TEST_F(FormatTest, FormatSpacesInAngles) { 8972 FormatStyle SpaceInAngles = getLLVMStyle(); 8973 SpaceInAngles.SpacesInAngles = true; 8974 verifyFormat("vector< ::std::string > x1;", SpaceInAngles); 8975 verifyFormat("Foo< int, Bar > x2;", SpaceInAngles); 8976 verifyFormat("Foo< ::int, ::Bar > x3;", SpaceInAngles); 8977 8978 SpaceInAngles.SpacesInAngles = false; 8979 verifyFormat("vector<::std::string> x4;", SpaceInAngles); 8980 verifyFormat("vector<int> x5;", SpaceInAngles); 8981 verifyFormat("Foo<int, Bar> x6;", SpaceInAngles); 8982 verifyFormat("Foo<::int, ::Bar> x7;", SpaceInAngles); 8983 } 8984 8985 TEST_F(FormatTest, FormatsBracedListsInColumnLayout) { 8986 verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8987 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8988 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8989 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8990 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8991 " 1, 22, 333, 4444, 55555, 666666, 7777777};"); 8992 verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777, //\n" 8993 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8994 " 1, 22, 333, 4444, 55555, //\n" 8995 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8996 " 1, 22, 333, 4444, 55555, 666666, 7777777};"); 8997 verifyFormat( 8998 "vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8999 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 9000 " 1, 22, 333, 4444, 55555, 666666, // comment\n" 9001 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 9002 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 9003 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 9004 " 7777777};"); 9005 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n" 9006 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n" 9007 " X86::R8, X86::R9, X86::R10, X86::R11, 0};"); 9008 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n" 9009 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n" 9010 " // Separating comment.\n" 9011 " X86::R8, X86::R9, X86::R10, X86::R11, 0};"); 9012 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n" 9013 " // Leading comment\n" 9014 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n" 9015 " X86::R8, X86::R9, X86::R10, X86::R11, 0};"); 9016 verifyFormat("vector<int> x = {1, 1, 1, 1,\n" 9017 " 1, 1, 1, 1};", 9018 getLLVMStyleWithColumns(39)); 9019 verifyFormat("vector<int> x = {1, 1, 1, 1,\n" 9020 " 1, 1, 1, 1};", 9021 getLLVMStyleWithColumns(38)); 9022 verifyFormat("vector<int> aaaaaaaaaaaaaaaaaaaaaa = {\n" 9023 " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};", 9024 getLLVMStyleWithColumns(43)); 9025 verifyFormat( 9026 "static unsigned SomeValues[10][3] = {\n" 9027 " {1, 4, 0}, {4, 9, 0}, {4, 5, 9}, {8, 5, 4}, {1, 8, 4},\n" 9028 " {10, 1, 6}, {11, 0, 9}, {2, 11, 9}, {5, 2, 9}, {11, 2, 7}};"); 9029 verifyFormat("static auto fields = new vector<string>{\n" 9030 " \"aaaaaaaaaaaaa\",\n" 9031 " \"aaaaaaaaaaaaa\",\n" 9032 " \"aaaaaaaaaaaa\",\n" 9033 " \"aaaaaaaaaaaaaa\",\n" 9034 " \"aaaaaaaaaaaaaaaaaaaaaaaaa\",\n" 9035 " \"aaaaaaaaaaaa\",\n" 9036 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",\n" 9037 "};"); 9038 verifyFormat("vector<int> x = {1, 2, 3, 4, aaaaaaaaaaaaaaaaa, 6};"); 9039 verifyFormat("vector<int> x = {1, aaaaaaaaaaaaaaaaaaaaaa,\n" 9040 " 2, bbbbbbbbbbbbbbbbbbbbbb,\n" 9041 " 3, cccccccccccccccccccccc};", 9042 getLLVMStyleWithColumns(60)); 9043 9044 // Trailing commas. 9045 verifyFormat("vector<int> x = {\n" 9046 " 1, 1, 1, 1, 1, 1, 1, 1,\n" 9047 "};", 9048 getLLVMStyleWithColumns(39)); 9049 verifyFormat("vector<int> x = {\n" 9050 " 1, 1, 1, 1, 1, 1, 1, 1, //\n" 9051 "};", 9052 getLLVMStyleWithColumns(39)); 9053 verifyFormat("vector<int> x = {1, 1, 1, 1,\n" 9054 " 1, 1, 1, 1,\n" 9055 " /**/ /**/};", 9056 getLLVMStyleWithColumns(39)); 9057 9058 // Trailing comment in the first line. 9059 verifyFormat("vector<int> iiiiiiiiiiiiiii = { //\n" 9060 " 1111111111, 2222222222, 33333333333, 4444444444, //\n" 9061 " 111111111, 222222222, 3333333333, 444444444, //\n" 9062 " 11111111, 22222222, 333333333, 44444444};"); 9063 // Trailing comment in the last line. 9064 verifyFormat("int aaaaa[] = {\n" 9065 " 1, 2, 3, // comment\n" 9066 " 4, 5, 6 // comment\n" 9067 "};"); 9068 9069 // With nested lists, we should either format one item per line or all nested 9070 // lists one on line. 9071 // FIXME: For some nested lists, we can do better. 9072 verifyFormat("return {{aaaaaaaaaaaaaaaaaaaaa},\n" 9073 " {aaaaaaaaaaaaaaaaaaa},\n" 9074 " {aaaaaaaaaaaaaaaaaaaaa},\n" 9075 " {aaaaaaaaaaaaaaaaa}};", 9076 getLLVMStyleWithColumns(60)); 9077 verifyFormat( 9078 "SomeStruct my_struct_array = {\n" 9079 " {aaaaaa, aaaaaaaa, aaaaaaaaaa, aaaaaaaaa, aaaaaaaaa, aaaaaaaaaa,\n" 9080 " aaaaaaaaaaaaa, aaaaaaa, aaa},\n" 9081 " {aaa, aaa},\n" 9082 " {aaa, aaa},\n" 9083 " {aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaa},\n" 9084 " {aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaa,\n" 9085 " aaaaaaaaaaaa, a, aaaaaaaaaa, aaaaaaaaa, aaa}};"); 9086 9087 // No column layout should be used here. 9088 verifyFormat("aaaaaaaaaaaaaaa = {aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0, 0,\n" 9089 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb};"); 9090 9091 verifyNoCrash("a<,"); 9092 9093 // No braced initializer here. 9094 verifyFormat("void f() {\n" 9095 " struct Dummy {};\n" 9096 " f(v);\n" 9097 "}"); 9098 9099 // Long lists should be formatted in columns even if they are nested. 9100 verifyFormat( 9101 "vector<int> x = function({1, 22, 333, 4444, 55555, 666666, 7777777,\n" 9102 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 9103 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 9104 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 9105 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 9106 " 1, 22, 333, 4444, 55555, 666666, 7777777});"); 9107 9108 // Allow "single-column" layout even if that violates the column limit. There 9109 // isn't going to be a better way. 9110 verifyFormat("std::vector<int> a = {\n" 9111 " aaaaaaaa,\n" 9112 " aaaaaaaa,\n" 9113 " aaaaaaaa,\n" 9114 " aaaaaaaa,\n" 9115 " aaaaaaaaaa,\n" 9116 " aaaaaaaa,\n" 9117 " aaaaaaaaaaaaaaaaaaaaaaaaaaa};", 9118 getLLVMStyleWithColumns(30)); 9119 verifyFormat("vector<int> aaaa = {\n" 9120 " aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 9121 " aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 9122 " aaaaaa.aaaaaaa,\n" 9123 " aaaaaa.aaaaaaa,\n" 9124 " aaaaaa.aaaaaaa,\n" 9125 " aaaaaa.aaaaaaa,\n" 9126 "};"); 9127 9128 // Don't create hanging lists. 9129 verifyFormat("someFunction(Param, {List1, List2,\n" 9130 " List3});", 9131 getLLVMStyleWithColumns(35)); 9132 verifyFormat("someFunction(Param, Param,\n" 9133 " {List1, List2,\n" 9134 " List3});", 9135 getLLVMStyleWithColumns(35)); 9136 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa, {},\n" 9137 " aaaaaaaaaaaaaaaaaaaaaaa);"); 9138 } 9139 9140 TEST_F(FormatTest, PullTrivialFunctionDefinitionsIntoSingleLine) { 9141 FormatStyle DoNotMerge = getLLVMStyle(); 9142 DoNotMerge.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 9143 9144 verifyFormat("void f() { return 42; }"); 9145 verifyFormat("void f() {\n" 9146 " return 42;\n" 9147 "}", 9148 DoNotMerge); 9149 verifyFormat("void f() {\n" 9150 " // Comment\n" 9151 "}"); 9152 verifyFormat("{\n" 9153 "#error {\n" 9154 " int a;\n" 9155 "}"); 9156 verifyFormat("{\n" 9157 " int a;\n" 9158 "#error {\n" 9159 "}"); 9160 verifyFormat("void f() {} // comment"); 9161 verifyFormat("void f() { int a; } // comment"); 9162 verifyFormat("void f() {\n" 9163 "} // comment", 9164 DoNotMerge); 9165 verifyFormat("void f() {\n" 9166 " int a;\n" 9167 "} // comment", 9168 DoNotMerge); 9169 verifyFormat("void f() {\n" 9170 "} // comment", 9171 getLLVMStyleWithColumns(15)); 9172 9173 verifyFormat("void f() { return 42; }", getLLVMStyleWithColumns(23)); 9174 verifyFormat("void f() {\n return 42;\n}", getLLVMStyleWithColumns(22)); 9175 9176 verifyFormat("void f() {}", getLLVMStyleWithColumns(11)); 9177 verifyFormat("void f() {\n}", getLLVMStyleWithColumns(10)); 9178 verifyFormat("class C {\n" 9179 " C()\n" 9180 " : iiiiiiii(nullptr),\n" 9181 " kkkkkkk(nullptr),\n" 9182 " mmmmmmm(nullptr),\n" 9183 " nnnnnnn(nullptr) {}\n" 9184 "};", 9185 getGoogleStyle()); 9186 9187 FormatStyle NoColumnLimit = getLLVMStyle(); 9188 NoColumnLimit.ColumnLimit = 0; 9189 EXPECT_EQ("A() : b(0) {}", format("A():b(0){}", NoColumnLimit)); 9190 EXPECT_EQ("class C {\n" 9191 " A() : b(0) {}\n" 9192 "};", 9193 format("class C{A():b(0){}};", NoColumnLimit)); 9194 EXPECT_EQ("A()\n" 9195 " : b(0) {\n" 9196 "}", 9197 format("A()\n:b(0)\n{\n}", NoColumnLimit)); 9198 9199 FormatStyle DoNotMergeNoColumnLimit = NoColumnLimit; 9200 DoNotMergeNoColumnLimit.AllowShortFunctionsOnASingleLine = 9201 FormatStyle::SFS_None; 9202 EXPECT_EQ("A()\n" 9203 " : b(0) {\n" 9204 "}", 9205 format("A():b(0){}", DoNotMergeNoColumnLimit)); 9206 EXPECT_EQ("A()\n" 9207 " : b(0) {\n" 9208 "}", 9209 format("A()\n:b(0)\n{\n}", DoNotMergeNoColumnLimit)); 9210 9211 verifyFormat("#define A \\\n" 9212 " void f() { \\\n" 9213 " int i; \\\n" 9214 " }", 9215 getLLVMStyleWithColumns(20)); 9216 verifyFormat("#define A \\\n" 9217 " void f() { int i; }", 9218 getLLVMStyleWithColumns(21)); 9219 verifyFormat("#define A \\\n" 9220 " void f() { \\\n" 9221 " int i; \\\n" 9222 " } \\\n" 9223 " int j;", 9224 getLLVMStyleWithColumns(22)); 9225 verifyFormat("#define A \\\n" 9226 " void f() { int i; } \\\n" 9227 " int j;", 9228 getLLVMStyleWithColumns(23)); 9229 } 9230 9231 TEST_F(FormatTest, PullEmptyFunctionDefinitionsIntoSingleLine) { 9232 FormatStyle MergeEmptyOnly = getLLVMStyle(); 9233 MergeEmptyOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty; 9234 verifyFormat("class C {\n" 9235 " int f() {}\n" 9236 "};", 9237 MergeEmptyOnly); 9238 verifyFormat("class C {\n" 9239 " int f() {\n" 9240 " return 42;\n" 9241 " }\n" 9242 "};", 9243 MergeEmptyOnly); 9244 verifyFormat("int f() {}", MergeEmptyOnly); 9245 verifyFormat("int f() {\n" 9246 " return 42;\n" 9247 "}", 9248 MergeEmptyOnly); 9249 9250 // Also verify behavior when BraceWrapping.AfterFunction = true 9251 MergeEmptyOnly.BreakBeforeBraces = FormatStyle::BS_Custom; 9252 MergeEmptyOnly.BraceWrapping.AfterFunction = true; 9253 verifyFormat("int f() {}", MergeEmptyOnly); 9254 verifyFormat("class C {\n" 9255 " int f() {}\n" 9256 "};", 9257 MergeEmptyOnly); 9258 } 9259 9260 TEST_F(FormatTest, PullInlineFunctionDefinitionsIntoSingleLine) { 9261 FormatStyle MergeInlineOnly = getLLVMStyle(); 9262 MergeInlineOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; 9263 verifyFormat("class C {\n" 9264 " int f() { return 42; }\n" 9265 "};", 9266 MergeInlineOnly); 9267 verifyFormat("int f() {\n" 9268 " return 42;\n" 9269 "}", 9270 MergeInlineOnly); 9271 9272 // SFS_Inline implies SFS_Empty 9273 verifyFormat("class C {\n" 9274 " int f() {}\n" 9275 "};", 9276 MergeInlineOnly); 9277 verifyFormat("int f() {}", MergeInlineOnly); 9278 9279 // Also verify behavior when BraceWrapping.AfterFunction = true 9280 MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom; 9281 MergeInlineOnly.BraceWrapping.AfterFunction = true; 9282 verifyFormat("class C {\n" 9283 " int f() { return 42; }\n" 9284 "};", 9285 MergeInlineOnly); 9286 verifyFormat("int f()\n" 9287 "{\n" 9288 " return 42;\n" 9289 "}", 9290 MergeInlineOnly); 9291 9292 // SFS_Inline implies SFS_Empty 9293 verifyFormat("int f() {}", MergeInlineOnly); 9294 verifyFormat("class C {\n" 9295 " int f() {}\n" 9296 "};", 9297 MergeInlineOnly); 9298 } 9299 9300 TEST_F(FormatTest, PullInlineOnlyFunctionDefinitionsIntoSingleLine) { 9301 FormatStyle MergeInlineOnly = getLLVMStyle(); 9302 MergeInlineOnly.AllowShortFunctionsOnASingleLine = 9303 FormatStyle::SFS_InlineOnly; 9304 verifyFormat("class C {\n" 9305 " int f() { return 42; }\n" 9306 "};", 9307 MergeInlineOnly); 9308 verifyFormat("int f() {\n" 9309 " return 42;\n" 9310 "}", 9311 MergeInlineOnly); 9312 9313 // SFS_InlineOnly does not imply SFS_Empty 9314 verifyFormat("class C {\n" 9315 " int f() {}\n" 9316 "};", 9317 MergeInlineOnly); 9318 verifyFormat("int f() {\n" 9319 "}", 9320 MergeInlineOnly); 9321 9322 // Also verify behavior when BraceWrapping.AfterFunction = true 9323 MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom; 9324 MergeInlineOnly.BraceWrapping.AfterFunction = true; 9325 verifyFormat("class C {\n" 9326 " int f() { return 42; }\n" 9327 "};", 9328 MergeInlineOnly); 9329 verifyFormat("int f()\n" 9330 "{\n" 9331 " return 42;\n" 9332 "}", 9333 MergeInlineOnly); 9334 9335 // SFS_InlineOnly does not imply SFS_Empty 9336 verifyFormat("int f()\n" 9337 "{\n" 9338 "}", 9339 MergeInlineOnly); 9340 verifyFormat("class C {\n" 9341 " int f() {}\n" 9342 "};", 9343 MergeInlineOnly); 9344 } 9345 9346 TEST_F(FormatTest, SplitEmptyFunction) { 9347 FormatStyle Style = getLLVMStyle(); 9348 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 9349 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 9350 Style.BraceWrapping.AfterFunction = true; 9351 Style.BraceWrapping.SplitEmptyFunction = false; 9352 Style.ColumnLimit = 40; 9353 9354 verifyFormat("int f()\n" 9355 "{}", 9356 Style); 9357 verifyFormat("int f()\n" 9358 "{\n" 9359 " return 42;\n" 9360 "}", 9361 Style); 9362 verifyFormat("int f()\n" 9363 "{\n" 9364 " // some comment\n" 9365 "}", 9366 Style); 9367 9368 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty; 9369 verifyFormat("int f() {}", Style); 9370 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 9371 "{}", 9372 Style); 9373 verifyFormat("int f()\n" 9374 "{\n" 9375 " return 0;\n" 9376 "}", 9377 Style); 9378 9379 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; 9380 verifyFormat("class Foo {\n" 9381 " int f() {}\n" 9382 "};\n", 9383 Style); 9384 verifyFormat("class Foo {\n" 9385 " int f() { return 0; }\n" 9386 "};\n", 9387 Style); 9388 verifyFormat("class Foo {\n" 9389 " int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 9390 " {}\n" 9391 "};\n", 9392 Style); 9393 verifyFormat("class Foo {\n" 9394 " int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 9395 " {\n" 9396 " return 0;\n" 9397 " }\n" 9398 "};\n", 9399 Style); 9400 9401 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 9402 verifyFormat("int f() {}", Style); 9403 verifyFormat("int f() { return 0; }", Style); 9404 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 9405 "{}", 9406 Style); 9407 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 9408 "{\n" 9409 " return 0;\n" 9410 "}", 9411 Style); 9412 } 9413 TEST_F(FormatTest, KeepShortFunctionAfterPPElse) { 9414 FormatStyle Style = getLLVMStyle(); 9415 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 9416 verifyFormat("#ifdef A\n" 9417 "int f() {}\n" 9418 "#else\n" 9419 "int g() {}\n" 9420 "#endif", 9421 Style); 9422 } 9423 9424 TEST_F(FormatTest, SplitEmptyClass) { 9425 FormatStyle Style = getLLVMStyle(); 9426 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 9427 Style.BraceWrapping.AfterClass = true; 9428 Style.BraceWrapping.SplitEmptyRecord = false; 9429 9430 verifyFormat("class Foo\n" 9431 "{};", 9432 Style); 9433 verifyFormat("/* something */ class Foo\n" 9434 "{};", 9435 Style); 9436 verifyFormat("template <typename X> class Foo\n" 9437 "{};", 9438 Style); 9439 verifyFormat("class Foo\n" 9440 "{\n" 9441 " Foo();\n" 9442 "};", 9443 Style); 9444 verifyFormat("typedef class Foo\n" 9445 "{\n" 9446 "} Foo_t;", 9447 Style); 9448 } 9449 9450 TEST_F(FormatTest, SplitEmptyStruct) { 9451 FormatStyle Style = getLLVMStyle(); 9452 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 9453 Style.BraceWrapping.AfterStruct = true; 9454 Style.BraceWrapping.SplitEmptyRecord = false; 9455 9456 verifyFormat("struct Foo\n" 9457 "{};", 9458 Style); 9459 verifyFormat("/* something */ struct Foo\n" 9460 "{};", 9461 Style); 9462 verifyFormat("template <typename X> struct Foo\n" 9463 "{};", 9464 Style); 9465 verifyFormat("struct Foo\n" 9466 "{\n" 9467 " Foo();\n" 9468 "};", 9469 Style); 9470 verifyFormat("typedef struct Foo\n" 9471 "{\n" 9472 "} Foo_t;", 9473 Style); 9474 // typedef struct Bar {} Bar_t; 9475 } 9476 9477 TEST_F(FormatTest, SplitEmptyUnion) { 9478 FormatStyle Style = getLLVMStyle(); 9479 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 9480 Style.BraceWrapping.AfterUnion = true; 9481 Style.BraceWrapping.SplitEmptyRecord = false; 9482 9483 verifyFormat("union Foo\n" 9484 "{};", 9485 Style); 9486 verifyFormat("/* something */ union Foo\n" 9487 "{};", 9488 Style); 9489 verifyFormat("union Foo\n" 9490 "{\n" 9491 " A,\n" 9492 "};", 9493 Style); 9494 verifyFormat("typedef union Foo\n" 9495 "{\n" 9496 "} Foo_t;", 9497 Style); 9498 } 9499 9500 TEST_F(FormatTest, SplitEmptyNamespace) { 9501 FormatStyle Style = getLLVMStyle(); 9502 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 9503 Style.BraceWrapping.AfterNamespace = true; 9504 Style.BraceWrapping.SplitEmptyNamespace = false; 9505 9506 verifyFormat("namespace Foo\n" 9507 "{};", 9508 Style); 9509 verifyFormat("/* something */ namespace Foo\n" 9510 "{};", 9511 Style); 9512 verifyFormat("inline namespace Foo\n" 9513 "{};", 9514 Style); 9515 verifyFormat("/* something */ inline namespace Foo\n" 9516 "{};", 9517 Style); 9518 verifyFormat("export namespace Foo\n" 9519 "{};", 9520 Style); 9521 verifyFormat("namespace Foo\n" 9522 "{\n" 9523 "void Bar();\n" 9524 "};", 9525 Style); 9526 } 9527 9528 TEST_F(FormatTest, NeverMergeShortRecords) { 9529 FormatStyle Style = getLLVMStyle(); 9530 9531 verifyFormat("class Foo {\n" 9532 " Foo();\n" 9533 "};", 9534 Style); 9535 verifyFormat("typedef class Foo {\n" 9536 " Foo();\n" 9537 "} Foo_t;", 9538 Style); 9539 verifyFormat("struct Foo {\n" 9540 " Foo();\n" 9541 "};", 9542 Style); 9543 verifyFormat("typedef struct Foo {\n" 9544 " Foo();\n" 9545 "} Foo_t;", 9546 Style); 9547 verifyFormat("union Foo {\n" 9548 " A,\n" 9549 "};", 9550 Style); 9551 verifyFormat("typedef union Foo {\n" 9552 " A,\n" 9553 "} Foo_t;", 9554 Style); 9555 verifyFormat("namespace Foo {\n" 9556 "void Bar();\n" 9557 "};", 9558 Style); 9559 9560 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 9561 Style.BraceWrapping.AfterClass = true; 9562 Style.BraceWrapping.AfterStruct = true; 9563 Style.BraceWrapping.AfterUnion = true; 9564 Style.BraceWrapping.AfterNamespace = true; 9565 verifyFormat("class Foo\n" 9566 "{\n" 9567 " Foo();\n" 9568 "};", 9569 Style); 9570 verifyFormat("typedef class Foo\n" 9571 "{\n" 9572 " Foo();\n" 9573 "} Foo_t;", 9574 Style); 9575 verifyFormat("struct Foo\n" 9576 "{\n" 9577 " Foo();\n" 9578 "};", 9579 Style); 9580 verifyFormat("typedef struct Foo\n" 9581 "{\n" 9582 " Foo();\n" 9583 "} Foo_t;", 9584 Style); 9585 verifyFormat("union Foo\n" 9586 "{\n" 9587 " A,\n" 9588 "};", 9589 Style); 9590 verifyFormat("typedef union Foo\n" 9591 "{\n" 9592 " A,\n" 9593 "} Foo_t;", 9594 Style); 9595 verifyFormat("namespace Foo\n" 9596 "{\n" 9597 "void Bar();\n" 9598 "};", 9599 Style); 9600 } 9601 9602 TEST_F(FormatTest, UnderstandContextOfRecordTypeKeywords) { 9603 // Elaborate type variable declarations. 9604 verifyFormat("struct foo a = {bar};\nint n;"); 9605 verifyFormat("class foo a = {bar};\nint n;"); 9606 verifyFormat("union foo a = {bar};\nint n;"); 9607 9608 // Elaborate types inside function definitions. 9609 verifyFormat("struct foo f() {}\nint n;"); 9610 verifyFormat("class foo f() {}\nint n;"); 9611 verifyFormat("union foo f() {}\nint n;"); 9612 9613 // Templates. 9614 verifyFormat("template <class X> void f() {}\nint n;"); 9615 verifyFormat("template <struct X> void f() {}\nint n;"); 9616 verifyFormat("template <union X> void f() {}\nint n;"); 9617 9618 // Actual definitions... 9619 verifyFormat("struct {\n} n;"); 9620 verifyFormat( 9621 "template <template <class T, class Y>, class Z> class X {\n} n;"); 9622 verifyFormat("union Z {\n int n;\n} x;"); 9623 verifyFormat("class MACRO Z {\n} n;"); 9624 verifyFormat("class MACRO(X) Z {\n} n;"); 9625 verifyFormat("class __attribute__(X) Z {\n} n;"); 9626 verifyFormat("class __declspec(X) Z {\n} n;"); 9627 verifyFormat("class A##B##C {\n} n;"); 9628 verifyFormat("class alignas(16) Z {\n} n;"); 9629 verifyFormat("class MACRO(X) alignas(16) Z {\n} n;"); 9630 verifyFormat("class MACROA MACRO(X) Z {\n} n;"); 9631 9632 // Redefinition from nested context: 9633 verifyFormat("class A::B::C {\n} n;"); 9634 9635 // Template definitions. 9636 verifyFormat( 9637 "template <typename F>\n" 9638 "Matcher(const Matcher<F> &Other,\n" 9639 " typename enable_if_c<is_base_of<F, T>::value &&\n" 9640 " !is_same<F, T>::value>::type * = 0)\n" 9641 " : Implementation(new ImplicitCastMatcher<F>(Other)) {}"); 9642 9643 // FIXME: This is still incorrectly handled at the formatter side. 9644 verifyFormat("template <> struct X < 15, i<3 && 42 < 50 && 33 < 28> {};"); 9645 verifyFormat("int i = SomeFunction(a<b, a> b);"); 9646 9647 // FIXME: 9648 // This now gets parsed incorrectly as class definition. 9649 // verifyFormat("class A<int> f() {\n}\nint n;"); 9650 9651 // Elaborate types where incorrectly parsing the structural element would 9652 // break the indent. 9653 verifyFormat("if (true)\n" 9654 " class X x;\n" 9655 "else\n" 9656 " f();\n"); 9657 9658 // This is simply incomplete. Formatting is not important, but must not crash. 9659 verifyFormat("class A:"); 9660 } 9661 9662 TEST_F(FormatTest, DoNotInterfereWithErrorAndWarning) { 9663 EXPECT_EQ("#error Leave all white!!!!! space* alone!\n", 9664 format("#error Leave all white!!!!! space* alone!\n")); 9665 EXPECT_EQ( 9666 "#warning Leave all white!!!!! space* alone!\n", 9667 format("#warning Leave all white!!!!! space* alone!\n")); 9668 EXPECT_EQ("#error 1", format(" # error 1")); 9669 EXPECT_EQ("#warning 1", format(" # warning 1")); 9670 } 9671 9672 TEST_F(FormatTest, FormatHashIfExpressions) { 9673 verifyFormat("#if AAAA && BBBB"); 9674 verifyFormat("#if (AAAA && BBBB)"); 9675 verifyFormat("#elif (AAAA && BBBB)"); 9676 // FIXME: Come up with a better indentation for #elif. 9677 verifyFormat( 9678 "#if !defined(AAAAAAA) && (defined CCCCCC || defined DDDDDD) && \\\n" 9679 " defined(BBBBBBBB)\n" 9680 "#elif !defined(AAAAAA) && (defined CCCCC || defined DDDDDD) && \\\n" 9681 " defined(BBBBBBBB)\n" 9682 "#endif", 9683 getLLVMStyleWithColumns(65)); 9684 } 9685 9686 TEST_F(FormatTest, MergeHandlingInTheFaceOfPreprocessorDirectives) { 9687 FormatStyle AllowsMergedIf = getGoogleStyle(); 9688 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = 9689 FormatStyle::SIS_WithoutElse; 9690 verifyFormat("void f() { f(); }\n#error E", AllowsMergedIf); 9691 verifyFormat("if (true) return 42;\n#error E", AllowsMergedIf); 9692 verifyFormat("if (true)\n#error E\n return 42;", AllowsMergedIf); 9693 EXPECT_EQ("if (true) return 42;", 9694 format("if (true)\nreturn 42;", AllowsMergedIf)); 9695 FormatStyle ShortMergedIf = AllowsMergedIf; 9696 ShortMergedIf.ColumnLimit = 25; 9697 verifyFormat("#define A \\\n" 9698 " if (true) return 42;", 9699 ShortMergedIf); 9700 verifyFormat("#define A \\\n" 9701 " f(); \\\n" 9702 " if (true)\n" 9703 "#define B", 9704 ShortMergedIf); 9705 verifyFormat("#define A \\\n" 9706 " f(); \\\n" 9707 " if (true)\n" 9708 "g();", 9709 ShortMergedIf); 9710 verifyFormat("{\n" 9711 "#ifdef A\n" 9712 " // Comment\n" 9713 " if (true) continue;\n" 9714 "#endif\n" 9715 " // Comment\n" 9716 " if (true) continue;\n" 9717 "}", 9718 ShortMergedIf); 9719 ShortMergedIf.ColumnLimit = 33; 9720 verifyFormat("#define A \\\n" 9721 " if constexpr (true) return 42;", 9722 ShortMergedIf); 9723 verifyFormat("#define A \\\n" 9724 " if CONSTEXPR (true) return 42;", 9725 ShortMergedIf); 9726 ShortMergedIf.ColumnLimit = 29; 9727 verifyFormat("#define A \\\n" 9728 " if (aaaaaaaaaa) return 1; \\\n" 9729 " return 2;", 9730 ShortMergedIf); 9731 ShortMergedIf.ColumnLimit = 28; 9732 verifyFormat("#define A \\\n" 9733 " if (aaaaaaaaaa) \\\n" 9734 " return 1; \\\n" 9735 " return 2;", 9736 ShortMergedIf); 9737 verifyFormat("#define A \\\n" 9738 " if constexpr (aaaaaaa) \\\n" 9739 " return 1; \\\n" 9740 " return 2;", 9741 ShortMergedIf); 9742 verifyFormat("#define A \\\n" 9743 " if CONSTEXPR (aaaaaaa) \\\n" 9744 " return 1; \\\n" 9745 " return 2;", 9746 ShortMergedIf); 9747 } 9748 9749 TEST_F(FormatTest, FormatStarDependingOnContext) { 9750 verifyFormat("void f(int *a);"); 9751 verifyFormat("void f() { f(fint * b); }"); 9752 verifyFormat("class A {\n void f(int *a);\n};"); 9753 verifyFormat("class A {\n int *a;\n};"); 9754 verifyFormat("namespace a {\n" 9755 "namespace b {\n" 9756 "class A {\n" 9757 " void f() {}\n" 9758 " int *a;\n" 9759 "};\n" 9760 "} // namespace b\n" 9761 "} // namespace a"); 9762 } 9763 9764 TEST_F(FormatTest, SpecialTokensAtEndOfLine) { 9765 verifyFormat("while"); 9766 verifyFormat("operator"); 9767 } 9768 9769 TEST_F(FormatTest, SkipsDeeplyNestedLines) { 9770 // This code would be painfully slow to format if we didn't skip it. 9771 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 9772 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 9773 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 9774 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 9775 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 9776 "A(1, 1)\n" 9777 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" // 10x 9778 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9779 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9780 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9781 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9782 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9783 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9784 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9785 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9786 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1);\n"); 9787 // Deeply nested part is untouched, rest is formatted. 9788 EXPECT_EQ(std::string("int i;\n") + Code + "int j;\n", 9789 format(std::string("int i;\n") + Code + "int j;\n", 9790 getLLVMStyle(), SC_ExpectIncomplete)); 9791 } 9792 9793 //===----------------------------------------------------------------------===// 9794 // Objective-C tests. 9795 //===----------------------------------------------------------------------===// 9796 9797 TEST_F(FormatTest, FormatForObjectiveCMethodDecls) { 9798 verifyFormat("- (void)sendAction:(SEL)aSelector to:(BOOL)anObject;"); 9799 EXPECT_EQ("- (NSUInteger)indexOfObject:(id)anObject;", 9800 format("-(NSUInteger)indexOfObject:(id)anObject;")); 9801 EXPECT_EQ("- (NSInteger)Mthod1;", format("-(NSInteger)Mthod1;")); 9802 EXPECT_EQ("+ (id)Mthod2;", format("+(id)Mthod2;")); 9803 EXPECT_EQ("- (NSInteger)Method3:(id)anObject;", 9804 format("-(NSInteger)Method3:(id)anObject;")); 9805 EXPECT_EQ("- (NSInteger)Method4:(id)anObject;", 9806 format("-(NSInteger)Method4:(id)anObject;")); 9807 EXPECT_EQ("- (NSInteger)Method5:(id)anObject:(id)AnotherObject;", 9808 format("-(NSInteger)Method5:(id)anObject:(id)AnotherObject;")); 9809 EXPECT_EQ("- (id)Method6:(id)A:(id)B:(id)C:(id)D;", 9810 format("- (id)Method6:(id)A:(id)B:(id)C:(id)D;")); 9811 EXPECT_EQ("- (void)sendAction:(SEL)aSelector to:(id)anObject " 9812 "forAllCells:(BOOL)flag;", 9813 format("- (void)sendAction:(SEL)aSelector to:(id)anObject " 9814 "forAllCells:(BOOL)flag;")); 9815 9816 // Very long objectiveC method declaration. 9817 verifyFormat("- (void)aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n" 9818 " (SoooooooooooooooooooooomeType *)bbbbbbbbbb;"); 9819 verifyFormat("- (NSUInteger)indexOfObject:(id)anObject\n" 9820 " inRange:(NSRange)range\n" 9821 " outRange:(NSRange)out_range\n" 9822 " outRange1:(NSRange)out_range1\n" 9823 " outRange2:(NSRange)out_range2\n" 9824 " outRange3:(NSRange)out_range3\n" 9825 " outRange4:(NSRange)out_range4\n" 9826 " outRange5:(NSRange)out_range5\n" 9827 " outRange6:(NSRange)out_range6\n" 9828 " outRange7:(NSRange)out_range7\n" 9829 " outRange8:(NSRange)out_range8\n" 9830 " outRange9:(NSRange)out_range9;"); 9831 9832 // When the function name has to be wrapped. 9833 FormatStyle Style = getLLVMStyle(); 9834 // ObjC ignores IndentWrappedFunctionNames when wrapping methods 9835 // and always indents instead. 9836 Style.IndentWrappedFunctionNames = false; 9837 verifyFormat("- (SomeLooooooooooooooooooooongType *)\n" 9838 " veryLooooooooooongName:(NSString)aaaaaaaaaaaaaa\n" 9839 " anotherName:(NSString)bbbbbbbbbbbbbb {\n" 9840 "}", 9841 Style); 9842 Style.IndentWrappedFunctionNames = true; 9843 verifyFormat("- (SomeLooooooooooooooooooooongType *)\n" 9844 " veryLooooooooooongName:(NSString)cccccccccccccc\n" 9845 " anotherName:(NSString)dddddddddddddd {\n" 9846 "}", 9847 Style); 9848 9849 verifyFormat("- (int)sum:(vector<int>)numbers;"); 9850 verifyGoogleFormat("- (void)setDelegate:(id<Protocol>)delegate;"); 9851 // FIXME: In LLVM style, there should be a space in front of a '<' for ObjC 9852 // protocol lists (but not for template classes): 9853 // verifyFormat("- (void)setDelegate:(id <Protocol>)delegate;"); 9854 9855 verifyFormat("- (int (*)())foo:(int (*)())f;"); 9856 verifyGoogleFormat("- (int (*)())foo:(int (*)())foo;"); 9857 9858 // If there's no return type (very rare in practice!), LLVM and Google style 9859 // agree. 9860 verifyFormat("- foo;"); 9861 verifyFormat("- foo:(int)f;"); 9862 verifyGoogleFormat("- foo:(int)foo;"); 9863 } 9864 9865 TEST_F(FormatTest, BreaksStringLiterals) { 9866 EXPECT_EQ("\"some text \"\n" 9867 "\"other\";", 9868 format("\"some text other\";", getLLVMStyleWithColumns(12))); 9869 EXPECT_EQ("\"some text \"\n" 9870 "\"other\";", 9871 format("\\\n\"some text other\";", getLLVMStyleWithColumns(12))); 9872 EXPECT_EQ( 9873 "#define A \\\n" 9874 " \"some \" \\\n" 9875 " \"text \" \\\n" 9876 " \"other\";", 9877 format("#define A \"some text other\";", getLLVMStyleWithColumns(12))); 9878 EXPECT_EQ( 9879 "#define A \\\n" 9880 " \"so \" \\\n" 9881 " \"text \" \\\n" 9882 " \"other\";", 9883 format("#define A \"so text other\";", getLLVMStyleWithColumns(12))); 9884 9885 EXPECT_EQ("\"some text\"", 9886 format("\"some text\"", getLLVMStyleWithColumns(1))); 9887 EXPECT_EQ("\"some text\"", 9888 format("\"some text\"", getLLVMStyleWithColumns(11))); 9889 EXPECT_EQ("\"some \"\n" 9890 "\"text\"", 9891 format("\"some text\"", getLLVMStyleWithColumns(10))); 9892 EXPECT_EQ("\"some \"\n" 9893 "\"text\"", 9894 format("\"some text\"", getLLVMStyleWithColumns(7))); 9895 EXPECT_EQ("\"some\"\n" 9896 "\" tex\"\n" 9897 "\"t\"", 9898 format("\"some text\"", getLLVMStyleWithColumns(6))); 9899 EXPECT_EQ("\"some\"\n" 9900 "\" tex\"\n" 9901 "\" and\"", 9902 format("\"some tex and\"", getLLVMStyleWithColumns(6))); 9903 EXPECT_EQ("\"some\"\n" 9904 "\"/tex\"\n" 9905 "\"/and\"", 9906 format("\"some/tex/and\"", getLLVMStyleWithColumns(6))); 9907 9908 EXPECT_EQ("variable =\n" 9909 " \"long string \"\n" 9910 " \"literal\";", 9911 format("variable = \"long string literal\";", 9912 getLLVMStyleWithColumns(20))); 9913 9914 EXPECT_EQ("variable = f(\n" 9915 " \"long string \"\n" 9916 " \"literal\",\n" 9917 " short,\n" 9918 " loooooooooooooooooooong);", 9919 format("variable = f(\"long string literal\", short, " 9920 "loooooooooooooooooooong);", 9921 getLLVMStyleWithColumns(20))); 9922 9923 EXPECT_EQ( 9924 "f(g(\"long string \"\n" 9925 " \"literal\"),\n" 9926 " b);", 9927 format("f(g(\"long string literal\"), b);", getLLVMStyleWithColumns(20))); 9928 EXPECT_EQ("f(g(\"long string \"\n" 9929 " \"literal\",\n" 9930 " a),\n" 9931 " b);", 9932 format("f(g(\"long string literal\", a), b);", 9933 getLLVMStyleWithColumns(20))); 9934 EXPECT_EQ( 9935 "f(\"one two\".split(\n" 9936 " variable));", 9937 format("f(\"one two\".split(variable));", getLLVMStyleWithColumns(20))); 9938 EXPECT_EQ("f(\"one two three four five six \"\n" 9939 " \"seven\".split(\n" 9940 " really_looooong_variable));", 9941 format("f(\"one two three four five six seven\"." 9942 "split(really_looooong_variable));", 9943 getLLVMStyleWithColumns(33))); 9944 9945 EXPECT_EQ("f(\"some \"\n" 9946 " \"text\",\n" 9947 " other);", 9948 format("f(\"some text\", other);", getLLVMStyleWithColumns(10))); 9949 9950 // Only break as a last resort. 9951 verifyFormat( 9952 "aaaaaaaaaaaaaaaaaaaa(\n" 9953 " aaaaaaaaaaaaaaaaaaaa,\n" 9954 " aaaaaa(\"aaa aaaaa aaa aaa aaaaa aaa aaaaa aaa aaa aaaaaa\"));"); 9955 9956 EXPECT_EQ("\"splitmea\"\n" 9957 "\"trandomp\"\n" 9958 "\"oint\"", 9959 format("\"splitmeatrandompoint\"", getLLVMStyleWithColumns(10))); 9960 9961 EXPECT_EQ("\"split/\"\n" 9962 "\"pathat/\"\n" 9963 "\"slashes\"", 9964 format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10))); 9965 9966 EXPECT_EQ("\"split/\"\n" 9967 "\"pathat/\"\n" 9968 "\"slashes\"", 9969 format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10))); 9970 EXPECT_EQ("\"split at \"\n" 9971 "\"spaces/at/\"\n" 9972 "\"slashes.at.any$\"\n" 9973 "\"non-alphanumeric%\"\n" 9974 "\"1111111111characte\"\n" 9975 "\"rs\"", 9976 format("\"split at " 9977 "spaces/at/" 9978 "slashes.at." 9979 "any$non-" 9980 "alphanumeric%" 9981 "1111111111characte" 9982 "rs\"", 9983 getLLVMStyleWithColumns(20))); 9984 9985 // Verify that splitting the strings understands 9986 // Style::AlwaysBreakBeforeMultilineStrings. 9987 EXPECT_EQ("aaaaaaaaaaaa(\n" 9988 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa \"\n" 9989 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\");", 9990 format("aaaaaaaaaaaa(\"aaaaaaaaaaaaaaaaaaaaaaaaaa " 9991 "aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa " 9992 "aaaaaaaaaaaaaaaaaaaaaa\");", 9993 getGoogleStyle())); 9994 EXPECT_EQ("return \"aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 9995 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\";", 9996 format("return \"aaaaaaaaaaaaaaaaaaaaaa " 9997 "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa " 9998 "aaaaaaaaaaaaaaaaaaaaaa\";", 9999 getGoogleStyle())); 10000 EXPECT_EQ("llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 10001 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";", 10002 format("llvm::outs() << " 10003 "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa" 10004 "aaaaaaaaaaaaaaaaaaa\";")); 10005 EXPECT_EQ("ffff(\n" 10006 " {\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 10007 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});", 10008 format("ffff({\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa " 10009 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});", 10010 getGoogleStyle())); 10011 10012 FormatStyle Style = getLLVMStyleWithColumns(12); 10013 Style.BreakStringLiterals = false; 10014 EXPECT_EQ("\"some text other\";", format("\"some text other\";", Style)); 10015 10016 FormatStyle AlignLeft = getLLVMStyleWithColumns(12); 10017 AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left; 10018 EXPECT_EQ("#define A \\\n" 10019 " \"some \" \\\n" 10020 " \"text \" \\\n" 10021 " \"other\";", 10022 format("#define A \"some text other\";", AlignLeft)); 10023 } 10024 10025 TEST_F(FormatTest, BreaksStringLiteralsAtColumnLimit) { 10026 EXPECT_EQ("C a = \"some more \"\n" 10027 " \"text\";", 10028 format("C a = \"some more text\";", getLLVMStyleWithColumns(18))); 10029 } 10030 10031 TEST_F(FormatTest, FullyRemoveEmptyLines) { 10032 FormatStyle NoEmptyLines = getLLVMStyleWithColumns(80); 10033 NoEmptyLines.MaxEmptyLinesToKeep = 0; 10034 EXPECT_EQ("int i = a(b());", 10035 format("int i=a(\n\n b(\n\n\n )\n\n);", NoEmptyLines)); 10036 } 10037 10038 TEST_F(FormatTest, BreaksStringLiteralsWithTabs) { 10039 EXPECT_EQ( 10040 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 10041 "(\n" 10042 " \"x\t\");", 10043 format("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 10044 "aaaaaaa(" 10045 "\"x\t\");")); 10046 } 10047 10048 TEST_F(FormatTest, BreaksWideAndNSStringLiterals) { 10049 EXPECT_EQ( 10050 "u8\"utf8 string \"\n" 10051 "u8\"literal\";", 10052 format("u8\"utf8 string literal\";", getGoogleStyleWithColumns(16))); 10053 EXPECT_EQ( 10054 "u\"utf16 string \"\n" 10055 "u\"literal\";", 10056 format("u\"utf16 string literal\";", getGoogleStyleWithColumns(16))); 10057 EXPECT_EQ( 10058 "U\"utf32 string \"\n" 10059 "U\"literal\";", 10060 format("U\"utf32 string literal\";", getGoogleStyleWithColumns(16))); 10061 EXPECT_EQ("L\"wide string \"\n" 10062 "L\"literal\";", 10063 format("L\"wide string literal\";", getGoogleStyleWithColumns(16))); 10064 EXPECT_EQ("@\"NSString \"\n" 10065 "@\"literal\";", 10066 format("@\"NSString literal\";", getGoogleStyleWithColumns(19))); 10067 verifyFormat(R"(NSString *s = @"那那那那";)", getLLVMStyleWithColumns(26)); 10068 10069 // This input makes clang-format try to split the incomplete unicode escape 10070 // sequence, which used to lead to a crasher. 10071 verifyNoCrash( 10072 "aaaaaaaaaaaaaaaaaaaa = L\"\\udff\"'; // aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 10073 getLLVMStyleWithColumns(60)); 10074 } 10075 10076 TEST_F(FormatTest, DoesNotBreakRawStringLiterals) { 10077 FormatStyle Style = getGoogleStyleWithColumns(15); 10078 EXPECT_EQ("R\"x(raw literal)x\";", format("R\"x(raw literal)x\";", Style)); 10079 EXPECT_EQ("uR\"x(raw literal)x\";", format("uR\"x(raw literal)x\";", Style)); 10080 EXPECT_EQ("LR\"x(raw literal)x\";", format("LR\"x(raw literal)x\";", Style)); 10081 EXPECT_EQ("UR\"x(raw literal)x\";", format("UR\"x(raw literal)x\";", Style)); 10082 EXPECT_EQ("u8R\"x(raw literal)x\";", 10083 format("u8R\"x(raw literal)x\";", Style)); 10084 } 10085 10086 TEST_F(FormatTest, BreaksStringLiteralsWithin_TMacro) { 10087 FormatStyle Style = getLLVMStyleWithColumns(20); 10088 EXPECT_EQ( 10089 "_T(\"aaaaaaaaaaaaaa\")\n" 10090 "_T(\"aaaaaaaaaaaaaa\")\n" 10091 "_T(\"aaaaaaaaaaaa\")", 10092 format(" _T(\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\")", Style)); 10093 EXPECT_EQ("f(x,\n" 10094 " _T(\"aaaaaaaaaaaa\")\n" 10095 " _T(\"aaa\"),\n" 10096 " z);", 10097 format("f(x, _T(\"aaaaaaaaaaaaaaa\"), z);", Style)); 10098 10099 // FIXME: Handle embedded spaces in one iteration. 10100 // EXPECT_EQ("_T(\"aaaaaaaaaaaaa\")\n" 10101 // "_T(\"aaaaaaaaaaaaa\")\n" 10102 // "_T(\"aaaaaaaaaaaaa\")\n" 10103 // "_T(\"a\")", 10104 // format(" _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", 10105 // getLLVMStyleWithColumns(20))); 10106 EXPECT_EQ( 10107 "_T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", 10108 format(" _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", Style)); 10109 EXPECT_EQ("f(\n" 10110 "#if !TEST\n" 10111 " _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n" 10112 "#endif\n" 10113 ");", 10114 format("f(\n" 10115 "#if !TEST\n" 10116 "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n" 10117 "#endif\n" 10118 ");")); 10119 EXPECT_EQ("f(\n" 10120 "\n" 10121 " _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));", 10122 format("f(\n" 10123 "\n" 10124 "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));")); 10125 } 10126 10127 TEST_F(FormatTest, BreaksStringLiteralOperands) { 10128 // In a function call with two operands, the second can be broken with no line 10129 // break before it. 10130 EXPECT_EQ( 10131 "func(a, \"long long \"\n" 10132 " \"long long\");", 10133 format("func(a, \"long long long long\");", getLLVMStyleWithColumns(24))); 10134 // In a function call with three operands, the second must be broken with a 10135 // line break before it. 10136 EXPECT_EQ("func(a,\n" 10137 " \"long long long \"\n" 10138 " \"long\",\n" 10139 " c);", 10140 format("func(a, \"long long long long\", c);", 10141 getLLVMStyleWithColumns(24))); 10142 // In a function call with three operands, the third must be broken with a 10143 // line break before it. 10144 EXPECT_EQ("func(a, b,\n" 10145 " \"long long long \"\n" 10146 " \"long\");", 10147 format("func(a, b, \"long long long long\");", 10148 getLLVMStyleWithColumns(24))); 10149 // In a function call with three operands, both the second and the third must 10150 // be broken with a line break before them. 10151 EXPECT_EQ("func(a,\n" 10152 " \"long long long \"\n" 10153 " \"long\",\n" 10154 " \"long long long \"\n" 10155 " \"long\");", 10156 format("func(a, \"long long long long\", \"long long long long\");", 10157 getLLVMStyleWithColumns(24))); 10158 // In a chain of << with two operands, the second can be broken with no line 10159 // break before it. 10160 EXPECT_EQ("a << \"line line \"\n" 10161 " \"line\";", 10162 format("a << \"line line line\";", getLLVMStyleWithColumns(20))); 10163 // In a chain of << with three operands, the second can be broken with no line 10164 // break before it. 10165 EXPECT_EQ( 10166 "abcde << \"line \"\n" 10167 " \"line line\"\n" 10168 " << c;", 10169 format("abcde << \"line line line\" << c;", getLLVMStyleWithColumns(20))); 10170 // In a chain of << with three operands, the third must be broken with a line 10171 // break before it. 10172 EXPECT_EQ( 10173 "a << b\n" 10174 " << \"line line \"\n" 10175 " \"line\";", 10176 format("a << b << \"line line line\";", getLLVMStyleWithColumns(20))); 10177 // In a chain of << with three operands, the second can be broken with no line 10178 // break before it and the third must be broken with a line break before it. 10179 EXPECT_EQ("abcd << \"line line \"\n" 10180 " \"line\"\n" 10181 " << \"line line \"\n" 10182 " \"line\";", 10183 format("abcd << \"line line line\" << \"line line line\";", 10184 getLLVMStyleWithColumns(20))); 10185 // In a chain of binary operators with two operands, the second can be broken 10186 // with no line break before it. 10187 EXPECT_EQ( 10188 "abcd + \"line line \"\n" 10189 " \"line line\";", 10190 format("abcd + \"line line line line\";", getLLVMStyleWithColumns(20))); 10191 // In a chain of binary operators with three operands, the second must be 10192 // broken with a line break before it. 10193 EXPECT_EQ("abcd +\n" 10194 " \"line line \"\n" 10195 " \"line line\" +\n" 10196 " e;", 10197 format("abcd + \"line line line line\" + e;", 10198 getLLVMStyleWithColumns(20))); 10199 // In a function call with two operands, with AlignAfterOpenBracket enabled, 10200 // the first must be broken with a line break before it. 10201 FormatStyle Style = getLLVMStyleWithColumns(25); 10202 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 10203 EXPECT_EQ("someFunction(\n" 10204 " \"long long long \"\n" 10205 " \"long\",\n" 10206 " a);", 10207 format("someFunction(\"long long long long\", a);", Style)); 10208 } 10209 10210 TEST_F(FormatTest, DontSplitStringLiteralsWithEscapedNewlines) { 10211 EXPECT_EQ( 10212 "aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 10213 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 10214 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";", 10215 format("aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 10216 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 10217 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";")); 10218 } 10219 10220 TEST_F(FormatTest, CountsCharactersInMultilineRawStringLiterals) { 10221 EXPECT_EQ("f(g(R\"x(raw literal)x\", a), b);", 10222 format("f(g(R\"x(raw literal)x\", a), b);", getGoogleStyle())); 10223 EXPECT_EQ("fffffffffff(g(R\"x(\n" 10224 "multiline raw string literal xxxxxxxxxxxxxx\n" 10225 ")x\",\n" 10226 " a),\n" 10227 " b);", 10228 format("fffffffffff(g(R\"x(\n" 10229 "multiline raw string literal xxxxxxxxxxxxxx\n" 10230 ")x\", a), b);", 10231 getGoogleStyleWithColumns(20))); 10232 EXPECT_EQ("fffffffffff(\n" 10233 " g(R\"x(qqq\n" 10234 "multiline raw string literal xxxxxxxxxxxxxx\n" 10235 ")x\",\n" 10236 " a),\n" 10237 " b);", 10238 format("fffffffffff(g(R\"x(qqq\n" 10239 "multiline raw string literal xxxxxxxxxxxxxx\n" 10240 ")x\", a), b);", 10241 getGoogleStyleWithColumns(20))); 10242 10243 EXPECT_EQ("fffffffffff(R\"x(\n" 10244 "multiline raw string literal xxxxxxxxxxxxxx\n" 10245 ")x\");", 10246 format("fffffffffff(R\"x(\n" 10247 "multiline raw string literal xxxxxxxxxxxxxx\n" 10248 ")x\");", 10249 getGoogleStyleWithColumns(20))); 10250 EXPECT_EQ("fffffffffff(R\"x(\n" 10251 "multiline raw string literal xxxxxxxxxxxxxx\n" 10252 ")x\" + bbbbbb);", 10253 format("fffffffffff(R\"x(\n" 10254 "multiline raw string literal xxxxxxxxxxxxxx\n" 10255 ")x\" + bbbbbb);", 10256 getGoogleStyleWithColumns(20))); 10257 EXPECT_EQ("fffffffffff(\n" 10258 " R\"x(\n" 10259 "multiline raw string literal xxxxxxxxxxxxxx\n" 10260 ")x\" +\n" 10261 " bbbbbb);", 10262 format("fffffffffff(\n" 10263 " R\"x(\n" 10264 "multiline raw string literal xxxxxxxxxxxxxx\n" 10265 ")x\" + bbbbbb);", 10266 getGoogleStyleWithColumns(20))); 10267 EXPECT_EQ("fffffffffff(R\"(single line raw string)\" + bbbbbb);", 10268 format("fffffffffff(\n" 10269 " R\"(single line raw string)\" + bbbbbb);")); 10270 } 10271 10272 TEST_F(FormatTest, SkipsUnknownStringLiterals) { 10273 verifyFormat("string a = \"unterminated;"); 10274 EXPECT_EQ("function(\"unterminated,\n" 10275 " OtherParameter);", 10276 format("function( \"unterminated,\n" 10277 " OtherParameter);")); 10278 } 10279 10280 TEST_F(FormatTest, DoesNotTryToParseUDLiteralsInPreCpp11Code) { 10281 FormatStyle Style = getLLVMStyle(); 10282 Style.Standard = FormatStyle::LS_Cpp03; 10283 EXPECT_EQ("#define x(_a) printf(\"foo\" _a);", 10284 format("#define x(_a) printf(\"foo\"_a);", Style)); 10285 } 10286 10287 TEST_F(FormatTest, CppLexVersion) { 10288 FormatStyle Style = getLLVMStyle(); 10289 // Formatting of x * y differs if x is a type. 10290 verifyFormat("void foo() { MACRO(a * b); }", Style); 10291 verifyFormat("void foo() { MACRO(int *b); }", Style); 10292 10293 // LLVM style uses latest lexer. 10294 verifyFormat("void foo() { MACRO(char8_t *b); }", Style); 10295 Style.Standard = FormatStyle::LS_Cpp17; 10296 // But in c++17, char8_t isn't a keyword. 10297 verifyFormat("void foo() { MACRO(char8_t * b); }", Style); 10298 } 10299 10300 TEST_F(FormatTest, UnderstandsCpp1y) { verifyFormat("int bi{1'000'000};"); } 10301 10302 TEST_F(FormatTest, BreakStringLiteralsBeforeUnbreakableTokenSequence) { 10303 EXPECT_EQ("someFunction(\"aaabbbcccd\"\n" 10304 " \"ddeeefff\");", 10305 format("someFunction(\"aaabbbcccdddeeefff\");", 10306 getLLVMStyleWithColumns(25))); 10307 EXPECT_EQ("someFunction1234567890(\n" 10308 " \"aaabbbcccdddeeefff\");", 10309 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 10310 getLLVMStyleWithColumns(26))); 10311 EXPECT_EQ("someFunction1234567890(\n" 10312 " \"aaabbbcccdddeeeff\"\n" 10313 " \"f\");", 10314 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 10315 getLLVMStyleWithColumns(25))); 10316 EXPECT_EQ("someFunction1234567890(\n" 10317 " \"aaabbbcccdddeeeff\"\n" 10318 " \"f\");", 10319 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 10320 getLLVMStyleWithColumns(24))); 10321 EXPECT_EQ("someFunction(\n" 10322 " \"aaabbbcc ddde \"\n" 10323 " \"efff\");", 10324 format("someFunction(\"aaabbbcc ddde efff\");", 10325 getLLVMStyleWithColumns(25))); 10326 EXPECT_EQ("someFunction(\"aaabbbccc \"\n" 10327 " \"ddeeefff\");", 10328 format("someFunction(\"aaabbbccc ddeeefff\");", 10329 getLLVMStyleWithColumns(25))); 10330 EXPECT_EQ("someFunction1234567890(\n" 10331 " \"aaabb \"\n" 10332 " \"cccdddeeefff\");", 10333 format("someFunction1234567890(\"aaabb cccdddeeefff\");", 10334 getLLVMStyleWithColumns(25))); 10335 EXPECT_EQ("#define A \\\n" 10336 " string s = \\\n" 10337 " \"123456789\" \\\n" 10338 " \"0\"; \\\n" 10339 " int i;", 10340 format("#define A string s = \"1234567890\"; int i;", 10341 getLLVMStyleWithColumns(20))); 10342 EXPECT_EQ("someFunction(\n" 10343 " \"aaabbbcc \"\n" 10344 " \"dddeeefff\");", 10345 format("someFunction(\"aaabbbcc dddeeefff\");", 10346 getLLVMStyleWithColumns(25))); 10347 } 10348 10349 TEST_F(FormatTest, DoNotBreakStringLiteralsInEscapeSequence) { 10350 EXPECT_EQ("\"\\a\"", format("\"\\a\"", getLLVMStyleWithColumns(3))); 10351 EXPECT_EQ("\"\\\"", format("\"\\\"", getLLVMStyleWithColumns(2))); 10352 EXPECT_EQ("\"test\"\n" 10353 "\"\\n\"", 10354 format("\"test\\n\"", getLLVMStyleWithColumns(7))); 10355 EXPECT_EQ("\"tes\\\\\"\n" 10356 "\"n\"", 10357 format("\"tes\\\\n\"", getLLVMStyleWithColumns(7))); 10358 EXPECT_EQ("\"\\\\\\\\\"\n" 10359 "\"\\n\"", 10360 format("\"\\\\\\\\\\n\"", getLLVMStyleWithColumns(7))); 10361 EXPECT_EQ("\"\\uff01\"", format("\"\\uff01\"", getLLVMStyleWithColumns(7))); 10362 EXPECT_EQ("\"\\uff01\"\n" 10363 "\"test\"", 10364 format("\"\\uff01test\"", getLLVMStyleWithColumns(8))); 10365 EXPECT_EQ("\"\\Uff01ff02\"", 10366 format("\"\\Uff01ff02\"", getLLVMStyleWithColumns(11))); 10367 EXPECT_EQ("\"\\x000000000001\"\n" 10368 "\"next\"", 10369 format("\"\\x000000000001next\"", getLLVMStyleWithColumns(16))); 10370 EXPECT_EQ("\"\\x000000000001next\"", 10371 format("\"\\x000000000001next\"", getLLVMStyleWithColumns(15))); 10372 EXPECT_EQ("\"\\x000000000001\"", 10373 format("\"\\x000000000001\"", getLLVMStyleWithColumns(7))); 10374 EXPECT_EQ("\"test\"\n" 10375 "\"\\000000\"\n" 10376 "\"000001\"", 10377 format("\"test\\000000000001\"", getLLVMStyleWithColumns(9))); 10378 EXPECT_EQ("\"test\\000\"\n" 10379 "\"00000000\"\n" 10380 "\"1\"", 10381 format("\"test\\000000000001\"", getLLVMStyleWithColumns(10))); 10382 } 10383 10384 TEST_F(FormatTest, DoNotCreateUnreasonableUnwrappedLines) { 10385 verifyFormat("void f() {\n" 10386 " return g() {}\n" 10387 " void h() {}"); 10388 verifyFormat("int a[] = {void forgot_closing_brace(){f();\n" 10389 "g();\n" 10390 "}"); 10391 } 10392 10393 TEST_F(FormatTest, DoNotPrematurelyEndUnwrappedLineForReturnStatements) { 10394 verifyFormat( 10395 "void f() { return C{param1, param2}.SomeCall(param1, param2); }"); 10396 } 10397 10398 TEST_F(FormatTest, FormatsClosingBracesInEmptyNestedBlocks) { 10399 verifyFormat("class X {\n" 10400 " void f() {\n" 10401 " }\n" 10402 "};", 10403 getLLVMStyleWithColumns(12)); 10404 } 10405 10406 TEST_F(FormatTest, ConfigurableIndentWidth) { 10407 FormatStyle EightIndent = getLLVMStyleWithColumns(18); 10408 EightIndent.IndentWidth = 8; 10409 EightIndent.ContinuationIndentWidth = 8; 10410 verifyFormat("void f() {\n" 10411 " someFunction();\n" 10412 " if (true) {\n" 10413 " f();\n" 10414 " }\n" 10415 "}", 10416 EightIndent); 10417 verifyFormat("class X {\n" 10418 " void f() {\n" 10419 " }\n" 10420 "};", 10421 EightIndent); 10422 verifyFormat("int x[] = {\n" 10423 " call(),\n" 10424 " call()};", 10425 EightIndent); 10426 } 10427 10428 TEST_F(FormatTest, ConfigurableFunctionDeclarationIndentAfterType) { 10429 verifyFormat("double\n" 10430 "f();", 10431 getLLVMStyleWithColumns(8)); 10432 } 10433 10434 TEST_F(FormatTest, ConfigurableUseOfTab) { 10435 FormatStyle Tab = getLLVMStyleWithColumns(42); 10436 Tab.IndentWidth = 8; 10437 Tab.UseTab = FormatStyle::UT_Always; 10438 Tab.AlignEscapedNewlines = FormatStyle::ENAS_Left; 10439 10440 EXPECT_EQ("if (aaaaaaaa && // q\n" 10441 " bb)\t\t// w\n" 10442 "\t;", 10443 format("if (aaaaaaaa &&// q\n" 10444 "bb)// w\n" 10445 ";", 10446 Tab)); 10447 EXPECT_EQ("if (aaa && bbb) // w\n" 10448 "\t;", 10449 format("if(aaa&&bbb)// w\n" 10450 ";", 10451 Tab)); 10452 10453 verifyFormat("class X {\n" 10454 "\tvoid f() {\n" 10455 "\t\tsomeFunction(parameter1,\n" 10456 "\t\t\t parameter2);\n" 10457 "\t}\n" 10458 "};", 10459 Tab); 10460 verifyFormat("#define A \\\n" 10461 "\tvoid f() { \\\n" 10462 "\t\tsomeFunction( \\\n" 10463 "\t\t parameter1, \\\n" 10464 "\t\t parameter2); \\\n" 10465 "\t}", 10466 Tab); 10467 verifyFormat("int a;\t // x\n" 10468 "int bbbbbbbb; // x\n", 10469 Tab); 10470 10471 Tab.TabWidth = 4; 10472 Tab.IndentWidth = 8; 10473 verifyFormat("class TabWidth4Indent8 {\n" 10474 "\t\tvoid f() {\n" 10475 "\t\t\t\tsomeFunction(parameter1,\n" 10476 "\t\t\t\t\t\t\t parameter2);\n" 10477 "\t\t}\n" 10478 "};", 10479 Tab); 10480 10481 Tab.TabWidth = 4; 10482 Tab.IndentWidth = 4; 10483 verifyFormat("class TabWidth4Indent4 {\n" 10484 "\tvoid f() {\n" 10485 "\t\tsomeFunction(parameter1,\n" 10486 "\t\t\t\t\t parameter2);\n" 10487 "\t}\n" 10488 "};", 10489 Tab); 10490 10491 Tab.TabWidth = 8; 10492 Tab.IndentWidth = 4; 10493 verifyFormat("class TabWidth8Indent4 {\n" 10494 " void f() {\n" 10495 "\tsomeFunction(parameter1,\n" 10496 "\t\t parameter2);\n" 10497 " }\n" 10498 "};", 10499 Tab); 10500 10501 Tab.TabWidth = 8; 10502 Tab.IndentWidth = 8; 10503 EXPECT_EQ("/*\n" 10504 "\t a\t\tcomment\n" 10505 "\t in multiple lines\n" 10506 " */", 10507 format(" /*\t \t \n" 10508 " \t \t a\t\tcomment\t \t\n" 10509 " \t \t in multiple lines\t\n" 10510 " \t */", 10511 Tab)); 10512 10513 Tab.UseTab = FormatStyle::UT_ForIndentation; 10514 verifyFormat("{\n" 10515 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10516 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10517 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10518 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10519 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10520 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10521 "};", 10522 Tab); 10523 verifyFormat("enum AA {\n" 10524 "\ta1, // Force multiple lines\n" 10525 "\ta2,\n" 10526 "\ta3\n" 10527 "};", 10528 Tab); 10529 EXPECT_EQ("if (aaaaaaaa && // q\n" 10530 " bb) // w\n" 10531 "\t;", 10532 format("if (aaaaaaaa &&// q\n" 10533 "bb)// w\n" 10534 ";", 10535 Tab)); 10536 verifyFormat("class X {\n" 10537 "\tvoid f() {\n" 10538 "\t\tsomeFunction(parameter1,\n" 10539 "\t\t parameter2);\n" 10540 "\t}\n" 10541 "};", 10542 Tab); 10543 verifyFormat("{\n" 10544 "\tQ(\n" 10545 "\t {\n" 10546 "\t\t int a;\n" 10547 "\t\t someFunction(aaaaaaaa,\n" 10548 "\t\t bbbbbbb);\n" 10549 "\t },\n" 10550 "\t p);\n" 10551 "}", 10552 Tab); 10553 EXPECT_EQ("{\n" 10554 "\t/* aaaa\n" 10555 "\t bbbb */\n" 10556 "}", 10557 format("{\n" 10558 "/* aaaa\n" 10559 " bbbb */\n" 10560 "}", 10561 Tab)); 10562 EXPECT_EQ("{\n" 10563 "\t/*\n" 10564 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10565 "\t bbbbbbbbbbbbb\n" 10566 "\t*/\n" 10567 "}", 10568 format("{\n" 10569 "/*\n" 10570 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10571 "*/\n" 10572 "}", 10573 Tab)); 10574 EXPECT_EQ("{\n" 10575 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10576 "\t// bbbbbbbbbbbbb\n" 10577 "}", 10578 format("{\n" 10579 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10580 "}", 10581 Tab)); 10582 EXPECT_EQ("{\n" 10583 "\t/*\n" 10584 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10585 "\t bbbbbbbbbbbbb\n" 10586 "\t*/\n" 10587 "}", 10588 format("{\n" 10589 "\t/*\n" 10590 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10591 "\t*/\n" 10592 "}", 10593 Tab)); 10594 EXPECT_EQ("{\n" 10595 "\t/*\n" 10596 "\n" 10597 "\t*/\n" 10598 "}", 10599 format("{\n" 10600 "\t/*\n" 10601 "\n" 10602 "\t*/\n" 10603 "}", 10604 Tab)); 10605 EXPECT_EQ("{\n" 10606 "\t/*\n" 10607 " asdf\n" 10608 "\t*/\n" 10609 "}", 10610 format("{\n" 10611 "\t/*\n" 10612 " asdf\n" 10613 "\t*/\n" 10614 "}", 10615 Tab)); 10616 10617 Tab.UseTab = FormatStyle::UT_Never; 10618 EXPECT_EQ("/*\n" 10619 " a\t\tcomment\n" 10620 " in multiple lines\n" 10621 " */", 10622 format(" /*\t \t \n" 10623 " \t \t a\t\tcomment\t \t\n" 10624 " \t \t in multiple lines\t\n" 10625 " \t */", 10626 Tab)); 10627 EXPECT_EQ("/* some\n" 10628 " comment */", 10629 format(" \t \t /* some\n" 10630 " \t \t comment */", 10631 Tab)); 10632 EXPECT_EQ("int a; /* some\n" 10633 " comment */", 10634 format(" \t \t int a; /* some\n" 10635 " \t \t comment */", 10636 Tab)); 10637 10638 EXPECT_EQ("int a; /* some\n" 10639 "comment */", 10640 format(" \t \t int\ta; /* some\n" 10641 " \t \t comment */", 10642 Tab)); 10643 EXPECT_EQ("f(\"\t\t\"); /* some\n" 10644 " comment */", 10645 format(" \t \t f(\"\t\t\"); /* some\n" 10646 " \t \t comment */", 10647 Tab)); 10648 EXPECT_EQ("{\n" 10649 " /*\n" 10650 " * Comment\n" 10651 " */\n" 10652 " int i;\n" 10653 "}", 10654 format("{\n" 10655 "\t/*\n" 10656 "\t * Comment\n" 10657 "\t */\n" 10658 "\t int i;\n" 10659 "}", 10660 Tab)); 10661 10662 Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation; 10663 Tab.TabWidth = 8; 10664 Tab.IndentWidth = 8; 10665 EXPECT_EQ("if (aaaaaaaa && // q\n" 10666 " bb) // w\n" 10667 "\t;", 10668 format("if (aaaaaaaa &&// q\n" 10669 "bb)// w\n" 10670 ";", 10671 Tab)); 10672 EXPECT_EQ("if (aaa && bbb) // w\n" 10673 "\t;", 10674 format("if(aaa&&bbb)// w\n" 10675 ";", 10676 Tab)); 10677 verifyFormat("class X {\n" 10678 "\tvoid f() {\n" 10679 "\t\tsomeFunction(parameter1,\n" 10680 "\t\t\t parameter2);\n" 10681 "\t}\n" 10682 "};", 10683 Tab); 10684 verifyFormat("#define A \\\n" 10685 "\tvoid f() { \\\n" 10686 "\t\tsomeFunction( \\\n" 10687 "\t\t parameter1, \\\n" 10688 "\t\t parameter2); \\\n" 10689 "\t}", 10690 Tab); 10691 Tab.TabWidth = 4; 10692 Tab.IndentWidth = 8; 10693 verifyFormat("class TabWidth4Indent8 {\n" 10694 "\t\tvoid f() {\n" 10695 "\t\t\t\tsomeFunction(parameter1,\n" 10696 "\t\t\t\t\t\t\t parameter2);\n" 10697 "\t\t}\n" 10698 "};", 10699 Tab); 10700 Tab.TabWidth = 4; 10701 Tab.IndentWidth = 4; 10702 verifyFormat("class TabWidth4Indent4 {\n" 10703 "\tvoid f() {\n" 10704 "\t\tsomeFunction(parameter1,\n" 10705 "\t\t\t\t\t parameter2);\n" 10706 "\t}\n" 10707 "};", 10708 Tab); 10709 Tab.TabWidth = 8; 10710 Tab.IndentWidth = 4; 10711 verifyFormat("class TabWidth8Indent4 {\n" 10712 " void f() {\n" 10713 "\tsomeFunction(parameter1,\n" 10714 "\t\t parameter2);\n" 10715 " }\n" 10716 "};", 10717 Tab); 10718 Tab.TabWidth = 8; 10719 Tab.IndentWidth = 8; 10720 EXPECT_EQ("/*\n" 10721 "\t a\t\tcomment\n" 10722 "\t in multiple lines\n" 10723 " */", 10724 format(" /*\t \t \n" 10725 " \t \t a\t\tcomment\t \t\n" 10726 " \t \t in multiple lines\t\n" 10727 " \t */", 10728 Tab)); 10729 verifyFormat("{\n" 10730 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10731 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10732 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10733 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10734 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10735 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10736 "};", 10737 Tab); 10738 verifyFormat("enum AA {\n" 10739 "\ta1, // Force multiple lines\n" 10740 "\ta2,\n" 10741 "\ta3\n" 10742 "};", 10743 Tab); 10744 EXPECT_EQ("if (aaaaaaaa && // q\n" 10745 " bb) // w\n" 10746 "\t;", 10747 format("if (aaaaaaaa &&// q\n" 10748 "bb)// w\n" 10749 ";", 10750 Tab)); 10751 verifyFormat("class X {\n" 10752 "\tvoid f() {\n" 10753 "\t\tsomeFunction(parameter1,\n" 10754 "\t\t\t parameter2);\n" 10755 "\t}\n" 10756 "};", 10757 Tab); 10758 verifyFormat("{\n" 10759 "\tQ(\n" 10760 "\t {\n" 10761 "\t\t int a;\n" 10762 "\t\t someFunction(aaaaaaaa,\n" 10763 "\t\t\t\t bbbbbbb);\n" 10764 "\t },\n" 10765 "\t p);\n" 10766 "}", 10767 Tab); 10768 EXPECT_EQ("{\n" 10769 "\t/* aaaa\n" 10770 "\t bbbb */\n" 10771 "}", 10772 format("{\n" 10773 "/* aaaa\n" 10774 " bbbb */\n" 10775 "}", 10776 Tab)); 10777 EXPECT_EQ("{\n" 10778 "\t/*\n" 10779 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10780 "\t bbbbbbbbbbbbb\n" 10781 "\t*/\n" 10782 "}", 10783 format("{\n" 10784 "/*\n" 10785 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10786 "*/\n" 10787 "}", 10788 Tab)); 10789 EXPECT_EQ("{\n" 10790 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10791 "\t// bbbbbbbbbbbbb\n" 10792 "}", 10793 format("{\n" 10794 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10795 "}", 10796 Tab)); 10797 EXPECT_EQ("{\n" 10798 "\t/*\n" 10799 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10800 "\t bbbbbbbbbbbbb\n" 10801 "\t*/\n" 10802 "}", 10803 format("{\n" 10804 "\t/*\n" 10805 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10806 "\t*/\n" 10807 "}", 10808 Tab)); 10809 EXPECT_EQ("{\n" 10810 "\t/*\n" 10811 "\n" 10812 "\t*/\n" 10813 "}", 10814 format("{\n" 10815 "\t/*\n" 10816 "\n" 10817 "\t*/\n" 10818 "}", 10819 Tab)); 10820 EXPECT_EQ("{\n" 10821 "\t/*\n" 10822 " asdf\n" 10823 "\t*/\n" 10824 "}", 10825 format("{\n" 10826 "\t/*\n" 10827 " asdf\n" 10828 "\t*/\n" 10829 "}", 10830 Tab)); 10831 EXPECT_EQ("/* some\n" 10832 " comment */", 10833 format(" \t \t /* some\n" 10834 " \t \t comment */", 10835 Tab)); 10836 EXPECT_EQ("int a; /* some\n" 10837 " comment */", 10838 format(" \t \t int a; /* some\n" 10839 " \t \t comment */", 10840 Tab)); 10841 EXPECT_EQ("int a; /* some\n" 10842 "comment */", 10843 format(" \t \t int\ta; /* some\n" 10844 " \t \t comment */", 10845 Tab)); 10846 EXPECT_EQ("f(\"\t\t\"); /* some\n" 10847 " comment */", 10848 format(" \t \t f(\"\t\t\"); /* some\n" 10849 " \t \t comment */", 10850 Tab)); 10851 EXPECT_EQ("{\n" 10852 "\t/*\n" 10853 "\t * Comment\n" 10854 "\t */\n" 10855 "\tint i;\n" 10856 "}", 10857 format("{\n" 10858 "\t/*\n" 10859 "\t * Comment\n" 10860 "\t */\n" 10861 "\t int i;\n" 10862 "}", 10863 Tab)); 10864 Tab.TabWidth = 2; 10865 Tab.IndentWidth = 2; 10866 EXPECT_EQ("{\n" 10867 "\t/* aaaa\n" 10868 "\t\t bbbb */\n" 10869 "}", 10870 format("{\n" 10871 "/* aaaa\n" 10872 "\t bbbb */\n" 10873 "}", 10874 Tab)); 10875 EXPECT_EQ("{\n" 10876 "\t/*\n" 10877 "\t\taaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10878 "\t\tbbbbbbbbbbbbb\n" 10879 "\t*/\n" 10880 "}", 10881 format("{\n" 10882 "/*\n" 10883 "\taaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10884 "*/\n" 10885 "}", 10886 Tab)); 10887 Tab.AlignConsecutiveAssignments = true; 10888 Tab.AlignConsecutiveDeclarations = true; 10889 Tab.TabWidth = 4; 10890 Tab.IndentWidth = 4; 10891 verifyFormat("class Assign {\n" 10892 "\tvoid f() {\n" 10893 "\t\tint x = 123;\n" 10894 "\t\tint random = 4;\n" 10895 "\t\tstd::string alphabet =\n" 10896 "\t\t\t\"abcdefghijklmnopqrstuvwxyz\";\n" 10897 "\t}\n" 10898 "};", 10899 Tab); 10900 10901 Tab.UseTab = FormatStyle::UT_AlignWithSpaces; 10902 Tab.TabWidth = 8; 10903 Tab.IndentWidth = 8; 10904 EXPECT_EQ("if (aaaaaaaa && // q\n" 10905 " bb) // w\n" 10906 "\t;", 10907 format("if (aaaaaaaa &&// q\n" 10908 "bb)// w\n" 10909 ";", 10910 Tab)); 10911 EXPECT_EQ("if (aaa && bbb) // w\n" 10912 "\t;", 10913 format("if(aaa&&bbb)// w\n" 10914 ";", 10915 Tab)); 10916 verifyFormat("class X {\n" 10917 "\tvoid f() {\n" 10918 "\t\tsomeFunction(parameter1,\n" 10919 "\t\t parameter2);\n" 10920 "\t}\n" 10921 "};", 10922 Tab); 10923 verifyFormat("#define A \\\n" 10924 "\tvoid f() { \\\n" 10925 "\t\tsomeFunction( \\\n" 10926 "\t\t parameter1, \\\n" 10927 "\t\t parameter2); \\\n" 10928 "\t}", 10929 Tab); 10930 Tab.TabWidth = 4; 10931 Tab.IndentWidth = 8; 10932 verifyFormat("class TabWidth4Indent8 {\n" 10933 "\t\tvoid f() {\n" 10934 "\t\t\t\tsomeFunction(parameter1,\n" 10935 "\t\t\t\t parameter2);\n" 10936 "\t\t}\n" 10937 "};", 10938 Tab); 10939 Tab.TabWidth = 4; 10940 Tab.IndentWidth = 4; 10941 verifyFormat("class TabWidth4Indent4 {\n" 10942 "\tvoid f() {\n" 10943 "\t\tsomeFunction(parameter1,\n" 10944 "\t\t parameter2);\n" 10945 "\t}\n" 10946 "};", 10947 Tab); 10948 Tab.TabWidth = 8; 10949 Tab.IndentWidth = 4; 10950 verifyFormat("class TabWidth8Indent4 {\n" 10951 " void f() {\n" 10952 "\tsomeFunction(parameter1,\n" 10953 "\t parameter2);\n" 10954 " }\n" 10955 "};", 10956 Tab); 10957 Tab.TabWidth = 8; 10958 Tab.IndentWidth = 8; 10959 EXPECT_EQ("/*\n" 10960 " a\t\tcomment\n" 10961 " in multiple lines\n" 10962 " */", 10963 format(" /*\t \t \n" 10964 " \t \t a\t\tcomment\t \t\n" 10965 " \t \t in multiple lines\t\n" 10966 " \t */", 10967 Tab)); 10968 verifyFormat("{\n" 10969 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10970 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10971 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10972 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10973 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10974 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10975 "};", 10976 Tab); 10977 verifyFormat("enum AA {\n" 10978 "\ta1, // Force multiple lines\n" 10979 "\ta2,\n" 10980 "\ta3\n" 10981 "};", 10982 Tab); 10983 EXPECT_EQ("if (aaaaaaaa && // q\n" 10984 " bb) // w\n" 10985 "\t;", 10986 format("if (aaaaaaaa &&// q\n" 10987 "bb)// w\n" 10988 ";", 10989 Tab)); 10990 verifyFormat("class X {\n" 10991 "\tvoid f() {\n" 10992 "\t\tsomeFunction(parameter1,\n" 10993 "\t\t parameter2);\n" 10994 "\t}\n" 10995 "};", 10996 Tab); 10997 verifyFormat("{\n" 10998 "\tQ(\n" 10999 "\t {\n" 11000 "\t\t int a;\n" 11001 "\t\t someFunction(aaaaaaaa,\n" 11002 "\t\t bbbbbbb);\n" 11003 "\t },\n" 11004 "\t p);\n" 11005 "}", 11006 Tab); 11007 EXPECT_EQ("{\n" 11008 "\t/* aaaa\n" 11009 "\t bbbb */\n" 11010 "}", 11011 format("{\n" 11012 "/* aaaa\n" 11013 " bbbb */\n" 11014 "}", 11015 Tab)); 11016 EXPECT_EQ("{\n" 11017 "\t/*\n" 11018 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 11019 "\t bbbbbbbbbbbbb\n" 11020 "\t*/\n" 11021 "}", 11022 format("{\n" 11023 "/*\n" 11024 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 11025 "*/\n" 11026 "}", 11027 Tab)); 11028 EXPECT_EQ("{\n" 11029 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 11030 "\t// bbbbbbbbbbbbb\n" 11031 "}", 11032 format("{\n" 11033 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 11034 "}", 11035 Tab)); 11036 EXPECT_EQ("{\n" 11037 "\t/*\n" 11038 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 11039 "\t bbbbbbbbbbbbb\n" 11040 "\t*/\n" 11041 "}", 11042 format("{\n" 11043 "\t/*\n" 11044 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 11045 "\t*/\n" 11046 "}", 11047 Tab)); 11048 EXPECT_EQ("{\n" 11049 "\t/*\n" 11050 "\n" 11051 "\t*/\n" 11052 "}", 11053 format("{\n" 11054 "\t/*\n" 11055 "\n" 11056 "\t*/\n" 11057 "}", 11058 Tab)); 11059 EXPECT_EQ("{\n" 11060 "\t/*\n" 11061 " asdf\n" 11062 "\t*/\n" 11063 "}", 11064 format("{\n" 11065 "\t/*\n" 11066 " asdf\n" 11067 "\t*/\n" 11068 "}", 11069 Tab)); 11070 EXPECT_EQ("/* some\n" 11071 " comment */", 11072 format(" \t \t /* some\n" 11073 " \t \t comment */", 11074 Tab)); 11075 EXPECT_EQ("int a; /* some\n" 11076 " comment */", 11077 format(" \t \t int a; /* some\n" 11078 " \t \t comment */", 11079 Tab)); 11080 EXPECT_EQ("int a; /* some\n" 11081 "comment */", 11082 format(" \t \t int\ta; /* some\n" 11083 " \t \t comment */", 11084 Tab)); 11085 EXPECT_EQ("f(\"\t\t\"); /* some\n" 11086 " comment */", 11087 format(" \t \t f(\"\t\t\"); /* some\n" 11088 " \t \t comment */", 11089 Tab)); 11090 EXPECT_EQ("{\n" 11091 "\t/*\n" 11092 "\t * Comment\n" 11093 "\t */\n" 11094 "\tint i;\n" 11095 "}", 11096 format("{\n" 11097 "\t/*\n" 11098 "\t * Comment\n" 11099 "\t */\n" 11100 "\t int i;\n" 11101 "}", 11102 Tab)); 11103 Tab.TabWidth = 2; 11104 Tab.IndentWidth = 2; 11105 EXPECT_EQ("{\n" 11106 "\t/* aaaa\n" 11107 "\t bbbb */\n" 11108 "}", 11109 format("{\n" 11110 "/* aaaa\n" 11111 " bbbb */\n" 11112 "}", 11113 Tab)); 11114 EXPECT_EQ("{\n" 11115 "\t/*\n" 11116 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 11117 "\t bbbbbbbbbbbbb\n" 11118 "\t*/\n" 11119 "}", 11120 format("{\n" 11121 "/*\n" 11122 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 11123 "*/\n" 11124 "}", 11125 Tab)); 11126 Tab.AlignConsecutiveAssignments = true; 11127 Tab.AlignConsecutiveDeclarations = true; 11128 Tab.TabWidth = 4; 11129 Tab.IndentWidth = 4; 11130 verifyFormat("class Assign {\n" 11131 "\tvoid f() {\n" 11132 "\t\tint x = 123;\n" 11133 "\t\tint random = 4;\n" 11134 "\t\tstd::string alphabet =\n" 11135 "\t\t\t\"abcdefghijklmnopqrstuvwxyz\";\n" 11136 "\t}\n" 11137 "};", 11138 Tab); 11139 } 11140 11141 TEST_F(FormatTest, ZeroTabWidth) { 11142 FormatStyle Tab = getLLVMStyleWithColumns(42); 11143 Tab.IndentWidth = 8; 11144 Tab.UseTab = FormatStyle::UT_Never; 11145 Tab.TabWidth = 0; 11146 EXPECT_EQ("void a(){\n" 11147 " // line starts with '\t'\n" 11148 "};", 11149 format("void a(){\n" 11150 "\t// line starts with '\t'\n" 11151 "};", 11152 Tab)); 11153 11154 EXPECT_EQ("void a(){\n" 11155 " // line starts with '\t'\n" 11156 "};", 11157 format("void a(){\n" 11158 "\t\t// line starts with '\t'\n" 11159 "};", 11160 Tab)); 11161 11162 Tab.UseTab = FormatStyle::UT_ForIndentation; 11163 EXPECT_EQ("void a(){\n" 11164 " // line starts with '\t'\n" 11165 "};", 11166 format("void a(){\n" 11167 "\t// line starts with '\t'\n" 11168 "};", 11169 Tab)); 11170 11171 EXPECT_EQ("void a(){\n" 11172 " // line starts with '\t'\n" 11173 "};", 11174 format("void a(){\n" 11175 "\t\t// line starts with '\t'\n" 11176 "};", 11177 Tab)); 11178 11179 Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation; 11180 EXPECT_EQ("void a(){\n" 11181 " // line starts with '\t'\n" 11182 "};", 11183 format("void a(){\n" 11184 "\t// line starts with '\t'\n" 11185 "};", 11186 Tab)); 11187 11188 EXPECT_EQ("void a(){\n" 11189 " // line starts with '\t'\n" 11190 "};", 11191 format("void a(){\n" 11192 "\t\t// line starts with '\t'\n" 11193 "};", 11194 Tab)); 11195 11196 Tab.UseTab = FormatStyle::UT_AlignWithSpaces; 11197 EXPECT_EQ("void a(){\n" 11198 " // line starts with '\t'\n" 11199 "};", 11200 format("void a(){\n" 11201 "\t// line starts with '\t'\n" 11202 "};", 11203 Tab)); 11204 11205 EXPECT_EQ("void a(){\n" 11206 " // line starts with '\t'\n" 11207 "};", 11208 format("void a(){\n" 11209 "\t\t// line starts with '\t'\n" 11210 "};", 11211 Tab)); 11212 11213 Tab.UseTab = FormatStyle::UT_Always; 11214 EXPECT_EQ("void a(){\n" 11215 "// line starts with '\t'\n" 11216 "};", 11217 format("void a(){\n" 11218 "\t// line starts with '\t'\n" 11219 "};", 11220 Tab)); 11221 11222 EXPECT_EQ("void a(){\n" 11223 "// line starts with '\t'\n" 11224 "};", 11225 format("void a(){\n" 11226 "\t\t// line starts with '\t'\n" 11227 "};", 11228 Tab)); 11229 } 11230 11231 TEST_F(FormatTest, CalculatesOriginalColumn) { 11232 EXPECT_EQ("\"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 11233 "q\"; /* some\n" 11234 " comment */", 11235 format(" \"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 11236 "q\"; /* some\n" 11237 " comment */", 11238 getLLVMStyle())); 11239 EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n" 11240 "/* some\n" 11241 " comment */", 11242 format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n" 11243 " /* some\n" 11244 " comment */", 11245 getLLVMStyle())); 11246 EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 11247 "qqq\n" 11248 "/* some\n" 11249 " comment */", 11250 format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 11251 "qqq\n" 11252 " /* some\n" 11253 " comment */", 11254 getLLVMStyle())); 11255 EXPECT_EQ("inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 11256 "wwww; /* some\n" 11257 " comment */", 11258 format(" inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 11259 "wwww; /* some\n" 11260 " comment */", 11261 getLLVMStyle())); 11262 } 11263 11264 TEST_F(FormatTest, ConfigurableSpaceBeforeParens) { 11265 FormatStyle NoSpace = getLLVMStyle(); 11266 NoSpace.SpaceBeforeParens = FormatStyle::SBPO_Never; 11267 11268 verifyFormat("while(true)\n" 11269 " continue;", 11270 NoSpace); 11271 verifyFormat("for(;;)\n" 11272 " continue;", 11273 NoSpace); 11274 verifyFormat("if(true)\n" 11275 " f();\n" 11276 "else if(true)\n" 11277 " f();", 11278 NoSpace); 11279 verifyFormat("do {\n" 11280 " do_something();\n" 11281 "} while(something());", 11282 NoSpace); 11283 verifyFormat("switch(x) {\n" 11284 "default:\n" 11285 " break;\n" 11286 "}", 11287 NoSpace); 11288 verifyFormat("auto i = std::make_unique<int>(5);", NoSpace); 11289 verifyFormat("size_t x = sizeof(x);", NoSpace); 11290 verifyFormat("auto f(int x) -> decltype(x);", NoSpace); 11291 verifyFormat("int f(T x) noexcept(x.create());", NoSpace); 11292 verifyFormat("alignas(128) char a[128];", NoSpace); 11293 verifyFormat("size_t x = alignof(MyType);", NoSpace); 11294 verifyFormat("static_assert(sizeof(char) == 1, \"Impossible!\");", NoSpace); 11295 verifyFormat("int f() throw(Deprecated);", NoSpace); 11296 verifyFormat("typedef void (*cb)(int);", NoSpace); 11297 verifyFormat("T A::operator()();", NoSpace); 11298 verifyFormat("X A::operator++(T);", NoSpace); 11299 verifyFormat("auto lambda = []() { return 0; };", NoSpace); 11300 11301 FormatStyle Space = getLLVMStyle(); 11302 Space.SpaceBeforeParens = FormatStyle::SBPO_Always; 11303 11304 verifyFormat("int f ();", Space); 11305 verifyFormat("void f (int a, T b) {\n" 11306 " while (true)\n" 11307 " continue;\n" 11308 "}", 11309 Space); 11310 verifyFormat("if (true)\n" 11311 " f ();\n" 11312 "else if (true)\n" 11313 " f ();", 11314 Space); 11315 verifyFormat("do {\n" 11316 " do_something ();\n" 11317 "} while (something ());", 11318 Space); 11319 verifyFormat("switch (x) {\n" 11320 "default:\n" 11321 " break;\n" 11322 "}", 11323 Space); 11324 verifyFormat("A::A () : a (1) {}", Space); 11325 verifyFormat("void f () __attribute__ ((asdf));", Space); 11326 verifyFormat("*(&a + 1);\n" 11327 "&((&a)[1]);\n" 11328 "a[(b + c) * d];\n" 11329 "(((a + 1) * 2) + 3) * 4;", 11330 Space); 11331 verifyFormat("#define A(x) x", Space); 11332 verifyFormat("#define A (x) x", Space); 11333 verifyFormat("#if defined(x)\n" 11334 "#endif", 11335 Space); 11336 verifyFormat("auto i = std::make_unique<int> (5);", Space); 11337 verifyFormat("size_t x = sizeof (x);", Space); 11338 verifyFormat("auto f (int x) -> decltype (x);", Space); 11339 verifyFormat("int f (T x) noexcept (x.create ());", Space); 11340 verifyFormat("alignas (128) char a[128];", Space); 11341 verifyFormat("size_t x = alignof (MyType);", Space); 11342 verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");", Space); 11343 verifyFormat("int f () throw (Deprecated);", Space); 11344 verifyFormat("typedef void (*cb) (int);", Space); 11345 verifyFormat("T A::operator() ();", Space); 11346 verifyFormat("X A::operator++ (T);", Space); 11347 verifyFormat("auto lambda = [] () { return 0; };", Space); 11348 verifyFormat("int x = int (y);", Space); 11349 11350 FormatStyle SomeSpace = getLLVMStyle(); 11351 SomeSpace.SpaceBeforeParens = FormatStyle::SBPO_NonEmptyParentheses; 11352 11353 verifyFormat("[]() -> float {}", SomeSpace); 11354 verifyFormat("[] (auto foo) {}", SomeSpace); 11355 verifyFormat("[foo]() -> int {}", SomeSpace); 11356 verifyFormat("int f();", SomeSpace); 11357 verifyFormat("void f (int a, T b) {\n" 11358 " while (true)\n" 11359 " continue;\n" 11360 "}", 11361 SomeSpace); 11362 verifyFormat("if (true)\n" 11363 " f();\n" 11364 "else if (true)\n" 11365 " f();", 11366 SomeSpace); 11367 verifyFormat("do {\n" 11368 " do_something();\n" 11369 "} while (something());", 11370 SomeSpace); 11371 verifyFormat("switch (x) {\n" 11372 "default:\n" 11373 " break;\n" 11374 "}", 11375 SomeSpace); 11376 verifyFormat("A::A() : a (1) {}", SomeSpace); 11377 verifyFormat("void f() __attribute__ ((asdf));", SomeSpace); 11378 verifyFormat("*(&a + 1);\n" 11379 "&((&a)[1]);\n" 11380 "a[(b + c) * d];\n" 11381 "(((a + 1) * 2) + 3) * 4;", 11382 SomeSpace); 11383 verifyFormat("#define A(x) x", SomeSpace); 11384 verifyFormat("#define A (x) x", SomeSpace); 11385 verifyFormat("#if defined(x)\n" 11386 "#endif", 11387 SomeSpace); 11388 verifyFormat("auto i = std::make_unique<int> (5);", SomeSpace); 11389 verifyFormat("size_t x = sizeof (x);", SomeSpace); 11390 verifyFormat("auto f (int x) -> decltype (x);", SomeSpace); 11391 verifyFormat("int f (T x) noexcept (x.create());", SomeSpace); 11392 verifyFormat("alignas (128) char a[128];", SomeSpace); 11393 verifyFormat("size_t x = alignof (MyType);", SomeSpace); 11394 verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");", 11395 SomeSpace); 11396 verifyFormat("int f() throw (Deprecated);", SomeSpace); 11397 verifyFormat("typedef void (*cb) (int);", SomeSpace); 11398 verifyFormat("T A::operator()();", SomeSpace); 11399 verifyFormat("X A::operator++ (T);", SomeSpace); 11400 verifyFormat("int x = int (y);", SomeSpace); 11401 verifyFormat("auto lambda = []() { return 0; };", SomeSpace); 11402 } 11403 11404 TEST_F(FormatTest, SpaceAfterLogicalNot) { 11405 FormatStyle Spaces = getLLVMStyle(); 11406 Spaces.SpaceAfterLogicalNot = true; 11407 11408 verifyFormat("bool x = ! y", Spaces); 11409 verifyFormat("if (! isFailure())", Spaces); 11410 verifyFormat("if (! (a && b))", Spaces); 11411 verifyFormat("\"Error!\"", Spaces); 11412 verifyFormat("! ! x", Spaces); 11413 } 11414 11415 TEST_F(FormatTest, ConfigurableSpacesInParentheses) { 11416 FormatStyle Spaces = getLLVMStyle(); 11417 11418 Spaces.SpacesInParentheses = true; 11419 verifyFormat("do_something( ::globalVar );", Spaces); 11420 verifyFormat("call( x, y, z );", Spaces); 11421 verifyFormat("call();", Spaces); 11422 verifyFormat("std::function<void( int, int )> callback;", Spaces); 11423 verifyFormat("void inFunction() { std::function<void( int, int )> fct; }", 11424 Spaces); 11425 verifyFormat("while ( (bool)1 )\n" 11426 " continue;", 11427 Spaces); 11428 verifyFormat("for ( ;; )\n" 11429 " continue;", 11430 Spaces); 11431 verifyFormat("if ( true )\n" 11432 " f();\n" 11433 "else if ( true )\n" 11434 " f();", 11435 Spaces); 11436 verifyFormat("do {\n" 11437 " do_something( (int)i );\n" 11438 "} while ( something() );", 11439 Spaces); 11440 verifyFormat("switch ( x ) {\n" 11441 "default:\n" 11442 " break;\n" 11443 "}", 11444 Spaces); 11445 11446 Spaces.SpacesInParentheses = false; 11447 Spaces.SpacesInCStyleCastParentheses = true; 11448 verifyFormat("Type *A = ( Type * )P;", Spaces); 11449 verifyFormat("Type *A = ( vector<Type *, int *> )P;", Spaces); 11450 verifyFormat("x = ( int32 )y;", Spaces); 11451 verifyFormat("int a = ( int )(2.0f);", Spaces); 11452 verifyFormat("#define AA(X) sizeof((( X * )NULL)->a)", Spaces); 11453 verifyFormat("my_int a = ( my_int )sizeof(int);", Spaces); 11454 verifyFormat("#define x (( int )-1)", Spaces); 11455 11456 // Run the first set of tests again with: 11457 Spaces.SpacesInParentheses = false; 11458 Spaces.SpaceInEmptyParentheses = true; 11459 Spaces.SpacesInCStyleCastParentheses = true; 11460 verifyFormat("call(x, y, z);", Spaces); 11461 verifyFormat("call( );", Spaces); 11462 verifyFormat("std::function<void(int, int)> callback;", Spaces); 11463 verifyFormat("while (( bool )1)\n" 11464 " continue;", 11465 Spaces); 11466 verifyFormat("for (;;)\n" 11467 " continue;", 11468 Spaces); 11469 verifyFormat("if (true)\n" 11470 " f( );\n" 11471 "else if (true)\n" 11472 " f( );", 11473 Spaces); 11474 verifyFormat("do {\n" 11475 " do_something(( int )i);\n" 11476 "} while (something( ));", 11477 Spaces); 11478 verifyFormat("switch (x) {\n" 11479 "default:\n" 11480 " break;\n" 11481 "}", 11482 Spaces); 11483 11484 // Run the first set of tests again with: 11485 Spaces.SpaceAfterCStyleCast = true; 11486 verifyFormat("call(x, y, z);", Spaces); 11487 verifyFormat("call( );", Spaces); 11488 verifyFormat("std::function<void(int, int)> callback;", Spaces); 11489 verifyFormat("while (( bool ) 1)\n" 11490 " continue;", 11491 Spaces); 11492 verifyFormat("for (;;)\n" 11493 " continue;", 11494 Spaces); 11495 verifyFormat("if (true)\n" 11496 " f( );\n" 11497 "else if (true)\n" 11498 " f( );", 11499 Spaces); 11500 verifyFormat("do {\n" 11501 " do_something(( int ) i);\n" 11502 "} while (something( ));", 11503 Spaces); 11504 verifyFormat("switch (x) {\n" 11505 "default:\n" 11506 " break;\n" 11507 "}", 11508 Spaces); 11509 11510 // Run subset of tests again with: 11511 Spaces.SpacesInCStyleCastParentheses = false; 11512 Spaces.SpaceAfterCStyleCast = true; 11513 verifyFormat("while ((bool) 1)\n" 11514 " continue;", 11515 Spaces); 11516 verifyFormat("do {\n" 11517 " do_something((int) i);\n" 11518 "} while (something( ));", 11519 Spaces); 11520 } 11521 11522 TEST_F(FormatTest, ConfigurableSpacesInSquareBrackets) { 11523 verifyFormat("int a[5];"); 11524 verifyFormat("a[3] += 42;"); 11525 11526 FormatStyle Spaces = getLLVMStyle(); 11527 Spaces.SpacesInSquareBrackets = true; 11528 // Not lambdas. 11529 verifyFormat("int a[ 5 ];", Spaces); 11530 verifyFormat("a[ 3 ] += 42;", Spaces); 11531 verifyFormat("constexpr char hello[]{\"hello\"};", Spaces); 11532 verifyFormat("double &operator[](int i) { return 0; }\n" 11533 "int i;", 11534 Spaces); 11535 verifyFormat("std::unique_ptr<int[]> foo() {}", Spaces); 11536 verifyFormat("int i = a[ a ][ a ]->f();", Spaces); 11537 verifyFormat("int i = (*b)[ a ]->f();", Spaces); 11538 // Lambdas. 11539 verifyFormat("int c = []() -> int { return 2; }();\n", Spaces); 11540 verifyFormat("return [ i, args... ] {};", Spaces); 11541 verifyFormat("int foo = [ &bar ]() {};", Spaces); 11542 verifyFormat("int foo = [ = ]() {};", Spaces); 11543 verifyFormat("int foo = [ & ]() {};", Spaces); 11544 verifyFormat("int foo = [ =, &bar ]() {};", Spaces); 11545 verifyFormat("int foo = [ &bar, = ]() {};", Spaces); 11546 } 11547 11548 TEST_F(FormatTest, ConfigurableSpaceBeforeBrackets) { 11549 FormatStyle NoSpaceStyle = getLLVMStyle(); 11550 verifyFormat("int a[5];", NoSpaceStyle); 11551 verifyFormat("a[3] += 42;", NoSpaceStyle); 11552 11553 verifyFormat("int a[1];", NoSpaceStyle); 11554 verifyFormat("int 1 [a];", NoSpaceStyle); 11555 verifyFormat("int a[1][2];", NoSpaceStyle); 11556 verifyFormat("a[7] = 5;", NoSpaceStyle); 11557 verifyFormat("int a = (f())[23];", NoSpaceStyle); 11558 verifyFormat("f([] {})", NoSpaceStyle); 11559 11560 FormatStyle Space = getLLVMStyle(); 11561 Space.SpaceBeforeSquareBrackets = true; 11562 verifyFormat("int c = []() -> int { return 2; }();\n", Space); 11563 verifyFormat("return [i, args...] {};", Space); 11564 11565 verifyFormat("int a [5];", Space); 11566 verifyFormat("a [3] += 42;", Space); 11567 verifyFormat("constexpr char hello []{\"hello\"};", Space); 11568 verifyFormat("double &operator[](int i) { return 0; }\n" 11569 "int i;", 11570 Space); 11571 verifyFormat("std::unique_ptr<int []> foo() {}", Space); 11572 verifyFormat("int i = a [a][a]->f();", Space); 11573 verifyFormat("int i = (*b) [a]->f();", Space); 11574 11575 verifyFormat("int a [1];", Space); 11576 verifyFormat("int 1 [a];", Space); 11577 verifyFormat("int a [1][2];", Space); 11578 verifyFormat("a [7] = 5;", Space); 11579 verifyFormat("int a = (f()) [23];", Space); 11580 verifyFormat("f([] {})", Space); 11581 } 11582 11583 TEST_F(FormatTest, ConfigurableSpaceBeforeAssignmentOperators) { 11584 verifyFormat("int a = 5;"); 11585 verifyFormat("a += 42;"); 11586 verifyFormat("a or_eq 8;"); 11587 11588 FormatStyle Spaces = getLLVMStyle(); 11589 Spaces.SpaceBeforeAssignmentOperators = false; 11590 verifyFormat("int a= 5;", Spaces); 11591 verifyFormat("a+= 42;", Spaces); 11592 verifyFormat("a or_eq 8;", Spaces); 11593 } 11594 11595 TEST_F(FormatTest, ConfigurableSpaceBeforeColon) { 11596 verifyFormat("class Foo : public Bar {};"); 11597 verifyFormat("Foo::Foo() : foo(1) {}"); 11598 verifyFormat("for (auto a : b) {\n}"); 11599 verifyFormat("int x = a ? b : c;"); 11600 verifyFormat("{\n" 11601 "label0:\n" 11602 " int x = 0;\n" 11603 "}"); 11604 verifyFormat("switch (x) {\n" 11605 "case 1:\n" 11606 "default:\n" 11607 "}"); 11608 11609 FormatStyle CtorInitializerStyle = getLLVMStyleWithColumns(30); 11610 CtorInitializerStyle.SpaceBeforeCtorInitializerColon = false; 11611 verifyFormat("class Foo : public Bar {};", CtorInitializerStyle); 11612 verifyFormat("Foo::Foo(): foo(1) {}", CtorInitializerStyle); 11613 verifyFormat("for (auto a : b) {\n}", CtorInitializerStyle); 11614 verifyFormat("int x = a ? b : c;", CtorInitializerStyle); 11615 verifyFormat("{\n" 11616 "label1:\n" 11617 " int x = 0;\n" 11618 "}", 11619 CtorInitializerStyle); 11620 verifyFormat("switch (x) {\n" 11621 "case 1:\n" 11622 "default:\n" 11623 "}", 11624 CtorInitializerStyle); 11625 CtorInitializerStyle.BreakConstructorInitializers = 11626 FormatStyle::BCIS_AfterColon; 11627 verifyFormat("Fooooooooooo::Fooooooooooo():\n" 11628 " aaaaaaaaaaaaaaaa(1),\n" 11629 " bbbbbbbbbbbbbbbb(2) {}", 11630 CtorInitializerStyle); 11631 CtorInitializerStyle.BreakConstructorInitializers = 11632 FormatStyle::BCIS_BeforeComma; 11633 verifyFormat("Fooooooooooo::Fooooooooooo()\n" 11634 " : aaaaaaaaaaaaaaaa(1)\n" 11635 " , bbbbbbbbbbbbbbbb(2) {}", 11636 CtorInitializerStyle); 11637 CtorInitializerStyle.BreakConstructorInitializers = 11638 FormatStyle::BCIS_BeforeColon; 11639 verifyFormat("Fooooooooooo::Fooooooooooo()\n" 11640 " : aaaaaaaaaaaaaaaa(1),\n" 11641 " bbbbbbbbbbbbbbbb(2) {}", 11642 CtorInitializerStyle); 11643 CtorInitializerStyle.ConstructorInitializerIndentWidth = 0; 11644 verifyFormat("Fooooooooooo::Fooooooooooo()\n" 11645 ": aaaaaaaaaaaaaaaa(1),\n" 11646 " bbbbbbbbbbbbbbbb(2) {}", 11647 CtorInitializerStyle); 11648 11649 FormatStyle InheritanceStyle = getLLVMStyleWithColumns(30); 11650 InheritanceStyle.SpaceBeforeInheritanceColon = false; 11651 verifyFormat("class Foo: public Bar {};", InheritanceStyle); 11652 verifyFormat("Foo::Foo() : foo(1) {}", InheritanceStyle); 11653 verifyFormat("for (auto a : b) {\n}", InheritanceStyle); 11654 verifyFormat("int x = a ? b : c;", InheritanceStyle); 11655 verifyFormat("{\n" 11656 "label2:\n" 11657 " int x = 0;\n" 11658 "}", 11659 InheritanceStyle); 11660 verifyFormat("switch (x) {\n" 11661 "case 1:\n" 11662 "default:\n" 11663 "}", 11664 InheritanceStyle); 11665 InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_AfterColon; 11666 verifyFormat("class Foooooooooooooooooooooo:\n" 11667 " public aaaaaaaaaaaaaaaaaa,\n" 11668 " public bbbbbbbbbbbbbbbbbb {\n" 11669 "}", 11670 InheritanceStyle); 11671 InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeComma; 11672 verifyFormat("class Foooooooooooooooooooooo\n" 11673 " : public aaaaaaaaaaaaaaaaaa\n" 11674 " , public bbbbbbbbbbbbbbbbbb {\n" 11675 "}", 11676 InheritanceStyle); 11677 InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeColon; 11678 verifyFormat("class Foooooooooooooooooooooo\n" 11679 " : public aaaaaaaaaaaaaaaaaa,\n" 11680 " public bbbbbbbbbbbbbbbbbb {\n" 11681 "}", 11682 InheritanceStyle); 11683 InheritanceStyle.ConstructorInitializerIndentWidth = 0; 11684 verifyFormat("class Foooooooooooooooooooooo\n" 11685 ": public aaaaaaaaaaaaaaaaaa,\n" 11686 " public bbbbbbbbbbbbbbbbbb {}", 11687 InheritanceStyle); 11688 11689 FormatStyle ForLoopStyle = getLLVMStyle(); 11690 ForLoopStyle.SpaceBeforeRangeBasedForLoopColon = false; 11691 verifyFormat("class Foo : public Bar {};", ForLoopStyle); 11692 verifyFormat("Foo::Foo() : foo(1) {}", ForLoopStyle); 11693 verifyFormat("for (auto a: b) {\n}", ForLoopStyle); 11694 verifyFormat("int x = a ? b : c;", ForLoopStyle); 11695 verifyFormat("{\n" 11696 "label2:\n" 11697 " int x = 0;\n" 11698 "}", 11699 ForLoopStyle); 11700 verifyFormat("switch (x) {\n" 11701 "case 1:\n" 11702 "default:\n" 11703 "}", 11704 ForLoopStyle); 11705 11706 FormatStyle NoSpaceStyle = getLLVMStyle(); 11707 NoSpaceStyle.SpaceBeforeCtorInitializerColon = false; 11708 NoSpaceStyle.SpaceBeforeInheritanceColon = false; 11709 NoSpaceStyle.SpaceBeforeRangeBasedForLoopColon = false; 11710 verifyFormat("class Foo: public Bar {};", NoSpaceStyle); 11711 verifyFormat("Foo::Foo(): foo(1) {}", NoSpaceStyle); 11712 verifyFormat("for (auto a: b) {\n}", NoSpaceStyle); 11713 verifyFormat("int x = a ? b : c;", NoSpaceStyle); 11714 verifyFormat("{\n" 11715 "label3:\n" 11716 " int x = 0;\n" 11717 "}", 11718 NoSpaceStyle); 11719 verifyFormat("switch (x) {\n" 11720 "case 1:\n" 11721 "default:\n" 11722 "}", 11723 NoSpaceStyle); 11724 } 11725 11726 TEST_F(FormatTest, AlignConsecutiveMacros) { 11727 FormatStyle Style = getLLVMStyle(); 11728 Style.AlignConsecutiveAssignments = true; 11729 Style.AlignConsecutiveDeclarations = true; 11730 Style.AlignConsecutiveMacros = false; 11731 11732 verifyFormat("#define a 3\n" 11733 "#define bbbb 4\n" 11734 "#define ccc (5)", 11735 Style); 11736 11737 verifyFormat("#define f(x) (x * x)\n" 11738 "#define fff(x, y, z) (x * y + z)\n" 11739 "#define ffff(x, y) (x - y)", 11740 Style); 11741 11742 verifyFormat("#define foo(x, y) (x + y)\n" 11743 "#define bar (5, 6)(2 + 2)", 11744 Style); 11745 11746 verifyFormat("#define a 3\n" 11747 "#define bbbb 4\n" 11748 "#define ccc (5)\n" 11749 "#define f(x) (x * x)\n" 11750 "#define fff(x, y, z) (x * y + z)\n" 11751 "#define ffff(x, y) (x - y)", 11752 Style); 11753 11754 Style.AlignConsecutiveMacros = true; 11755 verifyFormat("#define a 3\n" 11756 "#define bbbb 4\n" 11757 "#define ccc (5)", 11758 Style); 11759 11760 verifyFormat("#define f(x) (x * x)\n" 11761 "#define fff(x, y, z) (x * y + z)\n" 11762 "#define ffff(x, y) (x - y)", 11763 Style); 11764 11765 verifyFormat("#define foo(x, y) (x + y)\n" 11766 "#define bar (5, 6)(2 + 2)", 11767 Style); 11768 11769 verifyFormat("#define a 3\n" 11770 "#define bbbb 4\n" 11771 "#define ccc (5)\n" 11772 "#define f(x) (x * x)\n" 11773 "#define fff(x, y, z) (x * y + z)\n" 11774 "#define ffff(x, y) (x - y)", 11775 Style); 11776 11777 verifyFormat("#define a 5\n" 11778 "#define foo(x, y) (x + y)\n" 11779 "#define CCC (6)\n" 11780 "auto lambda = []() {\n" 11781 " auto ii = 0;\n" 11782 " float j = 0;\n" 11783 " return 0;\n" 11784 "};\n" 11785 "int i = 0;\n" 11786 "float i2 = 0;\n" 11787 "auto v = type{\n" 11788 " i = 1, //\n" 11789 " (i = 2), //\n" 11790 " i = 3 //\n" 11791 "};", 11792 Style); 11793 11794 Style.AlignConsecutiveMacros = false; 11795 Style.ColumnLimit = 20; 11796 11797 verifyFormat("#define a \\\n" 11798 " \"aabbbbbbbbbbbb\"\n" 11799 "#define D \\\n" 11800 " \"aabbbbbbbbbbbb\" \\\n" 11801 " \"ccddeeeeeeeee\"\n" 11802 "#define B \\\n" 11803 " \"QQQQQQQQQQQQQ\" \\\n" 11804 " \"FFFFFFFFFFFFF\" \\\n" 11805 " \"LLLLLLLL\"\n", 11806 Style); 11807 11808 Style.AlignConsecutiveMacros = true; 11809 verifyFormat("#define a \\\n" 11810 " \"aabbbbbbbbbbbb\"\n" 11811 "#define D \\\n" 11812 " \"aabbbbbbbbbbbb\" \\\n" 11813 " \"ccddeeeeeeeee\"\n" 11814 "#define B \\\n" 11815 " \"QQQQQQQQQQQQQ\" \\\n" 11816 " \"FFFFFFFFFFFFF\" \\\n" 11817 " \"LLLLLLLL\"\n", 11818 Style); 11819 } 11820 11821 TEST_F(FormatTest, AlignConsecutiveAssignments) { 11822 FormatStyle Alignment = getLLVMStyle(); 11823 Alignment.AlignConsecutiveMacros = true; 11824 Alignment.AlignConsecutiveAssignments = false; 11825 verifyFormat("int a = 5;\n" 11826 "int oneTwoThree = 123;", 11827 Alignment); 11828 verifyFormat("int a = 5;\n" 11829 "int oneTwoThree = 123;", 11830 Alignment); 11831 11832 Alignment.AlignConsecutiveAssignments = true; 11833 verifyFormat("int a = 5;\n" 11834 "int oneTwoThree = 123;", 11835 Alignment); 11836 verifyFormat("int a = method();\n" 11837 "int oneTwoThree = 133;", 11838 Alignment); 11839 verifyFormat("a &= 5;\n" 11840 "bcd *= 5;\n" 11841 "ghtyf += 5;\n" 11842 "dvfvdb -= 5;\n" 11843 "a /= 5;\n" 11844 "vdsvsv %= 5;\n" 11845 "sfdbddfbdfbb ^= 5;\n" 11846 "dvsdsv |= 5;\n" 11847 "int dsvvdvsdvvv = 123;", 11848 Alignment); 11849 verifyFormat("int i = 1, j = 10;\n" 11850 "something = 2000;", 11851 Alignment); 11852 verifyFormat("something = 2000;\n" 11853 "int i = 1, j = 10;\n", 11854 Alignment); 11855 verifyFormat("something = 2000;\n" 11856 "another = 911;\n" 11857 "int i = 1, j = 10;\n" 11858 "oneMore = 1;\n" 11859 "i = 2;", 11860 Alignment); 11861 verifyFormat("int a = 5;\n" 11862 "int one = 1;\n" 11863 "method();\n" 11864 "int oneTwoThree = 123;\n" 11865 "int oneTwo = 12;", 11866 Alignment); 11867 verifyFormat("int oneTwoThree = 123;\n" 11868 "int oneTwo = 12;\n" 11869 "method();\n", 11870 Alignment); 11871 verifyFormat("int oneTwoThree = 123; // comment\n" 11872 "int oneTwo = 12; // comment", 11873 Alignment); 11874 11875 // Bug 25167 11876 verifyFormat("#if A\n" 11877 "#else\n" 11878 "int aaaaaaaa = 12;\n" 11879 "#endif\n" 11880 "#if B\n" 11881 "#else\n" 11882 "int a = 12;\n" 11883 "#endif\n", 11884 Alignment); 11885 verifyFormat("enum foo {\n" 11886 "#if A\n" 11887 "#else\n" 11888 " aaaaaaaa = 12;\n" 11889 "#endif\n" 11890 "#if B\n" 11891 "#else\n" 11892 " a = 12;\n" 11893 "#endif\n" 11894 "};\n", 11895 Alignment); 11896 11897 EXPECT_EQ("int a = 5;\n" 11898 "\n" 11899 "int oneTwoThree = 123;", 11900 format("int a = 5;\n" 11901 "\n" 11902 "int oneTwoThree= 123;", 11903 Alignment)); 11904 EXPECT_EQ("int a = 5;\n" 11905 "int one = 1;\n" 11906 "\n" 11907 "int oneTwoThree = 123;", 11908 format("int a = 5;\n" 11909 "int one = 1;\n" 11910 "\n" 11911 "int oneTwoThree = 123;", 11912 Alignment)); 11913 EXPECT_EQ("int a = 5;\n" 11914 "int one = 1;\n" 11915 "\n" 11916 "int oneTwoThree = 123;\n" 11917 "int oneTwo = 12;", 11918 format("int a = 5;\n" 11919 "int one = 1;\n" 11920 "\n" 11921 "int oneTwoThree = 123;\n" 11922 "int oneTwo = 12;", 11923 Alignment)); 11924 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign; 11925 verifyFormat("#define A \\\n" 11926 " int aaaa = 12; \\\n" 11927 " int b = 23; \\\n" 11928 " int ccc = 234; \\\n" 11929 " int dddddddddd = 2345;", 11930 Alignment); 11931 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left; 11932 verifyFormat("#define A \\\n" 11933 " int aaaa = 12; \\\n" 11934 " int b = 23; \\\n" 11935 " int ccc = 234; \\\n" 11936 " int dddddddddd = 2345;", 11937 Alignment); 11938 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right; 11939 verifyFormat("#define A " 11940 " \\\n" 11941 " int aaaa = 12; " 11942 " \\\n" 11943 " int b = 23; " 11944 " \\\n" 11945 " int ccc = 234; " 11946 " \\\n" 11947 " int dddddddddd = 2345;", 11948 Alignment); 11949 verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int " 11950 "k = 4, int l = 5,\n" 11951 " int m = 6) {\n" 11952 " int j = 10;\n" 11953 " otherThing = 1;\n" 11954 "}", 11955 Alignment); 11956 verifyFormat("void SomeFunction(int parameter = 0) {\n" 11957 " int i = 1;\n" 11958 " int j = 2;\n" 11959 " int big = 10000;\n" 11960 "}", 11961 Alignment); 11962 verifyFormat("class C {\n" 11963 "public:\n" 11964 " int i = 1;\n" 11965 " virtual void f() = 0;\n" 11966 "};", 11967 Alignment); 11968 verifyFormat("int i = 1;\n" 11969 "if (SomeType t = getSomething()) {\n" 11970 "}\n" 11971 "int j = 2;\n" 11972 "int big = 10000;", 11973 Alignment); 11974 verifyFormat("int j = 7;\n" 11975 "for (int k = 0; k < N; ++k) {\n" 11976 "}\n" 11977 "int j = 2;\n" 11978 "int big = 10000;\n" 11979 "}", 11980 Alignment); 11981 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 11982 verifyFormat("int i = 1;\n" 11983 "LooooooooooongType loooooooooooooooooooooongVariable\n" 11984 " = someLooooooooooooooooongFunction();\n" 11985 "int j = 2;", 11986 Alignment); 11987 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 11988 verifyFormat("int i = 1;\n" 11989 "LooooooooooongType loooooooooooooooooooooongVariable =\n" 11990 " someLooooooooooooooooongFunction();\n" 11991 "int j = 2;", 11992 Alignment); 11993 11994 verifyFormat("auto lambda = []() {\n" 11995 " auto i = 0;\n" 11996 " return 0;\n" 11997 "};\n" 11998 "int i = 0;\n" 11999 "auto v = type{\n" 12000 " i = 1, //\n" 12001 " (i = 2), //\n" 12002 " i = 3 //\n" 12003 "};", 12004 Alignment); 12005 12006 verifyFormat( 12007 "int i = 1;\n" 12008 "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n" 12009 " loooooooooooooooooooooongParameterB);\n" 12010 "int j = 2;", 12011 Alignment); 12012 12013 verifyFormat("template <typename T, typename T_0 = very_long_type_name_0,\n" 12014 " typename B = very_long_type_name_1,\n" 12015 " typename T_2 = very_long_type_name_2>\n" 12016 "auto foo() {}\n", 12017 Alignment); 12018 verifyFormat("int a, b = 1;\n" 12019 "int c = 2;\n" 12020 "int dd = 3;\n", 12021 Alignment); 12022 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n" 12023 "float b[1][] = {{3.f}};\n", 12024 Alignment); 12025 verifyFormat("for (int i = 0; i < 1; i++)\n" 12026 " int x = 1;\n", 12027 Alignment); 12028 verifyFormat("for (i = 0; i < 1; i++)\n" 12029 " x = 1;\n" 12030 "y = 1;\n", 12031 Alignment); 12032 12033 Alignment.ReflowComments = true; 12034 Alignment.ColumnLimit = 50; 12035 EXPECT_EQ("int x = 0;\n" 12036 "int yy = 1; /// specificlennospace\n" 12037 "int zzz = 2;\n", 12038 format("int x = 0;\n" 12039 "int yy = 1; ///specificlennospace\n" 12040 "int zzz = 2;\n", 12041 Alignment)); 12042 } 12043 12044 TEST_F(FormatTest, AlignConsecutiveBitFields) { 12045 FormatStyle Alignment = getLLVMStyle(); 12046 Alignment.AlignConsecutiveBitFields = true; 12047 verifyFormat("int const a : 5;\n" 12048 "int oneTwoThree : 23;", 12049 Alignment); 12050 12051 // Initializers are allowed starting with c++2a 12052 verifyFormat("int const a : 5 = 1;\n" 12053 "int oneTwoThree : 23 = 0;", 12054 Alignment); 12055 12056 Alignment.AlignConsecutiveDeclarations = true; 12057 verifyFormat("int const a : 5;\n" 12058 "int oneTwoThree : 23;", 12059 Alignment); 12060 12061 verifyFormat("int const a : 5; // comment\n" 12062 "int oneTwoThree : 23; // comment", 12063 Alignment); 12064 12065 verifyFormat("int const a : 5 = 1;\n" 12066 "int oneTwoThree : 23 = 0;", 12067 Alignment); 12068 12069 Alignment.AlignConsecutiveAssignments = true; 12070 verifyFormat("int const a : 5 = 1;\n" 12071 "int oneTwoThree : 23 = 0;", 12072 Alignment); 12073 verifyFormat("int const a : 5 = {1};\n" 12074 "int oneTwoThree : 23 = 0;", 12075 Alignment); 12076 12077 // Known limitations: ':' is only recognized as a bitfield colon when 12078 // followed by a number. 12079 /* 12080 verifyFormat("int oneTwoThree : SOME_CONSTANT;\n" 12081 "int a : 5;", 12082 Alignment); 12083 */ 12084 } 12085 12086 TEST_F(FormatTest, AlignConsecutiveDeclarations) { 12087 FormatStyle Alignment = getLLVMStyle(); 12088 Alignment.AlignConsecutiveMacros = true; 12089 Alignment.AlignConsecutiveDeclarations = false; 12090 verifyFormat("float const a = 5;\n" 12091 "int oneTwoThree = 123;", 12092 Alignment); 12093 verifyFormat("int a = 5;\n" 12094 "float const oneTwoThree = 123;", 12095 Alignment); 12096 12097 Alignment.AlignConsecutiveDeclarations = true; 12098 verifyFormat("float const a = 5;\n" 12099 "int oneTwoThree = 123;", 12100 Alignment); 12101 verifyFormat("int a = method();\n" 12102 "float const oneTwoThree = 133;", 12103 Alignment); 12104 verifyFormat("int i = 1, j = 10;\n" 12105 "something = 2000;", 12106 Alignment); 12107 verifyFormat("something = 2000;\n" 12108 "int i = 1, j = 10;\n", 12109 Alignment); 12110 verifyFormat("float something = 2000;\n" 12111 "double another = 911;\n" 12112 "int i = 1, j = 10;\n" 12113 "const int *oneMore = 1;\n" 12114 "unsigned i = 2;", 12115 Alignment); 12116 verifyFormat("float a = 5;\n" 12117 "int one = 1;\n" 12118 "method();\n" 12119 "const double oneTwoThree = 123;\n" 12120 "const unsigned int oneTwo = 12;", 12121 Alignment); 12122 verifyFormat("int oneTwoThree{0}; // comment\n" 12123 "unsigned oneTwo; // comment", 12124 Alignment); 12125 EXPECT_EQ("float const a = 5;\n" 12126 "\n" 12127 "int oneTwoThree = 123;", 12128 format("float const a = 5;\n" 12129 "\n" 12130 "int oneTwoThree= 123;", 12131 Alignment)); 12132 EXPECT_EQ("float a = 5;\n" 12133 "int one = 1;\n" 12134 "\n" 12135 "unsigned oneTwoThree = 123;", 12136 format("float a = 5;\n" 12137 "int one = 1;\n" 12138 "\n" 12139 "unsigned oneTwoThree = 123;", 12140 Alignment)); 12141 EXPECT_EQ("float a = 5;\n" 12142 "int one = 1;\n" 12143 "\n" 12144 "unsigned oneTwoThree = 123;\n" 12145 "int oneTwo = 12;", 12146 format("float a = 5;\n" 12147 "int one = 1;\n" 12148 "\n" 12149 "unsigned oneTwoThree = 123;\n" 12150 "int oneTwo = 12;", 12151 Alignment)); 12152 // Function prototype alignment 12153 verifyFormat("int a();\n" 12154 "double b();", 12155 Alignment); 12156 verifyFormat("int a(int x);\n" 12157 "double b();", 12158 Alignment); 12159 unsigned OldColumnLimit = Alignment.ColumnLimit; 12160 // We need to set ColumnLimit to zero, in order to stress nested alignments, 12161 // otherwise the function parameters will be re-flowed onto a single line. 12162 Alignment.ColumnLimit = 0; 12163 EXPECT_EQ("int a(int x,\n" 12164 " float y);\n" 12165 "double b(int x,\n" 12166 " double y);", 12167 format("int a(int x,\n" 12168 " float y);\n" 12169 "double b(int x,\n" 12170 " double y);", 12171 Alignment)); 12172 // This ensures that function parameters of function declarations are 12173 // correctly indented when their owning functions are indented. 12174 // The failure case here is for 'double y' to not be indented enough. 12175 EXPECT_EQ("double a(int x);\n" 12176 "int b(int y,\n" 12177 " double z);", 12178 format("double a(int x);\n" 12179 "int b(int y,\n" 12180 " double z);", 12181 Alignment)); 12182 // Set ColumnLimit low so that we induce wrapping immediately after 12183 // the function name and opening paren. 12184 Alignment.ColumnLimit = 13; 12185 verifyFormat("int function(\n" 12186 " int x,\n" 12187 " bool y);", 12188 Alignment); 12189 Alignment.ColumnLimit = OldColumnLimit; 12190 // Ensure function pointers don't screw up recursive alignment 12191 verifyFormat("int a(int x, void (*fp)(int y));\n" 12192 "double b();", 12193 Alignment); 12194 Alignment.AlignConsecutiveAssignments = true; 12195 // Ensure recursive alignment is broken by function braces, so that the 12196 // "a = 1" does not align with subsequent assignments inside the function 12197 // body. 12198 verifyFormat("int func(int a = 1) {\n" 12199 " int b = 2;\n" 12200 " int cc = 3;\n" 12201 "}", 12202 Alignment); 12203 verifyFormat("float something = 2000;\n" 12204 "double another = 911;\n" 12205 "int i = 1, j = 10;\n" 12206 "const int *oneMore = 1;\n" 12207 "unsigned i = 2;", 12208 Alignment); 12209 verifyFormat("int oneTwoThree = {0}; // comment\n" 12210 "unsigned oneTwo = 0; // comment", 12211 Alignment); 12212 // Make sure that scope is correctly tracked, in the absence of braces 12213 verifyFormat("for (int i = 0; i < n; i++)\n" 12214 " j = i;\n" 12215 "double x = 1;\n", 12216 Alignment); 12217 verifyFormat("if (int i = 0)\n" 12218 " j = i;\n" 12219 "double x = 1;\n", 12220 Alignment); 12221 // Ensure operator[] and operator() are comprehended 12222 verifyFormat("struct test {\n" 12223 " long long int foo();\n" 12224 " int operator[](int a);\n" 12225 " double bar();\n" 12226 "};\n", 12227 Alignment); 12228 verifyFormat("struct test {\n" 12229 " long long int foo();\n" 12230 " int operator()(int a);\n" 12231 " double bar();\n" 12232 "};\n", 12233 Alignment); 12234 EXPECT_EQ("void SomeFunction(int parameter = 0) {\n" 12235 " int const i = 1;\n" 12236 " int * j = 2;\n" 12237 " int big = 10000;\n" 12238 "\n" 12239 " unsigned oneTwoThree = 123;\n" 12240 " int oneTwo = 12;\n" 12241 " method();\n" 12242 " float k = 2;\n" 12243 " int ll = 10000;\n" 12244 "}", 12245 format("void SomeFunction(int parameter= 0) {\n" 12246 " int const i= 1;\n" 12247 " int *j=2;\n" 12248 " int big = 10000;\n" 12249 "\n" 12250 "unsigned oneTwoThree =123;\n" 12251 "int oneTwo = 12;\n" 12252 " method();\n" 12253 "float k= 2;\n" 12254 "int ll=10000;\n" 12255 "}", 12256 Alignment)); 12257 Alignment.AlignConsecutiveAssignments = false; 12258 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign; 12259 verifyFormat("#define A \\\n" 12260 " int aaaa = 12; \\\n" 12261 " float b = 23; \\\n" 12262 " const int ccc = 234; \\\n" 12263 " unsigned dddddddddd = 2345;", 12264 Alignment); 12265 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left; 12266 verifyFormat("#define A \\\n" 12267 " int aaaa = 12; \\\n" 12268 " float b = 23; \\\n" 12269 " const int ccc = 234; \\\n" 12270 " unsigned dddddddddd = 2345;", 12271 Alignment); 12272 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right; 12273 Alignment.ColumnLimit = 30; 12274 verifyFormat("#define A \\\n" 12275 " int aaaa = 12; \\\n" 12276 " float b = 23; \\\n" 12277 " const int ccc = 234; \\\n" 12278 " int dddddddddd = 2345;", 12279 Alignment); 12280 Alignment.ColumnLimit = 80; 12281 verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int " 12282 "k = 4, int l = 5,\n" 12283 " int m = 6) {\n" 12284 " const int j = 10;\n" 12285 " otherThing = 1;\n" 12286 "}", 12287 Alignment); 12288 verifyFormat("void SomeFunction(int parameter = 0) {\n" 12289 " int const i = 1;\n" 12290 " int * j = 2;\n" 12291 " int big = 10000;\n" 12292 "}", 12293 Alignment); 12294 verifyFormat("class C {\n" 12295 "public:\n" 12296 " int i = 1;\n" 12297 " virtual void f() = 0;\n" 12298 "};", 12299 Alignment); 12300 verifyFormat("float i = 1;\n" 12301 "if (SomeType t = getSomething()) {\n" 12302 "}\n" 12303 "const unsigned j = 2;\n" 12304 "int big = 10000;", 12305 Alignment); 12306 verifyFormat("float j = 7;\n" 12307 "for (int k = 0; k < N; ++k) {\n" 12308 "}\n" 12309 "unsigned j = 2;\n" 12310 "int big = 10000;\n" 12311 "}", 12312 Alignment); 12313 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 12314 verifyFormat("float i = 1;\n" 12315 "LooooooooooongType loooooooooooooooooooooongVariable\n" 12316 " = someLooooooooooooooooongFunction();\n" 12317 "int j = 2;", 12318 Alignment); 12319 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 12320 verifyFormat("int i = 1;\n" 12321 "LooooooooooongType loooooooooooooooooooooongVariable =\n" 12322 " someLooooooooooooooooongFunction();\n" 12323 "int j = 2;", 12324 Alignment); 12325 12326 Alignment.AlignConsecutiveAssignments = true; 12327 verifyFormat("auto lambda = []() {\n" 12328 " auto ii = 0;\n" 12329 " float j = 0;\n" 12330 " return 0;\n" 12331 "};\n" 12332 "int i = 0;\n" 12333 "float i2 = 0;\n" 12334 "auto v = type{\n" 12335 " i = 1, //\n" 12336 " (i = 2), //\n" 12337 " i = 3 //\n" 12338 "};", 12339 Alignment); 12340 Alignment.AlignConsecutiveAssignments = false; 12341 12342 verifyFormat( 12343 "int i = 1;\n" 12344 "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n" 12345 " loooooooooooooooooooooongParameterB);\n" 12346 "int j = 2;", 12347 Alignment); 12348 12349 // Test interactions with ColumnLimit and AlignConsecutiveAssignments: 12350 // We expect declarations and assignments to align, as long as it doesn't 12351 // exceed the column limit, starting a new alignment sequence whenever it 12352 // happens. 12353 Alignment.AlignConsecutiveAssignments = true; 12354 Alignment.ColumnLimit = 30; 12355 verifyFormat("float ii = 1;\n" 12356 "unsigned j = 2;\n" 12357 "int someVerylongVariable = 1;\n" 12358 "AnotherLongType ll = 123456;\n" 12359 "VeryVeryLongType k = 2;\n" 12360 "int myvar = 1;", 12361 Alignment); 12362 Alignment.ColumnLimit = 80; 12363 Alignment.AlignConsecutiveAssignments = false; 12364 12365 verifyFormat( 12366 "template <typename LongTemplate, typename VeryLongTemplateTypeName,\n" 12367 " typename LongType, typename B>\n" 12368 "auto foo() {}\n", 12369 Alignment); 12370 verifyFormat("float a, b = 1;\n" 12371 "int c = 2;\n" 12372 "int dd = 3;\n", 12373 Alignment); 12374 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n" 12375 "float b[1][] = {{3.f}};\n", 12376 Alignment); 12377 Alignment.AlignConsecutiveAssignments = true; 12378 verifyFormat("float a, b = 1;\n" 12379 "int c = 2;\n" 12380 "int dd = 3;\n", 12381 Alignment); 12382 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n" 12383 "float b[1][] = {{3.f}};\n", 12384 Alignment); 12385 Alignment.AlignConsecutiveAssignments = false; 12386 12387 Alignment.ColumnLimit = 30; 12388 Alignment.BinPackParameters = false; 12389 verifyFormat("void foo(float a,\n" 12390 " float b,\n" 12391 " int c,\n" 12392 " uint32_t *d) {\n" 12393 " int * e = 0;\n" 12394 " float f = 0;\n" 12395 " double g = 0;\n" 12396 "}\n" 12397 "void bar(ino_t a,\n" 12398 " int b,\n" 12399 " uint32_t *c,\n" 12400 " bool d) {}\n", 12401 Alignment); 12402 Alignment.BinPackParameters = true; 12403 Alignment.ColumnLimit = 80; 12404 12405 // Bug 33507 12406 Alignment.PointerAlignment = FormatStyle::PAS_Middle; 12407 verifyFormat( 12408 "auto found = range::find_if(vsProducts, [&](auto * aProduct) {\n" 12409 " static const Version verVs2017;\n" 12410 " return true;\n" 12411 "});\n", 12412 Alignment); 12413 Alignment.PointerAlignment = FormatStyle::PAS_Right; 12414 12415 // See llvm.org/PR35641 12416 Alignment.AlignConsecutiveDeclarations = true; 12417 verifyFormat("int func() { //\n" 12418 " int b;\n" 12419 " unsigned c;\n" 12420 "}", 12421 Alignment); 12422 12423 // See PR37175 12424 FormatStyle Style = getMozillaStyle(); 12425 Style.AlignConsecutiveDeclarations = true; 12426 EXPECT_EQ("DECOR1 /**/ int8_t /**/ DECOR2 /**/\n" 12427 "foo(int a);", 12428 format("DECOR1 /**/ int8_t /**/ DECOR2 /**/ foo (int a);", Style)); 12429 } 12430 12431 TEST_F(FormatTest, LinuxBraceBreaking) { 12432 FormatStyle LinuxBraceStyle = getLLVMStyle(); 12433 LinuxBraceStyle.BreakBeforeBraces = FormatStyle::BS_Linux; 12434 verifyFormat("namespace a\n" 12435 "{\n" 12436 "class A\n" 12437 "{\n" 12438 " void f()\n" 12439 " {\n" 12440 " if (true) {\n" 12441 " a();\n" 12442 " b();\n" 12443 " } else {\n" 12444 " a();\n" 12445 " }\n" 12446 " }\n" 12447 " void g() { return; }\n" 12448 "};\n" 12449 "struct B {\n" 12450 " int x;\n" 12451 "};\n" 12452 "} // namespace a\n", 12453 LinuxBraceStyle); 12454 verifyFormat("enum X {\n" 12455 " Y = 0,\n" 12456 "}\n", 12457 LinuxBraceStyle); 12458 verifyFormat("struct S {\n" 12459 " int Type;\n" 12460 " union {\n" 12461 " int x;\n" 12462 " double y;\n" 12463 " } Value;\n" 12464 " class C\n" 12465 " {\n" 12466 " MyFavoriteType Value;\n" 12467 " } Class;\n" 12468 "}\n", 12469 LinuxBraceStyle); 12470 } 12471 12472 TEST_F(FormatTest, MozillaBraceBreaking) { 12473 FormatStyle MozillaBraceStyle = getLLVMStyle(); 12474 MozillaBraceStyle.BreakBeforeBraces = FormatStyle::BS_Mozilla; 12475 MozillaBraceStyle.FixNamespaceComments = false; 12476 verifyFormat("namespace a {\n" 12477 "class A\n" 12478 "{\n" 12479 " void f()\n" 12480 " {\n" 12481 " if (true) {\n" 12482 " a();\n" 12483 " b();\n" 12484 " }\n" 12485 " }\n" 12486 " void g() { return; }\n" 12487 "};\n" 12488 "enum E\n" 12489 "{\n" 12490 " A,\n" 12491 " // foo\n" 12492 " B,\n" 12493 " C\n" 12494 "};\n" 12495 "struct B\n" 12496 "{\n" 12497 " int x;\n" 12498 "};\n" 12499 "}\n", 12500 MozillaBraceStyle); 12501 verifyFormat("struct S\n" 12502 "{\n" 12503 " int Type;\n" 12504 " union\n" 12505 " {\n" 12506 " int x;\n" 12507 " double y;\n" 12508 " } Value;\n" 12509 " class C\n" 12510 " {\n" 12511 " MyFavoriteType Value;\n" 12512 " } Class;\n" 12513 "}\n", 12514 MozillaBraceStyle); 12515 } 12516 12517 TEST_F(FormatTest, StroustrupBraceBreaking) { 12518 FormatStyle StroustrupBraceStyle = getLLVMStyle(); 12519 StroustrupBraceStyle.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 12520 verifyFormat("namespace a {\n" 12521 "class A {\n" 12522 " void f()\n" 12523 " {\n" 12524 " if (true) {\n" 12525 " a();\n" 12526 " b();\n" 12527 " }\n" 12528 " }\n" 12529 " void g() { return; }\n" 12530 "};\n" 12531 "struct B {\n" 12532 " int x;\n" 12533 "};\n" 12534 "} // namespace a\n", 12535 StroustrupBraceStyle); 12536 12537 verifyFormat("void foo()\n" 12538 "{\n" 12539 " if (a) {\n" 12540 " a();\n" 12541 " }\n" 12542 " else {\n" 12543 " b();\n" 12544 " }\n" 12545 "}\n", 12546 StroustrupBraceStyle); 12547 12548 verifyFormat("#ifdef _DEBUG\n" 12549 "int foo(int i = 0)\n" 12550 "#else\n" 12551 "int foo(int i = 5)\n" 12552 "#endif\n" 12553 "{\n" 12554 " return i;\n" 12555 "}", 12556 StroustrupBraceStyle); 12557 12558 verifyFormat("void foo() {}\n" 12559 "void bar()\n" 12560 "#ifdef _DEBUG\n" 12561 "{\n" 12562 " foo();\n" 12563 "}\n" 12564 "#else\n" 12565 "{\n" 12566 "}\n" 12567 "#endif", 12568 StroustrupBraceStyle); 12569 12570 verifyFormat("void foobar() { int i = 5; }\n" 12571 "#ifdef _DEBUG\n" 12572 "void bar() {}\n" 12573 "#else\n" 12574 "void bar() { foobar(); }\n" 12575 "#endif", 12576 StroustrupBraceStyle); 12577 } 12578 12579 TEST_F(FormatTest, AllmanBraceBreaking) { 12580 FormatStyle AllmanBraceStyle = getLLVMStyle(); 12581 AllmanBraceStyle.BreakBeforeBraces = FormatStyle::BS_Allman; 12582 12583 EXPECT_EQ("namespace a\n" 12584 "{\n" 12585 "void f();\n" 12586 "void g();\n" 12587 "} // namespace a\n", 12588 format("namespace a\n" 12589 "{\n" 12590 "void f();\n" 12591 "void g();\n" 12592 "}\n", 12593 AllmanBraceStyle)); 12594 12595 verifyFormat("namespace a\n" 12596 "{\n" 12597 "class A\n" 12598 "{\n" 12599 " void f()\n" 12600 " {\n" 12601 " if (true)\n" 12602 " {\n" 12603 " a();\n" 12604 " b();\n" 12605 " }\n" 12606 " }\n" 12607 " void g() { return; }\n" 12608 "};\n" 12609 "struct B\n" 12610 "{\n" 12611 " int x;\n" 12612 "};\n" 12613 "union C\n" 12614 "{\n" 12615 "};\n" 12616 "} // namespace a", 12617 AllmanBraceStyle); 12618 12619 verifyFormat("void f()\n" 12620 "{\n" 12621 " if (true)\n" 12622 " {\n" 12623 " a();\n" 12624 " }\n" 12625 " else if (false)\n" 12626 " {\n" 12627 " b();\n" 12628 " }\n" 12629 " else\n" 12630 " {\n" 12631 " c();\n" 12632 " }\n" 12633 "}\n", 12634 AllmanBraceStyle); 12635 12636 verifyFormat("void f()\n" 12637 "{\n" 12638 " for (int i = 0; i < 10; ++i)\n" 12639 " {\n" 12640 " a();\n" 12641 " }\n" 12642 " while (false)\n" 12643 " {\n" 12644 " b();\n" 12645 " }\n" 12646 " do\n" 12647 " {\n" 12648 " c();\n" 12649 " } while (false)\n" 12650 "}\n", 12651 AllmanBraceStyle); 12652 12653 verifyFormat("void f(int a)\n" 12654 "{\n" 12655 " switch (a)\n" 12656 " {\n" 12657 " case 0:\n" 12658 " break;\n" 12659 " case 1:\n" 12660 " {\n" 12661 " break;\n" 12662 " }\n" 12663 " case 2:\n" 12664 " {\n" 12665 " }\n" 12666 " break;\n" 12667 " default:\n" 12668 " break;\n" 12669 " }\n" 12670 "}\n", 12671 AllmanBraceStyle); 12672 12673 verifyFormat("enum X\n" 12674 "{\n" 12675 " Y = 0,\n" 12676 "}\n", 12677 AllmanBraceStyle); 12678 verifyFormat("enum X\n" 12679 "{\n" 12680 " Y = 0\n" 12681 "}\n", 12682 AllmanBraceStyle); 12683 12684 verifyFormat("@interface BSApplicationController ()\n" 12685 "{\n" 12686 "@private\n" 12687 " id _extraIvar;\n" 12688 "}\n" 12689 "@end\n", 12690 AllmanBraceStyle); 12691 12692 verifyFormat("#ifdef _DEBUG\n" 12693 "int foo(int i = 0)\n" 12694 "#else\n" 12695 "int foo(int i = 5)\n" 12696 "#endif\n" 12697 "{\n" 12698 " return i;\n" 12699 "}", 12700 AllmanBraceStyle); 12701 12702 verifyFormat("void foo() {}\n" 12703 "void bar()\n" 12704 "#ifdef _DEBUG\n" 12705 "{\n" 12706 " foo();\n" 12707 "}\n" 12708 "#else\n" 12709 "{\n" 12710 "}\n" 12711 "#endif", 12712 AllmanBraceStyle); 12713 12714 verifyFormat("void foobar() { int i = 5; }\n" 12715 "#ifdef _DEBUG\n" 12716 "void bar() {}\n" 12717 "#else\n" 12718 "void bar() { foobar(); }\n" 12719 "#endif", 12720 AllmanBraceStyle); 12721 12722 // This shouldn't affect ObjC blocks.. 12723 verifyFormat("[self doSomeThingWithACompletionHandler:^{\n" 12724 " // ...\n" 12725 " int i;\n" 12726 "}];", 12727 AllmanBraceStyle); 12728 verifyFormat("void (^block)(void) = ^{\n" 12729 " // ...\n" 12730 " int i;\n" 12731 "};", 12732 AllmanBraceStyle); 12733 // .. or dict literals. 12734 verifyFormat("void f()\n" 12735 "{\n" 12736 " // ...\n" 12737 " [object someMethod:@{@\"a\" : @\"b\"}];\n" 12738 "}", 12739 AllmanBraceStyle); 12740 verifyFormat("void f()\n" 12741 "{\n" 12742 " // ...\n" 12743 " [object someMethod:@{a : @\"b\"}];\n" 12744 "}", 12745 AllmanBraceStyle); 12746 verifyFormat("int f()\n" 12747 "{ // comment\n" 12748 " return 42;\n" 12749 "}", 12750 AllmanBraceStyle); 12751 12752 AllmanBraceStyle.ColumnLimit = 19; 12753 verifyFormat("void f() { int i; }", AllmanBraceStyle); 12754 AllmanBraceStyle.ColumnLimit = 18; 12755 verifyFormat("void f()\n" 12756 "{\n" 12757 " int i;\n" 12758 "}", 12759 AllmanBraceStyle); 12760 AllmanBraceStyle.ColumnLimit = 80; 12761 12762 FormatStyle BreakBeforeBraceShortIfs = AllmanBraceStyle; 12763 BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine = 12764 FormatStyle::SIS_WithoutElse; 12765 BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true; 12766 verifyFormat("void f(bool b)\n" 12767 "{\n" 12768 " if (b)\n" 12769 " {\n" 12770 " return;\n" 12771 " }\n" 12772 "}\n", 12773 BreakBeforeBraceShortIfs); 12774 verifyFormat("void f(bool b)\n" 12775 "{\n" 12776 " if constexpr (b)\n" 12777 " {\n" 12778 " return;\n" 12779 " }\n" 12780 "}\n", 12781 BreakBeforeBraceShortIfs); 12782 verifyFormat("void f(bool b)\n" 12783 "{\n" 12784 " if CONSTEXPR (b)\n" 12785 " {\n" 12786 " return;\n" 12787 " }\n" 12788 "}\n", 12789 BreakBeforeBraceShortIfs); 12790 verifyFormat("void f(bool b)\n" 12791 "{\n" 12792 " if (b) return;\n" 12793 "}\n", 12794 BreakBeforeBraceShortIfs); 12795 verifyFormat("void f(bool b)\n" 12796 "{\n" 12797 " if constexpr (b) return;\n" 12798 "}\n", 12799 BreakBeforeBraceShortIfs); 12800 verifyFormat("void f(bool b)\n" 12801 "{\n" 12802 " if CONSTEXPR (b) return;\n" 12803 "}\n", 12804 BreakBeforeBraceShortIfs); 12805 verifyFormat("void f(bool b)\n" 12806 "{\n" 12807 " while (b)\n" 12808 " {\n" 12809 " return;\n" 12810 " }\n" 12811 "}\n", 12812 BreakBeforeBraceShortIfs); 12813 } 12814 12815 TEST_F(FormatTest, WhitesmithsBraceBreaking) { 12816 FormatStyle WhitesmithsBraceStyle = getLLVMStyle(); 12817 WhitesmithsBraceStyle.BreakBeforeBraces = FormatStyle::BS_Whitesmiths; 12818 12819 // Make a few changes to the style for testing purposes 12820 WhitesmithsBraceStyle.AllowShortFunctionsOnASingleLine = 12821 FormatStyle::SFS_Empty; 12822 WhitesmithsBraceStyle.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None; 12823 WhitesmithsBraceStyle.ColumnLimit = 0; 12824 12825 // FIXME: this test case can't decide whether there should be a blank line 12826 // after the ~D() line or not. It adds one if one doesn't exist in the test 12827 // and it removes the line if one exists. 12828 /* 12829 verifyFormat("class A;\n" 12830 "namespace B\n" 12831 " {\n" 12832 "class C;\n" 12833 "// Comment\n" 12834 "class D\n" 12835 " {\n" 12836 "public:\n" 12837 " D();\n" 12838 " ~D() {}\n" 12839 "private:\n" 12840 " enum E\n" 12841 " {\n" 12842 " F\n" 12843 " }\n" 12844 " };\n" 12845 " } // namespace B\n", 12846 WhitesmithsBraceStyle); 12847 */ 12848 12849 verifyFormat("namespace a\n" 12850 " {\n" 12851 "class A\n" 12852 " {\n" 12853 " void f()\n" 12854 " {\n" 12855 " if (true)\n" 12856 " {\n" 12857 " a();\n" 12858 " b();\n" 12859 " }\n" 12860 " }\n" 12861 " void g()\n" 12862 " {\n" 12863 " return;\n" 12864 " }\n" 12865 " };\n" 12866 "struct B\n" 12867 " {\n" 12868 " int x;\n" 12869 " };\n" 12870 " } // namespace a", 12871 WhitesmithsBraceStyle); 12872 12873 verifyFormat("void f()\n" 12874 " {\n" 12875 " if (true)\n" 12876 " {\n" 12877 " a();\n" 12878 " }\n" 12879 " else if (false)\n" 12880 " {\n" 12881 " b();\n" 12882 " }\n" 12883 " else\n" 12884 " {\n" 12885 " c();\n" 12886 " }\n" 12887 " }\n", 12888 WhitesmithsBraceStyle); 12889 12890 verifyFormat("void f()\n" 12891 " {\n" 12892 " for (int i = 0; i < 10; ++i)\n" 12893 " {\n" 12894 " a();\n" 12895 " }\n" 12896 " while (false)\n" 12897 " {\n" 12898 " b();\n" 12899 " }\n" 12900 " do\n" 12901 " {\n" 12902 " c();\n" 12903 " } while (false)\n" 12904 " }\n", 12905 WhitesmithsBraceStyle); 12906 12907 // FIXME: the block and the break under case 2 in this test don't get indented 12908 // correctly 12909 /* 12910 verifyFormat("void switchTest1(int a)\n" 12911 " {\n" 12912 " switch (a)\n" 12913 " {\n" 12914 " case 2:\n" 12915 " {\n" 12916 " }\n" 12917 " break;\n" 12918 " }\n" 12919 " }\n", 12920 WhitesmithsBraceStyle); 12921 */ 12922 12923 // FIXME: the block and the break under case 2 in this test don't get indented 12924 // correctly 12925 /* 12926 verifyFormat("void switchTest2(int a)\n" 12927 " {\n" 12928 " switch (a)\n" 12929 " {\n" 12930 " case 0:\n" 12931 " break;\n" 12932 " case 1:\n" 12933 " {\n" 12934 " break;\n" 12935 " }\n" 12936 " case 2:\n" 12937 " {\n" 12938 " }\n" 12939 " break;\n" 12940 " default:\n" 12941 " break;\n" 12942 " }\n" 12943 " }\n", 12944 WhitesmithsBraceStyle); 12945 */ 12946 12947 verifyFormat("enum X\n" 12948 " {\n" 12949 " Y = 0, // testing\n" 12950 " }\n", 12951 WhitesmithsBraceStyle); 12952 12953 verifyFormat("enum X\n" 12954 " {\n" 12955 " Y = 0\n" 12956 " }\n", 12957 WhitesmithsBraceStyle); 12958 verifyFormat("enum X\n" 12959 " {\n" 12960 " Y = 0,\n" 12961 " Z = 1\n" 12962 " };\n", 12963 WhitesmithsBraceStyle); 12964 12965 verifyFormat("@interface BSApplicationController ()\n" 12966 " {\n" 12967 "@private\n" 12968 " id _extraIvar;\n" 12969 " }\n" 12970 "@end\n", 12971 WhitesmithsBraceStyle); 12972 12973 verifyFormat("#ifdef _DEBUG\n" 12974 "int foo(int i = 0)\n" 12975 "#else\n" 12976 "int foo(int i = 5)\n" 12977 "#endif\n" 12978 " {\n" 12979 " return i;\n" 12980 " }", 12981 WhitesmithsBraceStyle); 12982 12983 verifyFormat("void foo() {}\n" 12984 "void bar()\n" 12985 "#ifdef _DEBUG\n" 12986 " {\n" 12987 " foo();\n" 12988 " }\n" 12989 "#else\n" 12990 " {\n" 12991 " }\n" 12992 "#endif", 12993 WhitesmithsBraceStyle); 12994 12995 verifyFormat("void foobar()\n" 12996 " {\n" 12997 " int i = 5;\n" 12998 " }\n" 12999 "#ifdef _DEBUG\n" 13000 "void bar()\n" 13001 " {\n" 13002 " }\n" 13003 "#else\n" 13004 "void bar()\n" 13005 " {\n" 13006 " foobar();\n" 13007 " }\n" 13008 "#endif", 13009 WhitesmithsBraceStyle); 13010 13011 // This shouldn't affect ObjC blocks.. 13012 verifyFormat("[self doSomeThingWithACompletionHandler:^{\n" 13013 " // ...\n" 13014 " int i;\n" 13015 "}];", 13016 WhitesmithsBraceStyle); 13017 verifyFormat("void (^block)(void) = ^{\n" 13018 " // ...\n" 13019 " int i;\n" 13020 "};", 13021 WhitesmithsBraceStyle); 13022 // .. or dict literals. 13023 verifyFormat("void f()\n" 13024 " {\n" 13025 " [object someMethod:@{@\"a\" : @\"b\"}];\n" 13026 " }", 13027 WhitesmithsBraceStyle); 13028 13029 verifyFormat("int f()\n" 13030 " { // comment\n" 13031 " return 42;\n" 13032 " }", 13033 WhitesmithsBraceStyle); 13034 13035 FormatStyle BreakBeforeBraceShortIfs = WhitesmithsBraceStyle; 13036 BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine = 13037 FormatStyle::SIS_Always; 13038 BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true; 13039 verifyFormat("void f(bool b)\n" 13040 " {\n" 13041 " if (b)\n" 13042 " {\n" 13043 " return;\n" 13044 " }\n" 13045 " }\n", 13046 BreakBeforeBraceShortIfs); 13047 verifyFormat("void f(bool b)\n" 13048 " {\n" 13049 " if (b) return;\n" 13050 " }\n", 13051 BreakBeforeBraceShortIfs); 13052 verifyFormat("void f(bool b)\n" 13053 " {\n" 13054 " while (b)\n" 13055 " {\n" 13056 " return;\n" 13057 " }\n" 13058 " }\n", 13059 BreakBeforeBraceShortIfs); 13060 } 13061 13062 TEST_F(FormatTest, GNUBraceBreaking) { 13063 FormatStyle GNUBraceStyle = getLLVMStyle(); 13064 GNUBraceStyle.BreakBeforeBraces = FormatStyle::BS_GNU; 13065 verifyFormat("namespace a\n" 13066 "{\n" 13067 "class A\n" 13068 "{\n" 13069 " void f()\n" 13070 " {\n" 13071 " int a;\n" 13072 " {\n" 13073 " int b;\n" 13074 " }\n" 13075 " if (true)\n" 13076 " {\n" 13077 " a();\n" 13078 " b();\n" 13079 " }\n" 13080 " }\n" 13081 " void g() { return; }\n" 13082 "}\n" 13083 "} // namespace a", 13084 GNUBraceStyle); 13085 13086 verifyFormat("void f()\n" 13087 "{\n" 13088 " if (true)\n" 13089 " {\n" 13090 " a();\n" 13091 " }\n" 13092 " else if (false)\n" 13093 " {\n" 13094 " b();\n" 13095 " }\n" 13096 " else\n" 13097 " {\n" 13098 " c();\n" 13099 " }\n" 13100 "}\n", 13101 GNUBraceStyle); 13102 13103 verifyFormat("void f()\n" 13104 "{\n" 13105 " for (int i = 0; i < 10; ++i)\n" 13106 " {\n" 13107 " a();\n" 13108 " }\n" 13109 " while (false)\n" 13110 " {\n" 13111 " b();\n" 13112 " }\n" 13113 " do\n" 13114 " {\n" 13115 " c();\n" 13116 " }\n" 13117 " while (false);\n" 13118 "}\n", 13119 GNUBraceStyle); 13120 13121 verifyFormat("void f(int a)\n" 13122 "{\n" 13123 " switch (a)\n" 13124 " {\n" 13125 " case 0:\n" 13126 " break;\n" 13127 " case 1:\n" 13128 " {\n" 13129 " break;\n" 13130 " }\n" 13131 " case 2:\n" 13132 " {\n" 13133 " }\n" 13134 " break;\n" 13135 " default:\n" 13136 " break;\n" 13137 " }\n" 13138 "}\n", 13139 GNUBraceStyle); 13140 13141 verifyFormat("enum X\n" 13142 "{\n" 13143 " Y = 0,\n" 13144 "}\n", 13145 GNUBraceStyle); 13146 13147 verifyFormat("@interface BSApplicationController ()\n" 13148 "{\n" 13149 "@private\n" 13150 " id _extraIvar;\n" 13151 "}\n" 13152 "@end\n", 13153 GNUBraceStyle); 13154 13155 verifyFormat("#ifdef _DEBUG\n" 13156 "int foo(int i = 0)\n" 13157 "#else\n" 13158 "int foo(int i = 5)\n" 13159 "#endif\n" 13160 "{\n" 13161 " return i;\n" 13162 "}", 13163 GNUBraceStyle); 13164 13165 verifyFormat("void foo() {}\n" 13166 "void bar()\n" 13167 "#ifdef _DEBUG\n" 13168 "{\n" 13169 " foo();\n" 13170 "}\n" 13171 "#else\n" 13172 "{\n" 13173 "}\n" 13174 "#endif", 13175 GNUBraceStyle); 13176 13177 verifyFormat("void foobar() { int i = 5; }\n" 13178 "#ifdef _DEBUG\n" 13179 "void bar() {}\n" 13180 "#else\n" 13181 "void bar() { foobar(); }\n" 13182 "#endif", 13183 GNUBraceStyle); 13184 } 13185 13186 TEST_F(FormatTest, WebKitBraceBreaking) { 13187 FormatStyle WebKitBraceStyle = getLLVMStyle(); 13188 WebKitBraceStyle.BreakBeforeBraces = FormatStyle::BS_WebKit; 13189 WebKitBraceStyle.FixNamespaceComments = false; 13190 verifyFormat("namespace a {\n" 13191 "class A {\n" 13192 " void f()\n" 13193 " {\n" 13194 " if (true) {\n" 13195 " a();\n" 13196 " b();\n" 13197 " }\n" 13198 " }\n" 13199 " void g() { return; }\n" 13200 "};\n" 13201 "enum E {\n" 13202 " A,\n" 13203 " // foo\n" 13204 " B,\n" 13205 " C\n" 13206 "};\n" 13207 "struct B {\n" 13208 " int x;\n" 13209 "};\n" 13210 "}\n", 13211 WebKitBraceStyle); 13212 verifyFormat("struct S {\n" 13213 " int Type;\n" 13214 " union {\n" 13215 " int x;\n" 13216 " double y;\n" 13217 " } Value;\n" 13218 " class C {\n" 13219 " MyFavoriteType Value;\n" 13220 " } Class;\n" 13221 "};\n", 13222 WebKitBraceStyle); 13223 } 13224 13225 TEST_F(FormatTest, CatchExceptionReferenceBinding) { 13226 verifyFormat("void f() {\n" 13227 " try {\n" 13228 " } catch (const Exception &e) {\n" 13229 " }\n" 13230 "}\n", 13231 getLLVMStyle()); 13232 } 13233 13234 TEST_F(FormatTest, UnderstandsPragmas) { 13235 verifyFormat("#pragma omp reduction(| : var)"); 13236 verifyFormat("#pragma omp reduction(+ : var)"); 13237 13238 EXPECT_EQ("#pragma mark Any non-hyphenated or hyphenated string " 13239 "(including parentheses).", 13240 format("#pragma mark Any non-hyphenated or hyphenated string " 13241 "(including parentheses).")); 13242 } 13243 13244 TEST_F(FormatTest, UnderstandPragmaOption) { 13245 verifyFormat("#pragma option -C -A"); 13246 13247 EXPECT_EQ("#pragma option -C -A", format("#pragma option -C -A")); 13248 } 13249 13250 TEST_F(FormatTest, OptimizeBreakPenaltyVsExcess) { 13251 FormatStyle Style = getLLVMStyle(); 13252 Style.ColumnLimit = 20; 13253 13254 // See PR41213 13255 EXPECT_EQ("/*\n" 13256 " *\t9012345\n" 13257 " * /8901\n" 13258 " */", 13259 format("/*\n" 13260 " *\t9012345 /8901\n" 13261 " */", 13262 Style)); 13263 EXPECT_EQ("/*\n" 13264 " *345678\n" 13265 " *\t/8901\n" 13266 " */", 13267 format("/*\n" 13268 " *345678\t/8901\n" 13269 " */", 13270 Style)); 13271 13272 verifyFormat("int a; // the\n" 13273 " // comment", 13274 Style); 13275 EXPECT_EQ("int a; /* first line\n" 13276 " * second\n" 13277 " * line third\n" 13278 " * line\n" 13279 " */", 13280 format("int a; /* first line\n" 13281 " * second\n" 13282 " * line third\n" 13283 " * line\n" 13284 " */", 13285 Style)); 13286 EXPECT_EQ("int a; // first line\n" 13287 " // second\n" 13288 " // line third\n" 13289 " // line", 13290 format("int a; // first line\n" 13291 " // second line\n" 13292 " // third line", 13293 Style)); 13294 13295 Style.PenaltyExcessCharacter = 90; 13296 verifyFormat("int a; // the comment", Style); 13297 EXPECT_EQ("int a; // the comment\n" 13298 " // aaa", 13299 format("int a; // the comment aaa", Style)); 13300 EXPECT_EQ("int a; /* first line\n" 13301 " * second line\n" 13302 " * third line\n" 13303 " */", 13304 format("int a; /* first line\n" 13305 " * second line\n" 13306 " * third line\n" 13307 " */", 13308 Style)); 13309 EXPECT_EQ("int a; // first line\n" 13310 " // second line\n" 13311 " // third line", 13312 format("int a; // first line\n" 13313 " // second line\n" 13314 " // third line", 13315 Style)); 13316 // FIXME: Investigate why this is not getting the same layout as the test 13317 // above. 13318 EXPECT_EQ("int a; /* first line\n" 13319 " * second line\n" 13320 " * third line\n" 13321 " */", 13322 format("int a; /* first line second line third line" 13323 "\n*/", 13324 Style)); 13325 13326 EXPECT_EQ("// foo bar baz bazfoo\n" 13327 "// foo bar foo bar\n", 13328 format("// foo bar baz bazfoo\n" 13329 "// foo bar foo bar\n", 13330 Style)); 13331 EXPECT_EQ("// foo bar baz bazfoo\n" 13332 "// foo bar foo bar\n", 13333 format("// foo bar baz bazfoo\n" 13334 "// foo bar foo bar\n", 13335 Style)); 13336 13337 // FIXME: Optimally, we'd keep bazfoo on the first line and reflow bar to the 13338 // next one. 13339 EXPECT_EQ("// foo bar baz bazfoo\n" 13340 "// bar foo bar\n", 13341 format("// foo bar baz bazfoo bar\n" 13342 "// foo bar\n", 13343 Style)); 13344 13345 EXPECT_EQ("// foo bar baz bazfoo\n" 13346 "// foo bar baz bazfoo\n" 13347 "// bar foo bar\n", 13348 format("// foo bar baz bazfoo\n" 13349 "// foo bar baz bazfoo bar\n" 13350 "// foo bar\n", 13351 Style)); 13352 13353 EXPECT_EQ("// foo bar baz bazfoo\n" 13354 "// foo bar baz bazfoo\n" 13355 "// bar foo bar\n", 13356 format("// foo bar baz bazfoo\n" 13357 "// foo bar baz bazfoo bar\n" 13358 "// foo bar\n", 13359 Style)); 13360 13361 // Make sure we do not keep protruding characters if strict mode reflow is 13362 // cheaper than keeping protruding characters. 13363 Style.ColumnLimit = 21; 13364 EXPECT_EQ( 13365 "// foo foo foo foo\n" 13366 "// foo foo foo foo\n" 13367 "// foo foo foo foo\n", 13368 format("// foo foo foo foo foo foo foo foo foo foo foo foo\n", Style)); 13369 13370 EXPECT_EQ("int a = /* long block\n" 13371 " comment */\n" 13372 " 42;", 13373 format("int a = /* long block comment */ 42;", Style)); 13374 } 13375 13376 #define EXPECT_ALL_STYLES_EQUAL(Styles) \ 13377 for (size_t i = 1; i < Styles.size(); ++i) \ 13378 EXPECT_EQ(Styles[0], Styles[i]) \ 13379 << "Style #" << i << " of " << Styles.size() << " differs from Style #0" 13380 13381 TEST_F(FormatTest, GetsPredefinedStyleByName) { 13382 SmallVector<FormatStyle, 3> Styles; 13383 Styles.resize(3); 13384 13385 Styles[0] = getLLVMStyle(); 13386 EXPECT_TRUE(getPredefinedStyle("LLVM", FormatStyle::LK_Cpp, &Styles[1])); 13387 EXPECT_TRUE(getPredefinedStyle("lLvM", FormatStyle::LK_Cpp, &Styles[2])); 13388 EXPECT_ALL_STYLES_EQUAL(Styles); 13389 13390 Styles[0] = getGoogleStyle(); 13391 EXPECT_TRUE(getPredefinedStyle("Google", FormatStyle::LK_Cpp, &Styles[1])); 13392 EXPECT_TRUE(getPredefinedStyle("gOOgle", FormatStyle::LK_Cpp, &Styles[2])); 13393 EXPECT_ALL_STYLES_EQUAL(Styles); 13394 13395 Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript); 13396 EXPECT_TRUE( 13397 getPredefinedStyle("Google", FormatStyle::LK_JavaScript, &Styles[1])); 13398 EXPECT_TRUE( 13399 getPredefinedStyle("gOOgle", FormatStyle::LK_JavaScript, &Styles[2])); 13400 EXPECT_ALL_STYLES_EQUAL(Styles); 13401 13402 Styles[0] = getChromiumStyle(FormatStyle::LK_Cpp); 13403 EXPECT_TRUE(getPredefinedStyle("Chromium", FormatStyle::LK_Cpp, &Styles[1])); 13404 EXPECT_TRUE(getPredefinedStyle("cHRoMiUM", FormatStyle::LK_Cpp, &Styles[2])); 13405 EXPECT_ALL_STYLES_EQUAL(Styles); 13406 13407 Styles[0] = getMozillaStyle(); 13408 EXPECT_TRUE(getPredefinedStyle("Mozilla", FormatStyle::LK_Cpp, &Styles[1])); 13409 EXPECT_TRUE(getPredefinedStyle("moZILla", FormatStyle::LK_Cpp, &Styles[2])); 13410 EXPECT_ALL_STYLES_EQUAL(Styles); 13411 13412 Styles[0] = getWebKitStyle(); 13413 EXPECT_TRUE(getPredefinedStyle("WebKit", FormatStyle::LK_Cpp, &Styles[1])); 13414 EXPECT_TRUE(getPredefinedStyle("wEbKit", FormatStyle::LK_Cpp, &Styles[2])); 13415 EXPECT_ALL_STYLES_EQUAL(Styles); 13416 13417 Styles[0] = getGNUStyle(); 13418 EXPECT_TRUE(getPredefinedStyle("GNU", FormatStyle::LK_Cpp, &Styles[1])); 13419 EXPECT_TRUE(getPredefinedStyle("gnU", FormatStyle::LK_Cpp, &Styles[2])); 13420 EXPECT_ALL_STYLES_EQUAL(Styles); 13421 13422 EXPECT_FALSE(getPredefinedStyle("qwerty", FormatStyle::LK_Cpp, &Styles[0])); 13423 } 13424 13425 TEST_F(FormatTest, GetsCorrectBasedOnStyle) { 13426 SmallVector<FormatStyle, 8> Styles; 13427 Styles.resize(2); 13428 13429 Styles[0] = getGoogleStyle(); 13430 Styles[1] = getLLVMStyle(); 13431 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value()); 13432 EXPECT_ALL_STYLES_EQUAL(Styles); 13433 13434 Styles.resize(5); 13435 Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript); 13436 Styles[1] = getLLVMStyle(); 13437 Styles[1].Language = FormatStyle::LK_JavaScript; 13438 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value()); 13439 13440 Styles[2] = getLLVMStyle(); 13441 Styles[2].Language = FormatStyle::LK_JavaScript; 13442 EXPECT_EQ(0, parseConfiguration("Language: JavaScript\n" 13443 "BasedOnStyle: Google", 13444 &Styles[2]) 13445 .value()); 13446 13447 Styles[3] = getLLVMStyle(); 13448 Styles[3].Language = FormatStyle::LK_JavaScript; 13449 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google\n" 13450 "Language: JavaScript", 13451 &Styles[3]) 13452 .value()); 13453 13454 Styles[4] = getLLVMStyle(); 13455 Styles[4].Language = FormatStyle::LK_JavaScript; 13456 EXPECT_EQ(0, parseConfiguration("---\n" 13457 "BasedOnStyle: LLVM\n" 13458 "IndentWidth: 123\n" 13459 "---\n" 13460 "BasedOnStyle: Google\n" 13461 "Language: JavaScript", 13462 &Styles[4]) 13463 .value()); 13464 EXPECT_ALL_STYLES_EQUAL(Styles); 13465 } 13466 13467 #define CHECK_PARSE_BOOL_FIELD(FIELD, CONFIG_NAME) \ 13468 Style.FIELD = false; \ 13469 EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": true", &Style).value()); \ 13470 EXPECT_TRUE(Style.FIELD); \ 13471 EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": false", &Style).value()); \ 13472 EXPECT_FALSE(Style.FIELD); 13473 13474 #define CHECK_PARSE_BOOL(FIELD) CHECK_PARSE_BOOL_FIELD(FIELD, #FIELD) 13475 13476 #define CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, CONFIG_NAME) \ 13477 Style.STRUCT.FIELD = false; \ 13478 EXPECT_EQ(0, \ 13479 parseConfiguration(#STRUCT ":\n " CONFIG_NAME ": true", &Style) \ 13480 .value()); \ 13481 EXPECT_TRUE(Style.STRUCT.FIELD); \ 13482 EXPECT_EQ(0, \ 13483 parseConfiguration(#STRUCT ":\n " CONFIG_NAME ": false", &Style) \ 13484 .value()); \ 13485 EXPECT_FALSE(Style.STRUCT.FIELD); 13486 13487 #define CHECK_PARSE_NESTED_BOOL(STRUCT, FIELD) \ 13488 CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, #FIELD) 13489 13490 #define CHECK_PARSE(TEXT, FIELD, VALUE) \ 13491 EXPECT_NE(VALUE, Style.FIELD); \ 13492 EXPECT_EQ(0, parseConfiguration(TEXT, &Style).value()); \ 13493 EXPECT_EQ(VALUE, Style.FIELD) 13494 13495 TEST_F(FormatTest, ParsesConfigurationBools) { 13496 FormatStyle Style = {}; 13497 Style.Language = FormatStyle::LK_Cpp; 13498 CHECK_PARSE_BOOL(AlignTrailingComments); 13499 CHECK_PARSE_BOOL(AlignConsecutiveAssignments); 13500 CHECK_PARSE_BOOL(AlignConsecutiveBitFields); 13501 CHECK_PARSE_BOOL(AlignConsecutiveDeclarations); 13502 CHECK_PARSE_BOOL(AlignConsecutiveMacros); 13503 CHECK_PARSE_BOOL(AllowAllArgumentsOnNextLine); 13504 CHECK_PARSE_BOOL(AllowAllConstructorInitializersOnNextLine); 13505 CHECK_PARSE_BOOL(AllowAllParametersOfDeclarationOnNextLine); 13506 CHECK_PARSE_BOOL(AllowShortCaseLabelsOnASingleLine); 13507 CHECK_PARSE_BOOL(AllowShortEnumsOnASingleLine); 13508 CHECK_PARSE_BOOL(AllowShortLoopsOnASingleLine); 13509 CHECK_PARSE_BOOL(BinPackArguments); 13510 CHECK_PARSE_BOOL(BinPackParameters); 13511 CHECK_PARSE_BOOL(BreakAfterJavaFieldAnnotations); 13512 CHECK_PARSE_BOOL(BreakBeforeTernaryOperators); 13513 CHECK_PARSE_BOOL(BreakStringLiterals); 13514 CHECK_PARSE_BOOL(CompactNamespaces); 13515 CHECK_PARSE_BOOL(ConstructorInitializerAllOnOneLineOrOnePerLine); 13516 CHECK_PARSE_BOOL(DeriveLineEnding); 13517 CHECK_PARSE_BOOL(DerivePointerAlignment); 13518 CHECK_PARSE_BOOL_FIELD(DerivePointerAlignment, "DerivePointerBinding"); 13519 CHECK_PARSE_BOOL(DisableFormat); 13520 CHECK_PARSE_BOOL(IndentCaseLabels); 13521 CHECK_PARSE_BOOL(IndentCaseBlocks); 13522 CHECK_PARSE_BOOL(IndentGotoLabels); 13523 CHECK_PARSE_BOOL(IndentWrappedFunctionNames); 13524 CHECK_PARSE_BOOL(KeepEmptyLinesAtTheStartOfBlocks); 13525 CHECK_PARSE_BOOL(ObjCSpaceAfterProperty); 13526 CHECK_PARSE_BOOL(ObjCSpaceBeforeProtocolList); 13527 CHECK_PARSE_BOOL(Cpp11BracedListStyle); 13528 CHECK_PARSE_BOOL(ReflowComments); 13529 CHECK_PARSE_BOOL(SortIncludes); 13530 CHECK_PARSE_BOOL(SortUsingDeclarations); 13531 CHECK_PARSE_BOOL(SpacesInParentheses); 13532 CHECK_PARSE_BOOL(SpacesInSquareBrackets); 13533 CHECK_PARSE_BOOL(SpacesInAngles); 13534 CHECK_PARSE_BOOL(SpacesInConditionalStatement); 13535 CHECK_PARSE_BOOL(SpaceInEmptyBlock); 13536 CHECK_PARSE_BOOL(SpaceInEmptyParentheses); 13537 CHECK_PARSE_BOOL(SpacesInContainerLiterals); 13538 CHECK_PARSE_BOOL(SpacesInCStyleCastParentheses); 13539 CHECK_PARSE_BOOL(SpaceAfterCStyleCast); 13540 CHECK_PARSE_BOOL(SpaceAfterTemplateKeyword); 13541 CHECK_PARSE_BOOL(SpaceAfterLogicalNot); 13542 CHECK_PARSE_BOOL(SpaceBeforeAssignmentOperators); 13543 CHECK_PARSE_BOOL(SpaceBeforeCpp11BracedList); 13544 CHECK_PARSE_BOOL(SpaceBeforeCtorInitializerColon); 13545 CHECK_PARSE_BOOL(SpaceBeforeInheritanceColon); 13546 CHECK_PARSE_BOOL(SpaceBeforeRangeBasedForLoopColon); 13547 CHECK_PARSE_BOOL(SpaceBeforeSquareBrackets); 13548 CHECK_PARSE_BOOL(UseCRLF); 13549 13550 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterCaseLabel); 13551 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterClass); 13552 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterEnum); 13553 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterFunction); 13554 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterNamespace); 13555 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterObjCDeclaration); 13556 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterStruct); 13557 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterUnion); 13558 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterExternBlock); 13559 CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeCatch); 13560 CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeElse); 13561 CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeLambdaBody); 13562 CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeWhile); 13563 CHECK_PARSE_NESTED_BOOL(BraceWrapping, IndentBraces); 13564 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyFunction); 13565 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyRecord); 13566 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyNamespace); 13567 } 13568 13569 #undef CHECK_PARSE_BOOL 13570 13571 TEST_F(FormatTest, ParsesConfiguration) { 13572 FormatStyle Style = {}; 13573 Style.Language = FormatStyle::LK_Cpp; 13574 CHECK_PARSE("AccessModifierOffset: -1234", AccessModifierOffset, -1234); 13575 CHECK_PARSE("ConstructorInitializerIndentWidth: 1234", 13576 ConstructorInitializerIndentWidth, 1234u); 13577 CHECK_PARSE("ObjCBlockIndentWidth: 1234", ObjCBlockIndentWidth, 1234u); 13578 CHECK_PARSE("ColumnLimit: 1234", ColumnLimit, 1234u); 13579 CHECK_PARSE("MaxEmptyLinesToKeep: 1234", MaxEmptyLinesToKeep, 1234u); 13580 CHECK_PARSE("PenaltyBreakAssignment: 1234", PenaltyBreakAssignment, 1234u); 13581 CHECK_PARSE("PenaltyBreakBeforeFirstCallParameter: 1234", 13582 PenaltyBreakBeforeFirstCallParameter, 1234u); 13583 CHECK_PARSE("PenaltyBreakTemplateDeclaration: 1234", 13584 PenaltyBreakTemplateDeclaration, 1234u); 13585 CHECK_PARSE("PenaltyExcessCharacter: 1234", PenaltyExcessCharacter, 1234u); 13586 CHECK_PARSE("PenaltyReturnTypeOnItsOwnLine: 1234", 13587 PenaltyReturnTypeOnItsOwnLine, 1234u); 13588 CHECK_PARSE("SpacesBeforeTrailingComments: 1234", 13589 SpacesBeforeTrailingComments, 1234u); 13590 CHECK_PARSE("IndentWidth: 32", IndentWidth, 32u); 13591 CHECK_PARSE("ContinuationIndentWidth: 11", ContinuationIndentWidth, 11u); 13592 CHECK_PARSE("CommentPragmas: '// abc$'", CommentPragmas, "// abc$"); 13593 13594 Style.PointerAlignment = FormatStyle::PAS_Middle; 13595 CHECK_PARSE("PointerAlignment: Left", PointerAlignment, 13596 FormatStyle::PAS_Left); 13597 CHECK_PARSE("PointerAlignment: Right", PointerAlignment, 13598 FormatStyle::PAS_Right); 13599 CHECK_PARSE("PointerAlignment: Middle", PointerAlignment, 13600 FormatStyle::PAS_Middle); 13601 // For backward compatibility: 13602 CHECK_PARSE("PointerBindsToType: Left", PointerAlignment, 13603 FormatStyle::PAS_Left); 13604 CHECK_PARSE("PointerBindsToType: Right", PointerAlignment, 13605 FormatStyle::PAS_Right); 13606 CHECK_PARSE("PointerBindsToType: Middle", PointerAlignment, 13607 FormatStyle::PAS_Middle); 13608 13609 Style.Standard = FormatStyle::LS_Auto; 13610 CHECK_PARSE("Standard: c++03", Standard, FormatStyle::LS_Cpp03); 13611 CHECK_PARSE("Standard: c++11", Standard, FormatStyle::LS_Cpp11); 13612 CHECK_PARSE("Standard: c++14", Standard, FormatStyle::LS_Cpp14); 13613 CHECK_PARSE("Standard: c++17", Standard, FormatStyle::LS_Cpp17); 13614 CHECK_PARSE("Standard: c++20", Standard, FormatStyle::LS_Cpp20); 13615 CHECK_PARSE("Standard: Auto", Standard, FormatStyle::LS_Auto); 13616 CHECK_PARSE("Standard: Latest", Standard, FormatStyle::LS_Latest); 13617 // Legacy aliases: 13618 CHECK_PARSE("Standard: Cpp03", Standard, FormatStyle::LS_Cpp03); 13619 CHECK_PARSE("Standard: Cpp11", Standard, FormatStyle::LS_Latest); 13620 CHECK_PARSE("Standard: C++03", Standard, FormatStyle::LS_Cpp03); 13621 CHECK_PARSE("Standard: C++11", Standard, FormatStyle::LS_Cpp11); 13622 13623 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 13624 CHECK_PARSE("BreakBeforeBinaryOperators: NonAssignment", 13625 BreakBeforeBinaryOperators, FormatStyle::BOS_NonAssignment); 13626 CHECK_PARSE("BreakBeforeBinaryOperators: None", BreakBeforeBinaryOperators, 13627 FormatStyle::BOS_None); 13628 CHECK_PARSE("BreakBeforeBinaryOperators: All", BreakBeforeBinaryOperators, 13629 FormatStyle::BOS_All); 13630 // For backward compatibility: 13631 CHECK_PARSE("BreakBeforeBinaryOperators: false", BreakBeforeBinaryOperators, 13632 FormatStyle::BOS_None); 13633 CHECK_PARSE("BreakBeforeBinaryOperators: true", BreakBeforeBinaryOperators, 13634 FormatStyle::BOS_All); 13635 13636 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon; 13637 CHECK_PARSE("BreakConstructorInitializers: BeforeComma", 13638 BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma); 13639 CHECK_PARSE("BreakConstructorInitializers: AfterColon", 13640 BreakConstructorInitializers, FormatStyle::BCIS_AfterColon); 13641 CHECK_PARSE("BreakConstructorInitializers: BeforeColon", 13642 BreakConstructorInitializers, FormatStyle::BCIS_BeforeColon); 13643 // For backward compatibility: 13644 CHECK_PARSE("BreakConstructorInitializersBeforeComma: true", 13645 BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma); 13646 13647 Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon; 13648 CHECK_PARSE("BreakInheritanceList: BeforeComma", BreakInheritanceList, 13649 FormatStyle::BILS_BeforeComma); 13650 CHECK_PARSE("BreakInheritanceList: AfterColon", BreakInheritanceList, 13651 FormatStyle::BILS_AfterColon); 13652 CHECK_PARSE("BreakInheritanceList: BeforeColon", BreakInheritanceList, 13653 FormatStyle::BILS_BeforeColon); 13654 // For backward compatibility: 13655 CHECK_PARSE("BreakBeforeInheritanceComma: true", BreakInheritanceList, 13656 FormatStyle::BILS_BeforeComma); 13657 13658 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 13659 CHECK_PARSE("AlignAfterOpenBracket: Align", AlignAfterOpenBracket, 13660 FormatStyle::BAS_Align); 13661 CHECK_PARSE("AlignAfterOpenBracket: DontAlign", AlignAfterOpenBracket, 13662 FormatStyle::BAS_DontAlign); 13663 CHECK_PARSE("AlignAfterOpenBracket: AlwaysBreak", AlignAfterOpenBracket, 13664 FormatStyle::BAS_AlwaysBreak); 13665 // For backward compatibility: 13666 CHECK_PARSE("AlignAfterOpenBracket: false", AlignAfterOpenBracket, 13667 FormatStyle::BAS_DontAlign); 13668 CHECK_PARSE("AlignAfterOpenBracket: true", AlignAfterOpenBracket, 13669 FormatStyle::BAS_Align); 13670 13671 Style.AlignEscapedNewlines = FormatStyle::ENAS_Left; 13672 CHECK_PARSE("AlignEscapedNewlines: DontAlign", AlignEscapedNewlines, 13673 FormatStyle::ENAS_DontAlign); 13674 CHECK_PARSE("AlignEscapedNewlines: Left", AlignEscapedNewlines, 13675 FormatStyle::ENAS_Left); 13676 CHECK_PARSE("AlignEscapedNewlines: Right", AlignEscapedNewlines, 13677 FormatStyle::ENAS_Right); 13678 // For backward compatibility: 13679 CHECK_PARSE("AlignEscapedNewlinesLeft: true", AlignEscapedNewlines, 13680 FormatStyle::ENAS_Left); 13681 CHECK_PARSE("AlignEscapedNewlinesLeft: false", AlignEscapedNewlines, 13682 FormatStyle::ENAS_Right); 13683 13684 Style.AlignOperands = FormatStyle::OAS_Align; 13685 CHECK_PARSE("AlignOperands: DontAlign", AlignOperands, 13686 FormatStyle::OAS_DontAlign); 13687 CHECK_PARSE("AlignOperands: Align", AlignOperands, FormatStyle::OAS_Align); 13688 CHECK_PARSE("AlignOperands: AlignAfterOperator", AlignOperands, 13689 FormatStyle::OAS_AlignAfterOperator); 13690 // For backward compatibility: 13691 CHECK_PARSE("AlignOperands: false", AlignOperands, 13692 FormatStyle::OAS_DontAlign); 13693 CHECK_PARSE("AlignOperands: true", AlignOperands, FormatStyle::OAS_Align); 13694 13695 Style.UseTab = FormatStyle::UT_ForIndentation; 13696 CHECK_PARSE("UseTab: Never", UseTab, FormatStyle::UT_Never); 13697 CHECK_PARSE("UseTab: ForIndentation", UseTab, FormatStyle::UT_ForIndentation); 13698 CHECK_PARSE("UseTab: Always", UseTab, FormatStyle::UT_Always); 13699 CHECK_PARSE("UseTab: ForContinuationAndIndentation", UseTab, 13700 FormatStyle::UT_ForContinuationAndIndentation); 13701 CHECK_PARSE("UseTab: AlignWithSpaces", UseTab, 13702 FormatStyle::UT_AlignWithSpaces); 13703 // For backward compatibility: 13704 CHECK_PARSE("UseTab: false", UseTab, FormatStyle::UT_Never); 13705 CHECK_PARSE("UseTab: true", UseTab, FormatStyle::UT_Always); 13706 13707 Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty; 13708 CHECK_PARSE("AllowShortBlocksOnASingleLine: Never", 13709 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never); 13710 CHECK_PARSE("AllowShortBlocksOnASingleLine: Empty", 13711 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Empty); 13712 CHECK_PARSE("AllowShortBlocksOnASingleLine: Always", 13713 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always); 13714 // For backward compatibility: 13715 CHECK_PARSE("AllowShortBlocksOnASingleLine: false", 13716 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never); 13717 CHECK_PARSE("AllowShortBlocksOnASingleLine: true", 13718 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always); 13719 13720 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; 13721 CHECK_PARSE("AllowShortFunctionsOnASingleLine: None", 13722 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None); 13723 CHECK_PARSE("AllowShortFunctionsOnASingleLine: Inline", 13724 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Inline); 13725 CHECK_PARSE("AllowShortFunctionsOnASingleLine: Empty", 13726 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Empty); 13727 CHECK_PARSE("AllowShortFunctionsOnASingleLine: All", 13728 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All); 13729 // For backward compatibility: 13730 CHECK_PARSE("AllowShortFunctionsOnASingleLine: false", 13731 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None); 13732 CHECK_PARSE("AllowShortFunctionsOnASingleLine: true", 13733 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All); 13734 13735 Style.SpaceBeforeParens = FormatStyle::SBPO_Always; 13736 CHECK_PARSE("SpaceBeforeParens: Never", SpaceBeforeParens, 13737 FormatStyle::SBPO_Never); 13738 CHECK_PARSE("SpaceBeforeParens: Always", SpaceBeforeParens, 13739 FormatStyle::SBPO_Always); 13740 CHECK_PARSE("SpaceBeforeParens: ControlStatements", SpaceBeforeParens, 13741 FormatStyle::SBPO_ControlStatements); 13742 CHECK_PARSE("SpaceBeforeParens: NonEmptyParentheses", SpaceBeforeParens, 13743 FormatStyle::SBPO_NonEmptyParentheses); 13744 // For backward compatibility: 13745 CHECK_PARSE("SpaceAfterControlStatementKeyword: false", SpaceBeforeParens, 13746 FormatStyle::SBPO_Never); 13747 CHECK_PARSE("SpaceAfterControlStatementKeyword: true", SpaceBeforeParens, 13748 FormatStyle::SBPO_ControlStatements); 13749 13750 Style.ColumnLimit = 123; 13751 FormatStyle BaseStyle = getLLVMStyle(); 13752 CHECK_PARSE("BasedOnStyle: LLVM", ColumnLimit, BaseStyle.ColumnLimit); 13753 CHECK_PARSE("BasedOnStyle: LLVM\nColumnLimit: 1234", ColumnLimit, 1234u); 13754 13755 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 13756 CHECK_PARSE("BreakBeforeBraces: Attach", BreakBeforeBraces, 13757 FormatStyle::BS_Attach); 13758 CHECK_PARSE("BreakBeforeBraces: Linux", BreakBeforeBraces, 13759 FormatStyle::BS_Linux); 13760 CHECK_PARSE("BreakBeforeBraces: Mozilla", BreakBeforeBraces, 13761 FormatStyle::BS_Mozilla); 13762 CHECK_PARSE("BreakBeforeBraces: Stroustrup", BreakBeforeBraces, 13763 FormatStyle::BS_Stroustrup); 13764 CHECK_PARSE("BreakBeforeBraces: Allman", BreakBeforeBraces, 13765 FormatStyle::BS_Allman); 13766 CHECK_PARSE("BreakBeforeBraces: Whitesmiths", BreakBeforeBraces, 13767 FormatStyle::BS_Whitesmiths); 13768 CHECK_PARSE("BreakBeforeBraces: GNU", BreakBeforeBraces, FormatStyle::BS_GNU); 13769 CHECK_PARSE("BreakBeforeBraces: WebKit", BreakBeforeBraces, 13770 FormatStyle::BS_WebKit); 13771 CHECK_PARSE("BreakBeforeBraces: Custom", BreakBeforeBraces, 13772 FormatStyle::BS_Custom); 13773 13774 Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Never; 13775 CHECK_PARSE("BraceWrapping:\n" 13776 " AfterControlStatement: MultiLine", 13777 BraceWrapping.AfterControlStatement, 13778 FormatStyle::BWACS_MultiLine); 13779 CHECK_PARSE("BraceWrapping:\n" 13780 " AfterControlStatement: Always", 13781 BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Always); 13782 CHECK_PARSE("BraceWrapping:\n" 13783 " AfterControlStatement: Never", 13784 BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Never); 13785 // For backward compatibility: 13786 CHECK_PARSE("BraceWrapping:\n" 13787 " AfterControlStatement: true", 13788 BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Always); 13789 CHECK_PARSE("BraceWrapping:\n" 13790 " AfterControlStatement: false", 13791 BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Never); 13792 13793 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All; 13794 CHECK_PARSE("AlwaysBreakAfterReturnType: None", AlwaysBreakAfterReturnType, 13795 FormatStyle::RTBS_None); 13796 CHECK_PARSE("AlwaysBreakAfterReturnType: All", AlwaysBreakAfterReturnType, 13797 FormatStyle::RTBS_All); 13798 CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevel", 13799 AlwaysBreakAfterReturnType, FormatStyle::RTBS_TopLevel); 13800 CHECK_PARSE("AlwaysBreakAfterReturnType: AllDefinitions", 13801 AlwaysBreakAfterReturnType, FormatStyle::RTBS_AllDefinitions); 13802 CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevelDefinitions", 13803 AlwaysBreakAfterReturnType, 13804 FormatStyle::RTBS_TopLevelDefinitions); 13805 13806 Style.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes; 13807 CHECK_PARSE("AlwaysBreakTemplateDeclarations: No", 13808 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_No); 13809 CHECK_PARSE("AlwaysBreakTemplateDeclarations: MultiLine", 13810 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_MultiLine); 13811 CHECK_PARSE("AlwaysBreakTemplateDeclarations: Yes", 13812 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_Yes); 13813 CHECK_PARSE("AlwaysBreakTemplateDeclarations: false", 13814 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_MultiLine); 13815 CHECK_PARSE("AlwaysBreakTemplateDeclarations: true", 13816 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_Yes); 13817 13818 Style.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_All; 13819 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: None", 13820 AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_None); 13821 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: All", 13822 AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_All); 13823 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: TopLevel", 13824 AlwaysBreakAfterDefinitionReturnType, 13825 FormatStyle::DRTBS_TopLevel); 13826 13827 Style.NamespaceIndentation = FormatStyle::NI_All; 13828 CHECK_PARSE("NamespaceIndentation: None", NamespaceIndentation, 13829 FormatStyle::NI_None); 13830 CHECK_PARSE("NamespaceIndentation: Inner", NamespaceIndentation, 13831 FormatStyle::NI_Inner); 13832 CHECK_PARSE("NamespaceIndentation: All", NamespaceIndentation, 13833 FormatStyle::NI_All); 13834 13835 Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Always; 13836 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Never", 13837 AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never); 13838 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: WithoutElse", 13839 AllowShortIfStatementsOnASingleLine, 13840 FormatStyle::SIS_WithoutElse); 13841 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Always", 13842 AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Always); 13843 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: false", 13844 AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never); 13845 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: true", 13846 AllowShortIfStatementsOnASingleLine, 13847 FormatStyle::SIS_WithoutElse); 13848 13849 // FIXME: This is required because parsing a configuration simply overwrites 13850 // the first N elements of the list instead of resetting it. 13851 Style.ForEachMacros.clear(); 13852 std::vector<std::string> BoostForeach; 13853 BoostForeach.push_back("BOOST_FOREACH"); 13854 CHECK_PARSE("ForEachMacros: [BOOST_FOREACH]", ForEachMacros, BoostForeach); 13855 std::vector<std::string> BoostAndQForeach; 13856 BoostAndQForeach.push_back("BOOST_FOREACH"); 13857 BoostAndQForeach.push_back("Q_FOREACH"); 13858 CHECK_PARSE("ForEachMacros: [BOOST_FOREACH, Q_FOREACH]", ForEachMacros, 13859 BoostAndQForeach); 13860 13861 Style.StatementMacros.clear(); 13862 CHECK_PARSE("StatementMacros: [QUNUSED]", StatementMacros, 13863 std::vector<std::string>{"QUNUSED"}); 13864 CHECK_PARSE("StatementMacros: [QUNUSED, QT_REQUIRE_VERSION]", StatementMacros, 13865 std::vector<std::string>({"QUNUSED", "QT_REQUIRE_VERSION"})); 13866 13867 Style.NamespaceMacros.clear(); 13868 CHECK_PARSE("NamespaceMacros: [TESTSUITE]", NamespaceMacros, 13869 std::vector<std::string>{"TESTSUITE"}); 13870 CHECK_PARSE("NamespaceMacros: [TESTSUITE, SUITE]", NamespaceMacros, 13871 std::vector<std::string>({"TESTSUITE", "SUITE"})); 13872 13873 Style.IncludeStyle.IncludeCategories.clear(); 13874 std::vector<tooling::IncludeStyle::IncludeCategory> ExpectedCategories = { 13875 {"abc/.*", 2, 0}, {".*", 1, 0}}; 13876 CHECK_PARSE("IncludeCategories:\n" 13877 " - Regex: abc/.*\n" 13878 " Priority: 2\n" 13879 " - Regex: .*\n" 13880 " Priority: 1", 13881 IncludeStyle.IncludeCategories, ExpectedCategories); 13882 CHECK_PARSE("IncludeIsMainRegex: 'abc$'", IncludeStyle.IncludeIsMainRegex, 13883 "abc$"); 13884 CHECK_PARSE("IncludeIsMainSourceRegex: 'abc$'", 13885 IncludeStyle.IncludeIsMainSourceRegex, "abc$"); 13886 13887 Style.RawStringFormats.clear(); 13888 std::vector<FormatStyle::RawStringFormat> ExpectedRawStringFormats = { 13889 { 13890 FormatStyle::LK_TextProto, 13891 {"pb", "proto"}, 13892 {"PARSE_TEXT_PROTO"}, 13893 /*CanonicalDelimiter=*/"", 13894 "llvm", 13895 }, 13896 { 13897 FormatStyle::LK_Cpp, 13898 {"cc", "cpp"}, 13899 {"C_CODEBLOCK", "CPPEVAL"}, 13900 /*CanonicalDelimiter=*/"cc", 13901 /*BasedOnStyle=*/"", 13902 }, 13903 }; 13904 13905 CHECK_PARSE("RawStringFormats:\n" 13906 " - Language: TextProto\n" 13907 " Delimiters:\n" 13908 " - 'pb'\n" 13909 " - 'proto'\n" 13910 " EnclosingFunctions:\n" 13911 " - 'PARSE_TEXT_PROTO'\n" 13912 " BasedOnStyle: llvm\n" 13913 " - Language: Cpp\n" 13914 " Delimiters:\n" 13915 " - 'cc'\n" 13916 " - 'cpp'\n" 13917 " EnclosingFunctions:\n" 13918 " - 'C_CODEBLOCK'\n" 13919 " - 'CPPEVAL'\n" 13920 " CanonicalDelimiter: 'cc'", 13921 RawStringFormats, ExpectedRawStringFormats); 13922 } 13923 13924 TEST_F(FormatTest, ParsesConfigurationWithLanguages) { 13925 FormatStyle Style = {}; 13926 Style.Language = FormatStyle::LK_Cpp; 13927 CHECK_PARSE("Language: Cpp\n" 13928 "IndentWidth: 12", 13929 IndentWidth, 12u); 13930 EXPECT_EQ(parseConfiguration("Language: JavaScript\n" 13931 "IndentWidth: 34", 13932 &Style), 13933 ParseError::Unsuitable); 13934 FormatStyle BinPackedTCS = {}; 13935 BinPackedTCS.Language = FormatStyle::LK_JavaScript; 13936 EXPECT_EQ(parseConfiguration("BinPackArguments: true\n" 13937 "InsertTrailingCommas: Wrapped", 13938 &BinPackedTCS), 13939 ParseError::BinPackTrailingCommaConflict); 13940 EXPECT_EQ(12u, Style.IndentWidth); 13941 CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u); 13942 EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language); 13943 13944 Style.Language = FormatStyle::LK_JavaScript; 13945 CHECK_PARSE("Language: JavaScript\n" 13946 "IndentWidth: 12", 13947 IndentWidth, 12u); 13948 CHECK_PARSE("IndentWidth: 23", IndentWidth, 23u); 13949 EXPECT_EQ(parseConfiguration("Language: Cpp\n" 13950 "IndentWidth: 34", 13951 &Style), 13952 ParseError::Unsuitable); 13953 EXPECT_EQ(23u, Style.IndentWidth); 13954 CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u); 13955 EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language); 13956 13957 CHECK_PARSE("BasedOnStyle: LLVM\n" 13958 "IndentWidth: 67", 13959 IndentWidth, 67u); 13960 13961 CHECK_PARSE("---\n" 13962 "Language: JavaScript\n" 13963 "IndentWidth: 12\n" 13964 "---\n" 13965 "Language: Cpp\n" 13966 "IndentWidth: 34\n" 13967 "...\n", 13968 IndentWidth, 12u); 13969 13970 Style.Language = FormatStyle::LK_Cpp; 13971 CHECK_PARSE("---\n" 13972 "Language: JavaScript\n" 13973 "IndentWidth: 12\n" 13974 "---\n" 13975 "Language: Cpp\n" 13976 "IndentWidth: 34\n" 13977 "...\n", 13978 IndentWidth, 34u); 13979 CHECK_PARSE("---\n" 13980 "IndentWidth: 78\n" 13981 "---\n" 13982 "Language: JavaScript\n" 13983 "IndentWidth: 56\n" 13984 "...\n", 13985 IndentWidth, 78u); 13986 13987 Style.ColumnLimit = 123; 13988 Style.IndentWidth = 234; 13989 Style.BreakBeforeBraces = FormatStyle::BS_Linux; 13990 Style.TabWidth = 345; 13991 EXPECT_FALSE(parseConfiguration("---\n" 13992 "IndentWidth: 456\n" 13993 "BreakBeforeBraces: Allman\n" 13994 "---\n" 13995 "Language: JavaScript\n" 13996 "IndentWidth: 111\n" 13997 "TabWidth: 111\n" 13998 "---\n" 13999 "Language: Cpp\n" 14000 "BreakBeforeBraces: Stroustrup\n" 14001 "TabWidth: 789\n" 14002 "...\n", 14003 &Style)); 14004 EXPECT_EQ(123u, Style.ColumnLimit); 14005 EXPECT_EQ(456u, Style.IndentWidth); 14006 EXPECT_EQ(FormatStyle::BS_Stroustrup, Style.BreakBeforeBraces); 14007 EXPECT_EQ(789u, Style.TabWidth); 14008 14009 EXPECT_EQ(parseConfiguration("---\n" 14010 "Language: JavaScript\n" 14011 "IndentWidth: 56\n" 14012 "---\n" 14013 "IndentWidth: 78\n" 14014 "...\n", 14015 &Style), 14016 ParseError::Error); 14017 EXPECT_EQ(parseConfiguration("---\n" 14018 "Language: JavaScript\n" 14019 "IndentWidth: 56\n" 14020 "---\n" 14021 "Language: JavaScript\n" 14022 "IndentWidth: 78\n" 14023 "...\n", 14024 &Style), 14025 ParseError::Error); 14026 14027 EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language); 14028 } 14029 14030 #undef CHECK_PARSE 14031 14032 TEST_F(FormatTest, UsesLanguageForBasedOnStyle) { 14033 FormatStyle Style = {}; 14034 Style.Language = FormatStyle::LK_JavaScript; 14035 Style.BreakBeforeTernaryOperators = true; 14036 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Style).value()); 14037 EXPECT_FALSE(Style.BreakBeforeTernaryOperators); 14038 14039 Style.BreakBeforeTernaryOperators = true; 14040 EXPECT_EQ(0, parseConfiguration("---\n" 14041 "BasedOnStyle: Google\n" 14042 "---\n" 14043 "Language: JavaScript\n" 14044 "IndentWidth: 76\n" 14045 "...\n", 14046 &Style) 14047 .value()); 14048 EXPECT_FALSE(Style.BreakBeforeTernaryOperators); 14049 EXPECT_EQ(76u, Style.IndentWidth); 14050 EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language); 14051 } 14052 14053 TEST_F(FormatTest, ConfigurationRoundTripTest) { 14054 FormatStyle Style = getLLVMStyle(); 14055 std::string YAML = configurationAsText(Style); 14056 FormatStyle ParsedStyle = {}; 14057 ParsedStyle.Language = FormatStyle::LK_Cpp; 14058 EXPECT_EQ(0, parseConfiguration(YAML, &ParsedStyle).value()); 14059 EXPECT_EQ(Style, ParsedStyle); 14060 } 14061 14062 TEST_F(FormatTest, WorksFor8bitEncodings) { 14063 EXPECT_EQ("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 \"\n" 14064 "\"\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \"\n" 14065 "\"\xe7\xe8\xec\xed\xfe\xfe \"\n" 14066 "\"\xef\xee\xf0\xf3...\"", 14067 format("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 " 14068 "\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \xe7\xe8\xec\xed\xfe\xfe " 14069 "\xef\xee\xf0\xf3...\"", 14070 getLLVMStyleWithColumns(12))); 14071 } 14072 14073 TEST_F(FormatTest, HandlesUTF8BOM) { 14074 EXPECT_EQ("\xef\xbb\xbf", format("\xef\xbb\xbf")); 14075 EXPECT_EQ("\xef\xbb\xbf#include <iostream>", 14076 format("\xef\xbb\xbf#include <iostream>")); 14077 EXPECT_EQ("\xef\xbb\xbf\n#include <iostream>", 14078 format("\xef\xbb\xbf\n#include <iostream>")); 14079 } 14080 14081 // FIXME: Encode Cyrillic and CJK characters below to appease MS compilers. 14082 #if !defined(_MSC_VER) 14083 14084 TEST_F(FormatTest, CountsUTF8CharactersProperly) { 14085 verifyFormat("\"Однажды в студёную зимнюю пору...\"", 14086 getLLVMStyleWithColumns(35)); 14087 verifyFormat("\"一 二 三 四 五 六 七 八 九 十\"", 14088 getLLVMStyleWithColumns(31)); 14089 verifyFormat("// Однажды в студёную зимнюю пору...", 14090 getLLVMStyleWithColumns(36)); 14091 verifyFormat("// 一 二 三 四 五 六 七 八 九 十", getLLVMStyleWithColumns(32)); 14092 verifyFormat("/* Однажды в студёную зимнюю пору... */", 14093 getLLVMStyleWithColumns(39)); 14094 verifyFormat("/* 一 二 三 四 五 六 七 八 九 十 */", 14095 getLLVMStyleWithColumns(35)); 14096 } 14097 14098 TEST_F(FormatTest, SplitsUTF8Strings) { 14099 // Non-printable characters' width is currently considered to be the length in 14100 // bytes in UTF8. The characters can be displayed in very different manner 14101 // (zero-width, single width with a substitution glyph, expanded to their code 14102 // (e.g. "<8d>"), so there's no single correct way to handle them. 14103 EXPECT_EQ("\"aaaaÄ\"\n" 14104 "\"\xc2\x8d\";", 14105 format("\"aaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10))); 14106 EXPECT_EQ("\"aaaaaaaÄ\"\n" 14107 "\"\xc2\x8d\";", 14108 format("\"aaaaaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10))); 14109 EXPECT_EQ("\"Однажды, в \"\n" 14110 "\"студёную \"\n" 14111 "\"зимнюю \"\n" 14112 "\"пору,\"", 14113 format("\"Однажды, в студёную зимнюю пору,\"", 14114 getLLVMStyleWithColumns(13))); 14115 EXPECT_EQ( 14116 "\"一 二 三 \"\n" 14117 "\"四 五六 \"\n" 14118 "\"七 八 九 \"\n" 14119 "\"十\"", 14120 format("\"一 二 三 四 五六 七 八 九 十\"", getLLVMStyleWithColumns(11))); 14121 EXPECT_EQ("\"一\t\"\n" 14122 "\"二 \t\"\n" 14123 "\"三 四 \"\n" 14124 "\"五\t\"\n" 14125 "\"六 \t\"\n" 14126 "\"七 \"\n" 14127 "\"八九十\tqq\"", 14128 format("\"一\t二 \t三 四 五\t六 \t七 八九十\tqq\"", 14129 getLLVMStyleWithColumns(11))); 14130 14131 // UTF8 character in an escape sequence. 14132 EXPECT_EQ("\"aaaaaa\"\n" 14133 "\"\\\xC2\x8D\"", 14134 format("\"aaaaaa\\\xC2\x8D\"", getLLVMStyleWithColumns(10))); 14135 } 14136 14137 TEST_F(FormatTest, HandlesDoubleWidthCharsInMultiLineStrings) { 14138 EXPECT_EQ("const char *sssss =\n" 14139 " \"一二三四五六七八\\\n" 14140 " 九 十\";", 14141 format("const char *sssss = \"一二三四五六七八\\\n" 14142 " 九 十\";", 14143 getLLVMStyleWithColumns(30))); 14144 } 14145 14146 TEST_F(FormatTest, SplitsUTF8LineComments) { 14147 EXPECT_EQ("// aaaaÄ\xc2\x8d", 14148 format("// aaaaÄ\xc2\x8d", getLLVMStyleWithColumns(10))); 14149 EXPECT_EQ("// Я из лесу\n" 14150 "// вышел; был\n" 14151 "// сильный\n" 14152 "// мороз.", 14153 format("// Я из лесу вышел; был сильный мороз.", 14154 getLLVMStyleWithColumns(13))); 14155 EXPECT_EQ("// 一二三\n" 14156 "// 四五六七\n" 14157 "// 八 九\n" 14158 "// 十", 14159 format("// 一二三 四五六七 八 九 十", getLLVMStyleWithColumns(9))); 14160 } 14161 14162 TEST_F(FormatTest, SplitsUTF8BlockComments) { 14163 EXPECT_EQ("/* Гляжу,\n" 14164 " * поднимается\n" 14165 " * медленно в\n" 14166 " * гору\n" 14167 " * Лошадка,\n" 14168 " * везущая\n" 14169 " * хворосту\n" 14170 " * воз. */", 14171 format("/* Гляжу, поднимается медленно в гору\n" 14172 " * Лошадка, везущая хворосту воз. */", 14173 getLLVMStyleWithColumns(13))); 14174 EXPECT_EQ( 14175 "/* 一二三\n" 14176 " * 四五六七\n" 14177 " * 八 九\n" 14178 " * 十 */", 14179 format("/* 一二三 四五六七 八 九 十 */", getLLVMStyleWithColumns(9))); 14180 EXPECT_EQ("/* �������� ��������\n" 14181 " * ��������\n" 14182 " * ������-�� */", 14183 format("/* �������� �������� �������� ������-�� */", getLLVMStyleWithColumns(12))); 14184 } 14185 14186 #endif // _MSC_VER 14187 14188 TEST_F(FormatTest, ConstructorInitializerIndentWidth) { 14189 FormatStyle Style = getLLVMStyle(); 14190 14191 Style.ConstructorInitializerIndentWidth = 4; 14192 verifyFormat( 14193 "SomeClass::Constructor()\n" 14194 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 14195 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 14196 Style); 14197 14198 Style.ConstructorInitializerIndentWidth = 2; 14199 verifyFormat( 14200 "SomeClass::Constructor()\n" 14201 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 14202 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 14203 Style); 14204 14205 Style.ConstructorInitializerIndentWidth = 0; 14206 verifyFormat( 14207 "SomeClass::Constructor()\n" 14208 ": aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 14209 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 14210 Style); 14211 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 14212 verifyFormat( 14213 "SomeLongTemplateVariableName<\n" 14214 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>", 14215 Style); 14216 verifyFormat("bool smaller = 1 < " 14217 "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 14218 " " 14219 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 14220 Style); 14221 14222 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 14223 verifyFormat("SomeClass::Constructor() :\n" 14224 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa),\n" 14225 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa) {}", 14226 Style); 14227 } 14228 14229 TEST_F(FormatTest, BreakConstructorInitializersBeforeComma) { 14230 FormatStyle Style = getLLVMStyle(); 14231 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 14232 Style.ConstructorInitializerIndentWidth = 4; 14233 verifyFormat("SomeClass::Constructor()\n" 14234 " : a(a)\n" 14235 " , b(b)\n" 14236 " , c(c) {}", 14237 Style); 14238 verifyFormat("SomeClass::Constructor()\n" 14239 " : a(a) {}", 14240 Style); 14241 14242 Style.ColumnLimit = 0; 14243 verifyFormat("SomeClass::Constructor()\n" 14244 " : a(a) {}", 14245 Style); 14246 verifyFormat("SomeClass::Constructor() noexcept\n" 14247 " : a(a) {}", 14248 Style); 14249 verifyFormat("SomeClass::Constructor()\n" 14250 " : a(a)\n" 14251 " , b(b)\n" 14252 " , c(c) {}", 14253 Style); 14254 verifyFormat("SomeClass::Constructor()\n" 14255 " : a(a) {\n" 14256 " foo();\n" 14257 " bar();\n" 14258 "}", 14259 Style); 14260 14261 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 14262 verifyFormat("SomeClass::Constructor()\n" 14263 " : a(a)\n" 14264 " , b(b)\n" 14265 " , c(c) {\n}", 14266 Style); 14267 verifyFormat("SomeClass::Constructor()\n" 14268 " : a(a) {\n}", 14269 Style); 14270 14271 Style.ColumnLimit = 80; 14272 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 14273 Style.ConstructorInitializerIndentWidth = 2; 14274 verifyFormat("SomeClass::Constructor()\n" 14275 " : a(a)\n" 14276 " , b(b)\n" 14277 " , c(c) {}", 14278 Style); 14279 14280 Style.ConstructorInitializerIndentWidth = 0; 14281 verifyFormat("SomeClass::Constructor()\n" 14282 ": a(a)\n" 14283 ", b(b)\n" 14284 ", c(c) {}", 14285 Style); 14286 14287 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 14288 Style.ConstructorInitializerIndentWidth = 4; 14289 verifyFormat("SomeClass::Constructor() : aaaaaaaa(aaaaaaaa) {}", Style); 14290 verifyFormat( 14291 "SomeClass::Constructor() : aaaaa(aaaaa), aaaaa(aaaaa), aaaaa(aaaaa)\n", 14292 Style); 14293 verifyFormat( 14294 "SomeClass::Constructor()\n" 14295 " : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa) {}", 14296 Style); 14297 Style.ConstructorInitializerIndentWidth = 4; 14298 Style.ColumnLimit = 60; 14299 verifyFormat("SomeClass::Constructor()\n" 14300 " : aaaaaaaa(aaaaaaaa)\n" 14301 " , aaaaaaaa(aaaaaaaa)\n" 14302 " , aaaaaaaa(aaaaaaaa) {}", 14303 Style); 14304 } 14305 14306 TEST_F(FormatTest, Destructors) { 14307 verifyFormat("void F(int &i) { i.~int(); }"); 14308 verifyFormat("void F(int &i) { i->~int(); }"); 14309 } 14310 14311 TEST_F(FormatTest, FormatsWithWebKitStyle) { 14312 FormatStyle Style = getWebKitStyle(); 14313 14314 // Don't indent in outer namespaces. 14315 verifyFormat("namespace outer {\n" 14316 "int i;\n" 14317 "namespace inner {\n" 14318 " int i;\n" 14319 "} // namespace inner\n" 14320 "} // namespace outer\n" 14321 "namespace other_outer {\n" 14322 "int i;\n" 14323 "}", 14324 Style); 14325 14326 // Don't indent case labels. 14327 verifyFormat("switch (variable) {\n" 14328 "case 1:\n" 14329 "case 2:\n" 14330 " doSomething();\n" 14331 " break;\n" 14332 "default:\n" 14333 " ++variable;\n" 14334 "}", 14335 Style); 14336 14337 // Wrap before binary operators. 14338 EXPECT_EQ("void f()\n" 14339 "{\n" 14340 " if (aaaaaaaaaaaaaaaa\n" 14341 " && bbbbbbbbbbbbbbbbbbbbbbbb\n" 14342 " && (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n" 14343 " return;\n" 14344 "}", 14345 format("void f() {\n" 14346 "if (aaaaaaaaaaaaaaaa\n" 14347 "&& bbbbbbbbbbbbbbbbbbbbbbbb\n" 14348 "&& (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n" 14349 "return;\n" 14350 "}", 14351 Style)); 14352 14353 // Allow functions on a single line. 14354 verifyFormat("void f() { return; }", Style); 14355 14356 // Allow empty blocks on a single line and insert a space in empty blocks. 14357 EXPECT_EQ("void f() { }", format("void f() {}", Style)); 14358 EXPECT_EQ("while (true) { }", format("while (true) {}", Style)); 14359 // However, don't merge non-empty short loops. 14360 EXPECT_EQ("while (true) {\n" 14361 " continue;\n" 14362 "}", 14363 format("while (true) { continue; }", Style)); 14364 14365 // Constructor initializers are formatted one per line with the "," on the 14366 // new line. 14367 verifyFormat("Constructor()\n" 14368 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 14369 " , aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaa, // break\n" 14370 " aaaaaaaaaaaaaa)\n" 14371 " , aaaaaaaaaaaaaaaaaaaaaaa()\n" 14372 "{\n" 14373 "}", 14374 Style); 14375 verifyFormat("SomeClass::Constructor()\n" 14376 " : a(a)\n" 14377 "{\n" 14378 "}", 14379 Style); 14380 EXPECT_EQ("SomeClass::Constructor()\n" 14381 " : a(a)\n" 14382 "{\n" 14383 "}", 14384 format("SomeClass::Constructor():a(a){}", Style)); 14385 verifyFormat("SomeClass::Constructor()\n" 14386 " : a(a)\n" 14387 " , b(b)\n" 14388 " , c(c)\n" 14389 "{\n" 14390 "}", 14391 Style); 14392 verifyFormat("SomeClass::Constructor()\n" 14393 " : a(a)\n" 14394 "{\n" 14395 " foo();\n" 14396 " bar();\n" 14397 "}", 14398 Style); 14399 14400 // Access specifiers should be aligned left. 14401 verifyFormat("class C {\n" 14402 "public:\n" 14403 " int i;\n" 14404 "};", 14405 Style); 14406 14407 // Do not align comments. 14408 verifyFormat("int a; // Do not\n" 14409 "double b; // align comments.", 14410 Style); 14411 14412 // Do not align operands. 14413 EXPECT_EQ("ASSERT(aaaa\n" 14414 " || bbbb);", 14415 format("ASSERT ( aaaa\n||bbbb);", Style)); 14416 14417 // Accept input's line breaks. 14418 EXPECT_EQ("if (aaaaaaaaaaaaaaa\n" 14419 " || bbbbbbbbbbbbbbb) {\n" 14420 " i++;\n" 14421 "}", 14422 format("if (aaaaaaaaaaaaaaa\n" 14423 "|| bbbbbbbbbbbbbbb) { i++; }", 14424 Style)); 14425 EXPECT_EQ("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) {\n" 14426 " i++;\n" 14427 "}", 14428 format("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) { i++; }", Style)); 14429 14430 // Don't automatically break all macro definitions (llvm.org/PR17842). 14431 verifyFormat("#define aNumber 10", Style); 14432 // However, generally keep the line breaks that the user authored. 14433 EXPECT_EQ("#define aNumber \\\n" 14434 " 10", 14435 format("#define aNumber \\\n" 14436 " 10", 14437 Style)); 14438 14439 // Keep empty and one-element array literals on a single line. 14440 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[]\n" 14441 " copyItems:YES];", 14442 format("NSArray*a=[[NSArray alloc] initWithArray:@[]\n" 14443 "copyItems:YES];", 14444 Style)); 14445 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\" ]\n" 14446 " copyItems:YES];", 14447 format("NSArray*a=[[NSArray alloc]initWithArray:@[ @\"a\" ]\n" 14448 " copyItems:YES];", 14449 Style)); 14450 // FIXME: This does not seem right, there should be more indentation before 14451 // the array literal's entries. Nested blocks have the same problem. 14452 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[\n" 14453 " @\"a\",\n" 14454 " @\"a\"\n" 14455 "]\n" 14456 " copyItems:YES];", 14457 format("NSArray* a = [[NSArray alloc] initWithArray:@[\n" 14458 " @\"a\",\n" 14459 " @\"a\"\n" 14460 " ]\n" 14461 " copyItems:YES];", 14462 Style)); 14463 EXPECT_EQ( 14464 "NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n" 14465 " copyItems:YES];", 14466 format("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n" 14467 " copyItems:YES];", 14468 Style)); 14469 14470 verifyFormat("[self.a b:c c:d];", Style); 14471 EXPECT_EQ("[self.a b:c\n" 14472 " c:d];", 14473 format("[self.a b:c\n" 14474 "c:d];", 14475 Style)); 14476 } 14477 14478 TEST_F(FormatTest, FormatsLambdas) { 14479 verifyFormat("int c = [b]() mutable { return [&b] { return b++; }(); }();\n"); 14480 verifyFormat( 14481 "int c = [b]() mutable noexcept { return [&b] { return b++; }(); }();\n"); 14482 verifyFormat("int c = [&] { [=] { return b++; }(); }();\n"); 14483 verifyFormat("int c = [&, &a, a] { [=, c, &d] { return b++; }(); }();\n"); 14484 verifyFormat("int c = [&a, &a, a] { [=, a, b, &c] { return b++; }(); }();\n"); 14485 verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] { return b++; }(); }}\n"); 14486 verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] {}(); }}\n"); 14487 verifyFormat("auto c = [a = [b = 42] {}] {};\n"); 14488 verifyFormat("auto c = [a = &i + 10, b = [] {}] {};\n"); 14489 verifyFormat("int x = f(*+[] {});"); 14490 verifyFormat("void f() {\n" 14491 " other(x.begin(), x.end(), [&](int, int) { return 1; });\n" 14492 "}\n"); 14493 verifyFormat("void f() {\n" 14494 " other(x.begin(), //\n" 14495 " x.end(), //\n" 14496 " [&](int, int) { return 1; });\n" 14497 "}\n"); 14498 verifyFormat("void f() {\n" 14499 " other.other.other.other.other(\n" 14500 " x.begin(), x.end(),\n" 14501 " [something, rather](int, int, int, int, int, int, int) { " 14502 "return 1; });\n" 14503 "}\n"); 14504 verifyFormat( 14505 "void f() {\n" 14506 " other.other.other.other.other(\n" 14507 " x.begin(), x.end(),\n" 14508 " [something, rather](int, int, int, int, int, int, int) {\n" 14509 " //\n" 14510 " });\n" 14511 "}\n"); 14512 verifyFormat("SomeFunction([]() { // A cool function...\n" 14513 " return 43;\n" 14514 "});"); 14515 EXPECT_EQ("SomeFunction([]() {\n" 14516 "#define A a\n" 14517 " return 43;\n" 14518 "});", 14519 format("SomeFunction([](){\n" 14520 "#define A a\n" 14521 "return 43;\n" 14522 "});")); 14523 verifyFormat("void f() {\n" 14524 " SomeFunction([](decltype(x), A *a) {});\n" 14525 "}"); 14526 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 14527 " [](const aaaaaaaaaa &a) { return a; });"); 14528 verifyFormat("string abc = SomeFunction(aaaaaaaaaaaaa, aaaaa, []() {\n" 14529 " SomeOtherFunctioooooooooooooooooooooooooon();\n" 14530 "});"); 14531 verifyFormat("Constructor()\n" 14532 " : Field([] { // comment\n" 14533 " int i;\n" 14534 " }) {}"); 14535 verifyFormat("auto my_lambda = [](const string &some_parameter) {\n" 14536 " return some_parameter.size();\n" 14537 "};"); 14538 verifyFormat("std::function<std::string(const std::string &)> my_lambda =\n" 14539 " [](const string &s) { return s; };"); 14540 verifyFormat("int i = aaaaaa ? 1 //\n" 14541 " : [] {\n" 14542 " return 2; //\n" 14543 " }();"); 14544 verifyFormat("llvm::errs() << \"number of twos is \"\n" 14545 " << std::count_if(v.begin(), v.end(), [](int x) {\n" 14546 " return x == 2; // force break\n" 14547 " });"); 14548 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 14549 " [=](int iiiiiiiiiiii) {\n" 14550 " return aaaaaaaaaaaaaaaaaaaaaaa !=\n" 14551 " aaaaaaaaaaaaaaaaaaaaaaa;\n" 14552 " });", 14553 getLLVMStyleWithColumns(60)); 14554 verifyFormat("SomeFunction({[&] {\n" 14555 " // comment\n" 14556 " },\n" 14557 " [&] {\n" 14558 " // comment\n" 14559 " }});"); 14560 verifyFormat("SomeFunction({[&] {\n" 14561 " // comment\n" 14562 "}});"); 14563 verifyFormat( 14564 "virtual aaaaaaaaaaaaaaaa(\n" 14565 " std::function<bool()> bbbbbbbbbbbb = [&]() { return true; },\n" 14566 " aaaaa aaaaaaaaa);"); 14567 14568 // Lambdas with return types. 14569 verifyFormat("int c = []() -> int { return 2; }();\n"); 14570 verifyFormat("int c = []() -> int * { return 2; }();\n"); 14571 verifyFormat("int c = []() -> vector<int> { return {2}; }();\n"); 14572 verifyFormat("Foo([]() -> std::vector<int> { return {2}; }());"); 14573 verifyGoogleFormat("auto a = [&b, c](D* d) -> D* {};"); 14574 verifyGoogleFormat("auto a = [&b, c](D* d) -> pair<D*, D*> {};"); 14575 verifyGoogleFormat("auto a = [&b, c](D* d) -> D& {};"); 14576 verifyGoogleFormat("auto a = [&b, c](D* d) -> const D* {};"); 14577 verifyFormat("[a, a]() -> a<1> {};"); 14578 verifyFormat("[]() -> foo<5 + 2> { return {}; };"); 14579 verifyFormat("[]() -> foo<5 - 2> { return {}; };"); 14580 verifyFormat("[]() -> foo<5 / 2> { return {}; };"); 14581 verifyFormat("[]() -> foo<5 * 2> { return {}; };"); 14582 verifyFormat("[]() -> foo<5 % 2> { return {}; };"); 14583 verifyFormat("[]() -> foo<5 << 2> { return {}; };"); 14584 verifyFormat("[]() -> foo<!5> { return {}; };"); 14585 verifyFormat("[]() -> foo<~5> { return {}; };"); 14586 verifyFormat("[]() -> foo<5 | 2> { return {}; };"); 14587 verifyFormat("[]() -> foo<5 || 2> { return {}; };"); 14588 verifyFormat("[]() -> foo<5 & 2> { return {}; };"); 14589 verifyFormat("[]() -> foo<5 && 2> { return {}; };"); 14590 verifyFormat("[]() -> foo<5 == 2> { return {}; };"); 14591 verifyFormat("[]() -> foo<5 != 2> { return {}; };"); 14592 verifyFormat("[]() -> foo<5 >= 2> { return {}; };"); 14593 verifyFormat("[]() -> foo<5 <= 2> { return {}; };"); 14594 verifyFormat("[]() -> foo<5 < 2> { return {}; };"); 14595 verifyFormat("[]() -> foo<2 ? 1 : 0> { return {}; };"); 14596 verifyFormat("namespace bar {\n" 14597 "// broken:\n" 14598 "auto foo{[]() -> foo<5 + 2> { return {}; }};\n" 14599 "} // namespace bar"); 14600 verifyFormat("namespace bar {\n" 14601 "// broken:\n" 14602 "auto foo{[]() -> foo<5 - 2> { return {}; }};\n" 14603 "} // namespace bar"); 14604 verifyFormat("namespace bar {\n" 14605 "// broken:\n" 14606 "auto foo{[]() -> foo<5 / 2> { return {}; }};\n" 14607 "} // namespace bar"); 14608 verifyFormat("namespace bar {\n" 14609 "// broken:\n" 14610 "auto foo{[]() -> foo<5 * 2> { return {}; }};\n" 14611 "} // namespace bar"); 14612 verifyFormat("namespace bar {\n" 14613 "// broken:\n" 14614 "auto foo{[]() -> foo<5 % 2> { return {}; }};\n" 14615 "} // namespace bar"); 14616 verifyFormat("namespace bar {\n" 14617 "// broken:\n" 14618 "auto foo{[]() -> foo<5 << 2> { return {}; }};\n" 14619 "} // namespace bar"); 14620 verifyFormat("namespace bar {\n" 14621 "// broken:\n" 14622 "auto foo{[]() -> foo<!5> { return {}; }};\n" 14623 "} // namespace bar"); 14624 verifyFormat("namespace bar {\n" 14625 "// broken:\n" 14626 "auto foo{[]() -> foo<~5> { return {}; }};\n" 14627 "} // namespace bar"); 14628 verifyFormat("namespace bar {\n" 14629 "// broken:\n" 14630 "auto foo{[]() -> foo<5 | 2> { return {}; }};\n" 14631 "} // namespace bar"); 14632 verifyFormat("namespace bar {\n" 14633 "// broken:\n" 14634 "auto foo{[]() -> foo<5 || 2> { return {}; }};\n" 14635 "} // namespace bar"); 14636 verifyFormat("namespace bar {\n" 14637 "// broken:\n" 14638 "auto foo{[]() -> foo<5 & 2> { return {}; }};\n" 14639 "} // namespace bar"); 14640 verifyFormat("namespace bar {\n" 14641 "// broken:\n" 14642 "auto foo{[]() -> foo<5 && 2> { return {}; }};\n" 14643 "} // namespace bar"); 14644 verifyFormat("namespace bar {\n" 14645 "// broken:\n" 14646 "auto foo{[]() -> foo<5 == 2> { return {}; }};\n" 14647 "} // namespace bar"); 14648 verifyFormat("namespace bar {\n" 14649 "// broken:\n" 14650 "auto foo{[]() -> foo<5 != 2> { return {}; }};\n" 14651 "} // namespace bar"); 14652 verifyFormat("namespace bar {\n" 14653 "// broken:\n" 14654 "auto foo{[]() -> foo<5 >= 2> { return {}; }};\n" 14655 "} // namespace bar"); 14656 verifyFormat("namespace bar {\n" 14657 "// broken:\n" 14658 "auto foo{[]() -> foo<5 <= 2> { return {}; }};\n" 14659 "} // namespace bar"); 14660 verifyFormat("namespace bar {\n" 14661 "// broken:\n" 14662 "auto foo{[]() -> foo<5 < 2> { return {}; }};\n" 14663 "} // namespace bar"); 14664 verifyFormat("namespace bar {\n" 14665 "// broken:\n" 14666 "auto foo{[]() -> foo<2 ? 1 : 0> { return {}; }};\n" 14667 "} // namespace bar"); 14668 verifyFormat("[]() -> a<1> {};"); 14669 verifyFormat("[]() -> a<1> { ; };"); 14670 verifyFormat("[]() -> a<1> { ; }();"); 14671 verifyFormat("[a, a]() -> a<true> {};"); 14672 verifyFormat("[]() -> a<true> {};"); 14673 verifyFormat("[]() -> a<true> { ; };"); 14674 verifyFormat("[]() -> a<true> { ; }();"); 14675 verifyFormat("[a, a]() -> a<false> {};"); 14676 verifyFormat("[]() -> a<false> {};"); 14677 verifyFormat("[]() -> a<false> { ; };"); 14678 verifyFormat("[]() -> a<false> { ; }();"); 14679 verifyFormat("auto foo{[]() -> foo<false> { ; }};"); 14680 verifyFormat("namespace bar {\n" 14681 "auto foo{[]() -> foo<false> { ; }};\n" 14682 "} // namespace bar"); 14683 verifyFormat("auto aaaaaaaa = [](int i, // break for some reason\n" 14684 " int j) -> int {\n" 14685 " return ffffffffffffffffffffffffffffffffffffffffffff(i * j);\n" 14686 "};"); 14687 verifyFormat( 14688 "aaaaaaaaaaaaaaaaaaaaaa(\n" 14689 " [](aaaaaaaaaaaaaaaaaaaaaaaaaaa &aaa) -> aaaaaaaaaaaaaaaa {\n" 14690 " return aaaaaaaaaaaaaaaaa;\n" 14691 " });", 14692 getLLVMStyleWithColumns(70)); 14693 verifyFormat("[]() //\n" 14694 " -> int {\n" 14695 " return 1; //\n" 14696 "};"); 14697 verifyFormat("[]() -> Void<T...> {};"); 14698 verifyFormat("[a, b]() -> Tuple<T...> { return {}; };"); 14699 14700 // Lambdas with explicit template argument lists. 14701 verifyFormat( 14702 "auto L = []<template <typename> class T, class U>(T<U> &&a) {};\n"); 14703 14704 // Multiple lambdas in the same parentheses change indentation rules. These 14705 // lambdas are forced to start on new lines. 14706 verifyFormat("SomeFunction(\n" 14707 " []() {\n" 14708 " //\n" 14709 " },\n" 14710 " []() {\n" 14711 " //\n" 14712 " });"); 14713 14714 // A lambda passed as arg0 is always pushed to the next line. 14715 verifyFormat("SomeFunction(\n" 14716 " [this] {\n" 14717 " //\n" 14718 " },\n" 14719 " 1);\n"); 14720 14721 // A multi-line lambda passed as arg1 forces arg0 to be pushed out, just like 14722 // the arg0 case above. 14723 auto Style = getGoogleStyle(); 14724 Style.BinPackArguments = false; 14725 verifyFormat("SomeFunction(\n" 14726 " a,\n" 14727 " [this] {\n" 14728 " //\n" 14729 " },\n" 14730 " b);\n", 14731 Style); 14732 verifyFormat("SomeFunction(\n" 14733 " a,\n" 14734 " [this] {\n" 14735 " //\n" 14736 " },\n" 14737 " b);\n"); 14738 14739 // A lambda with a very long line forces arg0 to be pushed out irrespective of 14740 // the BinPackArguments value (as long as the code is wide enough). 14741 verifyFormat( 14742 "something->SomeFunction(\n" 14743 " a,\n" 14744 " [this] {\n" 14745 " " 14746 "D0000000000000000000000000000000000000000000000000000000000001();\n" 14747 " },\n" 14748 " b);\n"); 14749 14750 // A multi-line lambda is pulled up as long as the introducer fits on the 14751 // previous line and there are no further args. 14752 verifyFormat("function(1, [this, that] {\n" 14753 " //\n" 14754 "});\n"); 14755 verifyFormat("function([this, that] {\n" 14756 " //\n" 14757 "});\n"); 14758 // FIXME: this format is not ideal and we should consider forcing the first 14759 // arg onto its own line. 14760 verifyFormat("function(a, b, c, //\n" 14761 " d, [this, that] {\n" 14762 " //\n" 14763 " });\n"); 14764 14765 // Multiple lambdas are treated correctly even when there is a short arg0. 14766 verifyFormat("SomeFunction(\n" 14767 " 1,\n" 14768 " [this] {\n" 14769 " //\n" 14770 " },\n" 14771 " [this] {\n" 14772 " //\n" 14773 " },\n" 14774 " 1);\n"); 14775 14776 // More complex introducers. 14777 verifyFormat("return [i, args...] {};"); 14778 14779 // Not lambdas. 14780 verifyFormat("constexpr char hello[]{\"hello\"};"); 14781 verifyFormat("double &operator[](int i) { return 0; }\n" 14782 "int i;"); 14783 verifyFormat("std::unique_ptr<int[]> foo() {}"); 14784 verifyFormat("int i = a[a][a]->f();"); 14785 verifyFormat("int i = (*b)[a]->f();"); 14786 14787 // Other corner cases. 14788 verifyFormat("void f() {\n" 14789 " bar([]() {} // Did not respect SpacesBeforeTrailingComments\n" 14790 " );\n" 14791 "}"); 14792 14793 // Lambdas created through weird macros. 14794 verifyFormat("void f() {\n" 14795 " MACRO((const AA &a) { return 1; });\n" 14796 " MACRO((AA &a) { return 1; });\n" 14797 "}"); 14798 14799 verifyFormat("if (blah_blah(whatever, whatever, [] {\n" 14800 " doo_dah();\n" 14801 " doo_dah();\n" 14802 " })) {\n" 14803 "}"); 14804 verifyFormat("if constexpr (blah_blah(whatever, whatever, [] {\n" 14805 " doo_dah();\n" 14806 " doo_dah();\n" 14807 " })) {\n" 14808 "}"); 14809 verifyFormat("if CONSTEXPR (blah_blah(whatever, whatever, [] {\n" 14810 " doo_dah();\n" 14811 " doo_dah();\n" 14812 " })) {\n" 14813 "}"); 14814 verifyFormat("auto lambda = []() {\n" 14815 " int a = 2\n" 14816 "#if A\n" 14817 " + 2\n" 14818 "#endif\n" 14819 " ;\n" 14820 "};"); 14821 14822 // Lambdas with complex multiline introducers. 14823 verifyFormat( 14824 "aaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 14825 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]()\n" 14826 " -> ::std::unordered_set<\n" 14827 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> {\n" 14828 " //\n" 14829 " });"); 14830 14831 FormatStyle DoNotMerge = getLLVMStyle(); 14832 DoNotMerge.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None; 14833 verifyFormat("auto c = []() {\n" 14834 " return b;\n" 14835 "};", 14836 "auto c = []() { return b; };", DoNotMerge); 14837 verifyFormat("auto c = []() {\n" 14838 "};", 14839 " auto c = []() {};", DoNotMerge); 14840 14841 FormatStyle MergeEmptyOnly = getLLVMStyle(); 14842 MergeEmptyOnly.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Empty; 14843 verifyFormat("auto c = []() {\n" 14844 " return b;\n" 14845 "};", 14846 "auto c = []() {\n" 14847 " return b;\n" 14848 " };", 14849 MergeEmptyOnly); 14850 verifyFormat("auto c = []() {};", 14851 "auto c = []() {\n" 14852 "};", 14853 MergeEmptyOnly); 14854 14855 FormatStyle MergeInline = getLLVMStyle(); 14856 MergeInline.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Inline; 14857 verifyFormat("auto c = []() {\n" 14858 " return b;\n" 14859 "};", 14860 "auto c = []() { return b; };", MergeInline); 14861 verifyFormat("function([]() { return b; })", "function([]() { return b; })", 14862 MergeInline); 14863 verifyFormat("function([]() { return b; }, a)", 14864 "function([]() { return b; }, a)", MergeInline); 14865 verifyFormat("function(a, []() { return b; })", 14866 "function(a, []() { return b; })", MergeInline); 14867 14868 // Check option "BraceWrapping.BeforeLambdaBody" and different state of 14869 // AllowShortLambdasOnASingleLine 14870 FormatStyle LLVMWithBeforeLambdaBody = getLLVMStyle(); 14871 LLVMWithBeforeLambdaBody.BreakBeforeBraces = FormatStyle::BS_Custom; 14872 LLVMWithBeforeLambdaBody.BraceWrapping.BeforeLambdaBody = true; 14873 LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine = 14874 FormatStyle::ShortLambdaStyle::SLS_None; 14875 verifyFormat("FctWithOneNestedLambdaInline_SLS_None(\n" 14876 " []()\n" 14877 " {\n" 14878 " return 17;\n" 14879 " });", 14880 LLVMWithBeforeLambdaBody); 14881 verifyFormat("FctWithOneNestedLambdaEmpty_SLS_None(\n" 14882 " []()\n" 14883 " {\n" 14884 " });", 14885 LLVMWithBeforeLambdaBody); 14886 verifyFormat("auto fct_SLS_None = []()\n" 14887 "{\n" 14888 " return 17;\n" 14889 "};", 14890 LLVMWithBeforeLambdaBody); 14891 verifyFormat("TwoNestedLambdas_SLS_None(\n" 14892 " []()\n" 14893 " {\n" 14894 " return Call(\n" 14895 " []()\n" 14896 " {\n" 14897 " return 17;\n" 14898 " });\n" 14899 " });", 14900 LLVMWithBeforeLambdaBody); 14901 verifyFormat("void Fct()\n" 14902 "{\n" 14903 " return {[]()\n" 14904 " {\n" 14905 " return 17;\n" 14906 " }};\n" 14907 "}", 14908 LLVMWithBeforeLambdaBody); 14909 14910 LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine = 14911 FormatStyle::ShortLambdaStyle::SLS_Empty; 14912 verifyFormat("FctWithOneNestedLambdaInline_SLS_Empty(\n" 14913 " []()\n" 14914 " {\n" 14915 " return 17;\n" 14916 " });", 14917 LLVMWithBeforeLambdaBody); 14918 verifyFormat("FctWithOneNestedLambdaEmpty_SLS_Empty([]() {});", 14919 LLVMWithBeforeLambdaBody); 14920 verifyFormat("FctWithOneNestedLambdaEmptyInsideAVeryVeryVeryVeryVeryVeryVeryL" 14921 "ongFunctionName_SLS_Empty(\n" 14922 " []() {});", 14923 LLVMWithBeforeLambdaBody); 14924 verifyFormat("FctWithMultipleParams_SLS_Empty(A, B,\n" 14925 " []()\n" 14926 " {\n" 14927 " return 17;\n" 14928 " });", 14929 LLVMWithBeforeLambdaBody); 14930 verifyFormat("auto fct_SLS_Empty = []()\n" 14931 "{\n" 14932 " return 17;\n" 14933 "};", 14934 LLVMWithBeforeLambdaBody); 14935 verifyFormat("TwoNestedLambdas_SLS_Empty(\n" 14936 " []()\n" 14937 " {\n" 14938 " return Call([]() {});\n" 14939 " });", 14940 LLVMWithBeforeLambdaBody); 14941 verifyFormat("TwoNestedLambdas_SLS_Empty(A,\n" 14942 " []()\n" 14943 " {\n" 14944 " return Call([]() {});\n" 14945 " });", 14946 LLVMWithBeforeLambdaBody); 14947 verifyFormat( 14948 "FctWithLongLineInLambda_SLS_Empty(\n" 14949 " []()\n" 14950 " {\n" 14951 " return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n" 14952 " AndShouldNotBeConsiderAsInline,\n" 14953 " LambdaBodyMustBeBreak);\n" 14954 " });", 14955 LLVMWithBeforeLambdaBody); 14956 14957 LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine = 14958 FormatStyle::ShortLambdaStyle::SLS_Inline; 14959 verifyFormat("FctWithOneNestedLambdaInline_SLS_Inline([]() { return 17; });", 14960 LLVMWithBeforeLambdaBody); 14961 verifyFormat("FctWithOneNestedLambdaEmpty_SLS_Inline([]() {});", 14962 LLVMWithBeforeLambdaBody); 14963 verifyFormat("auto fct_SLS_Inline = []()\n" 14964 "{\n" 14965 " return 17;\n" 14966 "};", 14967 LLVMWithBeforeLambdaBody); 14968 verifyFormat("TwoNestedLambdas_SLS_Inline([]() { return Call([]() { return " 14969 "17; }); });", 14970 LLVMWithBeforeLambdaBody); 14971 verifyFormat( 14972 "FctWithLongLineInLambda_SLS_Inline(\n" 14973 " []()\n" 14974 " {\n" 14975 " return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n" 14976 " AndShouldNotBeConsiderAsInline,\n" 14977 " LambdaBodyMustBeBreak);\n" 14978 " });", 14979 LLVMWithBeforeLambdaBody); 14980 verifyFormat("FctWithMultipleParams_SLS_Inline(" 14981 "VeryLongParameterThatShouldAskToBeOnMultiLine,\n" 14982 " []() { return 17; });", 14983 LLVMWithBeforeLambdaBody); 14984 verifyFormat( 14985 "FctWithMultipleParams_SLS_Inline(FirstParam, []() { return 17; });", 14986 LLVMWithBeforeLambdaBody); 14987 14988 LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine = 14989 FormatStyle::ShortLambdaStyle::SLS_All; 14990 verifyFormat("FctWithOneNestedLambdaInline_SLS_All([]() { return 17; });", 14991 LLVMWithBeforeLambdaBody); 14992 verifyFormat("FctWithOneNestedLambdaEmpty_SLS_All([]() {});", 14993 LLVMWithBeforeLambdaBody); 14994 verifyFormat("auto fct_SLS_All = []() { return 17; };", 14995 LLVMWithBeforeLambdaBody); 14996 verifyFormat("FctWithOneParam_SLS_All(\n" 14997 " []()\n" 14998 " {\n" 14999 " // A cool function...\n" 15000 " return 43;\n" 15001 " });", 15002 LLVMWithBeforeLambdaBody); 15003 verifyFormat("FctWithMultipleParams_SLS_All(" 15004 "VeryLongParameterThatShouldAskToBeOnMultiLine,\n" 15005 " []() { return 17; });", 15006 LLVMWithBeforeLambdaBody); 15007 verifyFormat("FctWithMultipleParams_SLS_All(A, []() { return 17; });", 15008 LLVMWithBeforeLambdaBody); 15009 verifyFormat("FctWithMultipleParams_SLS_All(A, B, []() { return 17; });", 15010 LLVMWithBeforeLambdaBody); 15011 verifyFormat( 15012 "FctWithLongLineInLambda_SLS_All(\n" 15013 " []()\n" 15014 " {\n" 15015 " return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n" 15016 " AndShouldNotBeConsiderAsInline,\n" 15017 " LambdaBodyMustBeBreak);\n" 15018 " });", 15019 LLVMWithBeforeLambdaBody); 15020 verifyFormat( 15021 "auto fct_SLS_All = []()\n" 15022 "{\n" 15023 " return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n" 15024 " AndShouldNotBeConsiderAsInline,\n" 15025 " LambdaBodyMustBeBreak);\n" 15026 "};", 15027 LLVMWithBeforeLambdaBody); 15028 LLVMWithBeforeLambdaBody.BinPackParameters = false; 15029 verifyFormat("FctAllOnSameLine_SLS_All([]() { return S; }, Fst, Second);", 15030 LLVMWithBeforeLambdaBody); 15031 verifyFormat( 15032 "FctWithLongLineInLambda_SLS_All([]() { return SomeValueNotSoLong; },\n" 15033 " FirstParam,\n" 15034 " SecondParam,\n" 15035 " ThirdParam,\n" 15036 " FourthParam);", 15037 LLVMWithBeforeLambdaBody); 15038 verifyFormat("FctWithLongLineInLambda_SLS_All(\n" 15039 " []() { return " 15040 "SomeValueVeryVeryVeryVeryVeryVeryVeryVeryVeryLong; },\n" 15041 " FirstParam,\n" 15042 " SecondParam,\n" 15043 " ThirdParam,\n" 15044 " FourthParam);", 15045 LLVMWithBeforeLambdaBody); 15046 verifyFormat( 15047 "FctWithLongLineInLambda_SLS_All(FirstParam,\n" 15048 " SecondParam,\n" 15049 " ThirdParam,\n" 15050 " FourthParam,\n" 15051 " []() { return SomeValueNotSoLong; });", 15052 LLVMWithBeforeLambdaBody); 15053 verifyFormat("FctWithLongLineInLambda_SLS_All(\n" 15054 " []()\n" 15055 " {\n" 15056 " return " 15057 "HereAVeryLongLineThatWillBeFormattedOnMultipleLineAndShouldNotB" 15058 "eConsiderAsInline;\n" 15059 " });", 15060 LLVMWithBeforeLambdaBody); 15061 verifyFormat( 15062 "FctWithLongLineInLambda_SLS_All(\n" 15063 " []()\n" 15064 " {\n" 15065 " return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n" 15066 " AndShouldNotBeConsiderAsInline,\n" 15067 " LambdaBodyMustBeBreak);\n" 15068 " });", 15069 LLVMWithBeforeLambdaBody); 15070 verifyFormat("FctWithTwoParams_SLS_All(\n" 15071 " []()\n" 15072 " {\n" 15073 " // A cool function...\n" 15074 " return 43;\n" 15075 " },\n" 15076 " 87);", 15077 LLVMWithBeforeLambdaBody); 15078 verifyFormat("FctWithTwoParams_SLS_All([]() { return 43; }, 87);", 15079 LLVMWithBeforeLambdaBody); 15080 verifyFormat("FctWithOneNestedLambdas_SLS_All([]() { return 17; });", 15081 LLVMWithBeforeLambdaBody); 15082 verifyFormat( 15083 "TwoNestedLambdas_SLS_All([]() { return Call([]() { return 17; }); });", 15084 LLVMWithBeforeLambdaBody); 15085 verifyFormat("TwoNestedLambdas_SLS_All([]() { return Call([]() { return 17; " 15086 "}); }, x);", 15087 LLVMWithBeforeLambdaBody); 15088 verifyFormat("TwoNestedLambdas_SLS_All(\n" 15089 " []()\n" 15090 " {\n" 15091 " // A cool function...\n" 15092 " return Call([]() { return 17; });\n" 15093 " });", 15094 LLVMWithBeforeLambdaBody); 15095 verifyFormat("TwoNestedLambdas_SLS_All(\n" 15096 " []()\n" 15097 " {\n" 15098 " return Call(\n" 15099 " []()\n" 15100 " {\n" 15101 " // A cool function...\n" 15102 " return 17;\n" 15103 " });\n" 15104 " });", 15105 LLVMWithBeforeLambdaBody); 15106 } 15107 15108 TEST_F(FormatTest, LambdaWithLineComments) { 15109 FormatStyle LLVMWithBeforeLambdaBody = getLLVMStyle(); 15110 LLVMWithBeforeLambdaBody.BreakBeforeBraces = FormatStyle::BS_Custom; 15111 LLVMWithBeforeLambdaBody.BraceWrapping.BeforeLambdaBody = true; 15112 LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine = 15113 FormatStyle::ShortLambdaStyle::SLS_All; 15114 15115 verifyFormat("auto k = []() { return; }", LLVMWithBeforeLambdaBody); 15116 verifyFormat("auto k = []() // comment\n" 15117 "{ return; }", 15118 LLVMWithBeforeLambdaBody); 15119 verifyFormat("auto k = []() /* comment */ { return; }", 15120 LLVMWithBeforeLambdaBody); 15121 verifyFormat("auto k = []() /* comment */ /* comment */ { return; }", 15122 LLVMWithBeforeLambdaBody); 15123 verifyFormat("auto k = []() // X\n" 15124 "{ return; }", 15125 LLVMWithBeforeLambdaBody); 15126 verifyFormat( 15127 "auto k = []() // XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX\n" 15128 "{ return; }", 15129 LLVMWithBeforeLambdaBody); 15130 } 15131 15132 TEST_F(FormatTest, EmptyLinesInLambdas) { 15133 verifyFormat("auto lambda = []() {\n" 15134 " x(); //\n" 15135 "};", 15136 "auto lambda = []() {\n" 15137 "\n" 15138 " x(); //\n" 15139 "\n" 15140 "};"); 15141 } 15142 15143 TEST_F(FormatTest, FormatsBlocks) { 15144 FormatStyle ShortBlocks = getLLVMStyle(); 15145 ShortBlocks.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always; 15146 verifyFormat("int (^Block)(int, int);", ShortBlocks); 15147 verifyFormat("int (^Block1)(int, int) = ^(int i, int j)", ShortBlocks); 15148 verifyFormat("void (^block)(int) = ^(id test) { int i; };", ShortBlocks); 15149 verifyFormat("void (^block)(int) = ^(int test) { int i; };", ShortBlocks); 15150 verifyFormat("void (^block)(int) = ^id(int test) { int i; };", ShortBlocks); 15151 verifyFormat("void (^block)(int) = ^int(int test) { int i; };", ShortBlocks); 15152 15153 verifyFormat("foo(^{ bar(); });", ShortBlocks); 15154 verifyFormat("foo(a, ^{ bar(); });", ShortBlocks); 15155 verifyFormat("{ void (^block)(Object *x); }", ShortBlocks); 15156 15157 verifyFormat("[operation setCompletionBlock:^{\n" 15158 " [self onOperationDone];\n" 15159 "}];"); 15160 verifyFormat("int i = {[operation setCompletionBlock:^{\n" 15161 " [self onOperationDone];\n" 15162 "}]};"); 15163 verifyFormat("[operation setCompletionBlock:^(int *i) {\n" 15164 " f();\n" 15165 "}];"); 15166 verifyFormat("int a = [operation block:^int(int *i) {\n" 15167 " return 1;\n" 15168 "}];"); 15169 verifyFormat("[myObject doSomethingWith:arg1\n" 15170 " aaa:^int(int *a) {\n" 15171 " return 1;\n" 15172 " }\n" 15173 " bbb:f(a * bbbbbbbb)];"); 15174 15175 verifyFormat("[operation setCompletionBlock:^{\n" 15176 " [self.delegate newDataAvailable];\n" 15177 "}];", 15178 getLLVMStyleWithColumns(60)); 15179 verifyFormat("dispatch_async(_fileIOQueue, ^{\n" 15180 " NSString *path = [self sessionFilePath];\n" 15181 " if (path) {\n" 15182 " // ...\n" 15183 " }\n" 15184 "});"); 15185 verifyFormat("[[SessionService sharedService]\n" 15186 " loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 15187 " if (window) {\n" 15188 " [self windowDidLoad:window];\n" 15189 " } else {\n" 15190 " [self errorLoadingWindow];\n" 15191 " }\n" 15192 " }];"); 15193 verifyFormat("void (^largeBlock)(void) = ^{\n" 15194 " // ...\n" 15195 "};\n", 15196 getLLVMStyleWithColumns(40)); 15197 verifyFormat("[[SessionService sharedService]\n" 15198 " loadWindowWithCompletionBlock: //\n" 15199 " ^(SessionWindow *window) {\n" 15200 " if (window) {\n" 15201 " [self windowDidLoad:window];\n" 15202 " } else {\n" 15203 " [self errorLoadingWindow];\n" 15204 " }\n" 15205 " }];", 15206 getLLVMStyleWithColumns(60)); 15207 verifyFormat("[myObject doSomethingWith:arg1\n" 15208 " firstBlock:^(Foo *a) {\n" 15209 " // ...\n" 15210 " int i;\n" 15211 " }\n" 15212 " secondBlock:^(Bar *b) {\n" 15213 " // ...\n" 15214 " int i;\n" 15215 " }\n" 15216 " thirdBlock:^Foo(Bar *b) {\n" 15217 " // ...\n" 15218 " int i;\n" 15219 " }];"); 15220 verifyFormat("[myObject doSomethingWith:arg1\n" 15221 " firstBlock:-1\n" 15222 " secondBlock:^(Bar *b) {\n" 15223 " // ...\n" 15224 " int i;\n" 15225 " }];"); 15226 15227 verifyFormat("f(^{\n" 15228 " @autoreleasepool {\n" 15229 " if (a) {\n" 15230 " g();\n" 15231 " }\n" 15232 " }\n" 15233 "});"); 15234 verifyFormat("Block b = ^int *(A *a, B *b) {}"); 15235 verifyFormat("BOOL (^aaa)(void) = ^BOOL {\n" 15236 "};"); 15237 15238 FormatStyle FourIndent = getLLVMStyle(); 15239 FourIndent.ObjCBlockIndentWidth = 4; 15240 verifyFormat("[operation setCompletionBlock:^{\n" 15241 " [self onOperationDone];\n" 15242 "}];", 15243 FourIndent); 15244 } 15245 15246 TEST_F(FormatTest, FormatsBlocksWithZeroColumnWidth) { 15247 FormatStyle ZeroColumn = getLLVMStyle(); 15248 ZeroColumn.ColumnLimit = 0; 15249 15250 verifyFormat("[[SessionService sharedService] " 15251 "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 15252 " if (window) {\n" 15253 " [self windowDidLoad:window];\n" 15254 " } else {\n" 15255 " [self errorLoadingWindow];\n" 15256 " }\n" 15257 "}];", 15258 ZeroColumn); 15259 EXPECT_EQ("[[SessionService sharedService]\n" 15260 " loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 15261 " if (window) {\n" 15262 " [self windowDidLoad:window];\n" 15263 " } else {\n" 15264 " [self errorLoadingWindow];\n" 15265 " }\n" 15266 " }];", 15267 format("[[SessionService sharedService]\n" 15268 "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 15269 " if (window) {\n" 15270 " [self windowDidLoad:window];\n" 15271 " } else {\n" 15272 " [self errorLoadingWindow];\n" 15273 " }\n" 15274 "}];", 15275 ZeroColumn)); 15276 verifyFormat("[myObject doSomethingWith:arg1\n" 15277 " firstBlock:^(Foo *a) {\n" 15278 " // ...\n" 15279 " int i;\n" 15280 " }\n" 15281 " secondBlock:^(Bar *b) {\n" 15282 " // ...\n" 15283 " int i;\n" 15284 " }\n" 15285 " thirdBlock:^Foo(Bar *b) {\n" 15286 " // ...\n" 15287 " int i;\n" 15288 " }];", 15289 ZeroColumn); 15290 verifyFormat("f(^{\n" 15291 " @autoreleasepool {\n" 15292 " if (a) {\n" 15293 " g();\n" 15294 " }\n" 15295 " }\n" 15296 "});", 15297 ZeroColumn); 15298 verifyFormat("void (^largeBlock)(void) = ^{\n" 15299 " // ...\n" 15300 "};", 15301 ZeroColumn); 15302 15303 ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always; 15304 EXPECT_EQ("void (^largeBlock)(void) = ^{ int i; };", 15305 format("void (^largeBlock)(void) = ^{ int i; };", ZeroColumn)); 15306 ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Never; 15307 EXPECT_EQ("void (^largeBlock)(void) = ^{\n" 15308 " int i;\n" 15309 "};", 15310 format("void (^largeBlock)(void) = ^{ int i; };", ZeroColumn)); 15311 } 15312 15313 TEST_F(FormatTest, SupportsCRLF) { 15314 EXPECT_EQ("int a;\r\n" 15315 "int b;\r\n" 15316 "int c;\r\n", 15317 format("int a;\r\n" 15318 " int b;\r\n" 15319 " int c;\r\n", 15320 getLLVMStyle())); 15321 EXPECT_EQ("int a;\r\n" 15322 "int b;\r\n" 15323 "int c;\r\n", 15324 format("int a;\r\n" 15325 " int b;\n" 15326 " int c;\r\n", 15327 getLLVMStyle())); 15328 EXPECT_EQ("int a;\n" 15329 "int b;\n" 15330 "int c;\n", 15331 format("int a;\r\n" 15332 " int b;\n" 15333 " int c;\n", 15334 getLLVMStyle())); 15335 EXPECT_EQ("\"aaaaaaa \"\r\n" 15336 "\"bbbbbbb\";\r\n", 15337 format("\"aaaaaaa bbbbbbb\";\r\n", getLLVMStyleWithColumns(10))); 15338 EXPECT_EQ("#define A \\\r\n" 15339 " b; \\\r\n" 15340 " c; \\\r\n" 15341 " d;\r\n", 15342 format("#define A \\\r\n" 15343 " b; \\\r\n" 15344 " c; d; \r\n", 15345 getGoogleStyle())); 15346 15347 EXPECT_EQ("/*\r\n" 15348 "multi line block comments\r\n" 15349 "should not introduce\r\n" 15350 "an extra carriage return\r\n" 15351 "*/\r\n", 15352 format("/*\r\n" 15353 "multi line block comments\r\n" 15354 "should not introduce\r\n" 15355 "an extra carriage return\r\n" 15356 "*/\r\n")); 15357 EXPECT_EQ("/*\r\n" 15358 "\r\n" 15359 "*/", 15360 format("/*\r\n" 15361 " \r\r\r\n" 15362 "*/")); 15363 15364 FormatStyle style = getLLVMStyle(); 15365 15366 style.DeriveLineEnding = true; 15367 style.UseCRLF = false; 15368 EXPECT_EQ("union FooBarBazQux {\n" 15369 " int foo;\n" 15370 " int bar;\n" 15371 " int baz;\n" 15372 "};", 15373 format("union FooBarBazQux {\r\n" 15374 " int foo;\n" 15375 " int bar;\r\n" 15376 " int baz;\n" 15377 "};", 15378 style)); 15379 style.UseCRLF = true; 15380 EXPECT_EQ("union FooBarBazQux {\r\n" 15381 " int foo;\r\n" 15382 " int bar;\r\n" 15383 " int baz;\r\n" 15384 "};", 15385 format("union FooBarBazQux {\r\n" 15386 " int foo;\n" 15387 " int bar;\r\n" 15388 " int baz;\n" 15389 "};", 15390 style)); 15391 15392 style.DeriveLineEnding = false; 15393 style.UseCRLF = false; 15394 EXPECT_EQ("union FooBarBazQux {\n" 15395 " int foo;\n" 15396 " int bar;\n" 15397 " int baz;\n" 15398 " int qux;\n" 15399 "};", 15400 format("union FooBarBazQux {\r\n" 15401 " int foo;\n" 15402 " int bar;\r\n" 15403 " int baz;\n" 15404 " int qux;\r\n" 15405 "};", 15406 style)); 15407 style.UseCRLF = true; 15408 EXPECT_EQ("union FooBarBazQux {\r\n" 15409 " int foo;\r\n" 15410 " int bar;\r\n" 15411 " int baz;\r\n" 15412 " int qux;\r\n" 15413 "};", 15414 format("union FooBarBazQux {\r\n" 15415 " int foo;\n" 15416 " int bar;\r\n" 15417 " int baz;\n" 15418 " int qux;\n" 15419 "};", 15420 style)); 15421 15422 style.DeriveLineEnding = true; 15423 style.UseCRLF = false; 15424 EXPECT_EQ("union FooBarBazQux {\r\n" 15425 " int foo;\r\n" 15426 " int bar;\r\n" 15427 " int baz;\r\n" 15428 " int qux;\r\n" 15429 "};", 15430 format("union FooBarBazQux {\r\n" 15431 " int foo;\n" 15432 " int bar;\r\n" 15433 " int baz;\n" 15434 " int qux;\r\n" 15435 "};", 15436 style)); 15437 style.UseCRLF = true; 15438 EXPECT_EQ("union FooBarBazQux {\n" 15439 " int foo;\n" 15440 " int bar;\n" 15441 " int baz;\n" 15442 " int qux;\n" 15443 "};", 15444 format("union FooBarBazQux {\r\n" 15445 " int foo;\n" 15446 " int bar;\r\n" 15447 " int baz;\n" 15448 " int qux;\n" 15449 "};", 15450 style)); 15451 } 15452 15453 TEST_F(FormatTest, MunchSemicolonAfterBlocks) { 15454 verifyFormat("MY_CLASS(C) {\n" 15455 " int i;\n" 15456 " int j;\n" 15457 "};"); 15458 } 15459 15460 TEST_F(FormatTest, ConfigurableContinuationIndentWidth) { 15461 FormatStyle TwoIndent = getLLVMStyleWithColumns(15); 15462 TwoIndent.ContinuationIndentWidth = 2; 15463 15464 EXPECT_EQ("int i =\n" 15465 " longFunction(\n" 15466 " arg);", 15467 format("int i = longFunction(arg);", TwoIndent)); 15468 15469 FormatStyle SixIndent = getLLVMStyleWithColumns(20); 15470 SixIndent.ContinuationIndentWidth = 6; 15471 15472 EXPECT_EQ("int i =\n" 15473 " longFunction(\n" 15474 " arg);", 15475 format("int i = longFunction(arg);", SixIndent)); 15476 } 15477 15478 TEST_F(FormatTest, WrappedClosingParenthesisIndent) { 15479 FormatStyle Style = getLLVMStyle(); 15480 verifyFormat("int Foo::getter(\n" 15481 " //\n" 15482 ") const {\n" 15483 " return foo;\n" 15484 "}", 15485 Style); 15486 verifyFormat("void Foo::setter(\n" 15487 " //\n" 15488 ") {\n" 15489 " foo = 1;\n" 15490 "}", 15491 Style); 15492 } 15493 15494 TEST_F(FormatTest, SpacesInAngles) { 15495 FormatStyle Spaces = getLLVMStyle(); 15496 Spaces.SpacesInAngles = true; 15497 15498 verifyFormat("static_cast< int >(arg);", Spaces); 15499 verifyFormat("template < typename T0, typename T1 > void f() {}", Spaces); 15500 verifyFormat("f< int, float >();", Spaces); 15501 verifyFormat("template <> g() {}", Spaces); 15502 verifyFormat("template < std::vector< int > > f() {}", Spaces); 15503 verifyFormat("std::function< void(int, int) > fct;", Spaces); 15504 verifyFormat("void inFunction() { std::function< void(int, int) > fct; }", 15505 Spaces); 15506 15507 Spaces.Standard = FormatStyle::LS_Cpp03; 15508 Spaces.SpacesInAngles = true; 15509 verifyFormat("A< A< int > >();", Spaces); 15510 15511 Spaces.SpacesInAngles = false; 15512 verifyFormat("A<A<int> >();", Spaces); 15513 15514 Spaces.Standard = FormatStyle::LS_Cpp11; 15515 Spaces.SpacesInAngles = true; 15516 verifyFormat("A< A< int > >();", Spaces); 15517 15518 Spaces.SpacesInAngles = false; 15519 verifyFormat("A<A<int>>();", Spaces); 15520 } 15521 15522 TEST_F(FormatTest, SpaceAfterTemplateKeyword) { 15523 FormatStyle Style = getLLVMStyle(); 15524 Style.SpaceAfterTemplateKeyword = false; 15525 verifyFormat("template<int> void foo();", Style); 15526 } 15527 15528 TEST_F(FormatTest, TripleAngleBrackets) { 15529 verifyFormat("f<<<1, 1>>>();"); 15530 verifyFormat("f<<<1, 1, 1, s>>>();"); 15531 verifyFormat("f<<<a, b, c, d>>>();"); 15532 EXPECT_EQ("f<<<1, 1>>>();", format("f <<< 1, 1 >>> ();")); 15533 verifyFormat("f<param><<<1, 1>>>();"); 15534 verifyFormat("f<1><<<1, 1>>>();"); 15535 EXPECT_EQ("f<param><<<1, 1>>>();", format("f< param > <<< 1, 1 >>> ();")); 15536 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 15537 "aaaaaaaaaaa<<<\n 1, 1>>>();"); 15538 verifyFormat("aaaaaaaaaaaaaaa<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaa>\n" 15539 " <<<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaaaaaa>>>();"); 15540 } 15541 15542 TEST_F(FormatTest, MergeLessLessAtEnd) { 15543 verifyFormat("<<"); 15544 EXPECT_EQ("< < <", format("\\\n<<<")); 15545 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 15546 "aaallvm::outs() <<"); 15547 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 15548 "aaaallvm::outs()\n <<"); 15549 } 15550 15551 TEST_F(FormatTest, HandleUnbalancedImplicitBracesAcrossPPBranches) { 15552 std::string code = "#if A\n" 15553 "#if B\n" 15554 "a.\n" 15555 "#endif\n" 15556 " a = 1;\n" 15557 "#else\n" 15558 "#endif\n" 15559 "#if C\n" 15560 "#else\n" 15561 "#endif\n"; 15562 EXPECT_EQ(code, format(code)); 15563 } 15564 15565 TEST_F(FormatTest, HandleConflictMarkers) { 15566 // Git/SVN conflict markers. 15567 EXPECT_EQ("int a;\n" 15568 "void f() {\n" 15569 " callme(some(parameter1,\n" 15570 "<<<<<<< text by the vcs\n" 15571 " parameter2),\n" 15572 "||||||| text by the vcs\n" 15573 " parameter2),\n" 15574 " parameter3,\n" 15575 "======= text by the vcs\n" 15576 " parameter2, parameter3),\n" 15577 ">>>>>>> text by the vcs\n" 15578 " otherparameter);\n", 15579 format("int a;\n" 15580 "void f() {\n" 15581 " callme(some(parameter1,\n" 15582 "<<<<<<< text by the vcs\n" 15583 " parameter2),\n" 15584 "||||||| text by the vcs\n" 15585 " parameter2),\n" 15586 " parameter3,\n" 15587 "======= text by the vcs\n" 15588 " parameter2,\n" 15589 " parameter3),\n" 15590 ">>>>>>> text by the vcs\n" 15591 " otherparameter);\n")); 15592 15593 // Perforce markers. 15594 EXPECT_EQ("void f() {\n" 15595 " function(\n" 15596 ">>>> text by the vcs\n" 15597 " parameter,\n" 15598 "==== text by the vcs\n" 15599 " parameter,\n" 15600 "==== text by the vcs\n" 15601 " parameter,\n" 15602 "<<<< text by the vcs\n" 15603 " parameter);\n", 15604 format("void f() {\n" 15605 " function(\n" 15606 ">>>> text by the vcs\n" 15607 " parameter,\n" 15608 "==== text by the vcs\n" 15609 " parameter,\n" 15610 "==== text by the vcs\n" 15611 " parameter,\n" 15612 "<<<< text by the vcs\n" 15613 " parameter);\n")); 15614 15615 EXPECT_EQ("<<<<<<<\n" 15616 "|||||||\n" 15617 "=======\n" 15618 ">>>>>>>", 15619 format("<<<<<<<\n" 15620 "|||||||\n" 15621 "=======\n" 15622 ">>>>>>>")); 15623 15624 EXPECT_EQ("<<<<<<<\n" 15625 "|||||||\n" 15626 "int i;\n" 15627 "=======\n" 15628 ">>>>>>>", 15629 format("<<<<<<<\n" 15630 "|||||||\n" 15631 "int i;\n" 15632 "=======\n" 15633 ">>>>>>>")); 15634 15635 // FIXME: Handle parsing of macros around conflict markers correctly: 15636 EXPECT_EQ("#define Macro \\\n" 15637 "<<<<<<<\n" 15638 "Something \\\n" 15639 "|||||||\n" 15640 "Else \\\n" 15641 "=======\n" 15642 "Other \\\n" 15643 ">>>>>>>\n" 15644 " End int i;\n", 15645 format("#define Macro \\\n" 15646 "<<<<<<<\n" 15647 " Something \\\n" 15648 "|||||||\n" 15649 " Else \\\n" 15650 "=======\n" 15651 " Other \\\n" 15652 ">>>>>>>\n" 15653 " End\n" 15654 "int i;\n")); 15655 } 15656 15657 TEST_F(FormatTest, DisableRegions) { 15658 EXPECT_EQ("int i;\n" 15659 "// clang-format off\n" 15660 " int j;\n" 15661 "// clang-format on\n" 15662 "int k;", 15663 format(" int i;\n" 15664 " // clang-format off\n" 15665 " int j;\n" 15666 " // clang-format on\n" 15667 " int k;")); 15668 EXPECT_EQ("int i;\n" 15669 "/* clang-format off */\n" 15670 " int j;\n" 15671 "/* clang-format on */\n" 15672 "int k;", 15673 format(" int i;\n" 15674 " /* clang-format off */\n" 15675 " int j;\n" 15676 " /* clang-format on */\n" 15677 " int k;")); 15678 15679 // Don't reflow comments within disabled regions. 15680 EXPECT_EQ("// clang-format off\n" 15681 "// long long long long long long line\n" 15682 "/* clang-format on */\n" 15683 "/* long long long\n" 15684 " * long long long\n" 15685 " * line */\n" 15686 "int i;\n" 15687 "/* clang-format off */\n" 15688 "/* long long long long long long line */\n", 15689 format("// clang-format off\n" 15690 "// long long long long long long line\n" 15691 "/* clang-format on */\n" 15692 "/* long long long long long long line */\n" 15693 "int i;\n" 15694 "/* clang-format off */\n" 15695 "/* long long long long long long line */\n", 15696 getLLVMStyleWithColumns(20))); 15697 } 15698 15699 TEST_F(FormatTest, DoNotCrashOnInvalidInput) { 15700 format("? ) ="); 15701 verifyNoCrash("#define a\\\n /**/}"); 15702 } 15703 15704 TEST_F(FormatTest, FormatsTableGenCode) { 15705 FormatStyle Style = getLLVMStyle(); 15706 Style.Language = FormatStyle::LK_TableGen; 15707 verifyFormat("include \"a.td\"\ninclude \"b.td\"", Style); 15708 } 15709 15710 TEST_F(FormatTest, ArrayOfTemplates) { 15711 EXPECT_EQ("auto a = new unique_ptr<int>[10];", 15712 format("auto a = new unique_ptr<int > [ 10];")); 15713 15714 FormatStyle Spaces = getLLVMStyle(); 15715 Spaces.SpacesInSquareBrackets = true; 15716 EXPECT_EQ("auto a = new unique_ptr<int>[ 10 ];", 15717 format("auto a = new unique_ptr<int > [10];", Spaces)); 15718 } 15719 15720 TEST_F(FormatTest, ArrayAsTemplateType) { 15721 EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[10]>;", 15722 format("auto a = unique_ptr < Foo < Bar>[ 10]> ;")); 15723 15724 FormatStyle Spaces = getLLVMStyle(); 15725 Spaces.SpacesInSquareBrackets = true; 15726 EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[ 10 ]>;", 15727 format("auto a = unique_ptr < Foo < Bar>[10]> ;", Spaces)); 15728 } 15729 15730 TEST_F(FormatTest, NoSpaceAfterSuper) { verifyFormat("__super::FooBar();"); } 15731 15732 TEST(FormatStyle, GetStyleWithEmptyFileName) { 15733 llvm::vfs::InMemoryFileSystem FS; 15734 auto Style1 = getStyle("file", "", "Google", "", &FS); 15735 ASSERT_TRUE((bool)Style1); 15736 ASSERT_EQ(*Style1, getGoogleStyle()); 15737 } 15738 15739 TEST(FormatStyle, GetStyleOfFile) { 15740 llvm::vfs::InMemoryFileSystem FS; 15741 // Test 1: format file in the same directory. 15742 ASSERT_TRUE( 15743 FS.addFile("/a/.clang-format", 0, 15744 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM"))); 15745 ASSERT_TRUE( 15746 FS.addFile("/a/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;"))); 15747 auto Style1 = getStyle("file", "/a/.clang-format", "Google", "", &FS); 15748 ASSERT_TRUE((bool)Style1); 15749 ASSERT_EQ(*Style1, getLLVMStyle()); 15750 15751 // Test 2.1: fallback to default. 15752 ASSERT_TRUE( 15753 FS.addFile("/b/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;"))); 15754 auto Style2 = getStyle("file", "/b/test.cpp", "Mozilla", "", &FS); 15755 ASSERT_TRUE((bool)Style2); 15756 ASSERT_EQ(*Style2, getMozillaStyle()); 15757 15758 // Test 2.2: no format on 'none' fallback style. 15759 Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS); 15760 ASSERT_TRUE((bool)Style2); 15761 ASSERT_EQ(*Style2, getNoStyle()); 15762 15763 // Test 2.3: format if config is found with no based style while fallback is 15764 // 'none'. 15765 ASSERT_TRUE(FS.addFile("/b/.clang-format", 0, 15766 llvm::MemoryBuffer::getMemBuffer("IndentWidth: 2"))); 15767 Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS); 15768 ASSERT_TRUE((bool)Style2); 15769 ASSERT_EQ(*Style2, getLLVMStyle()); 15770 15771 // Test 2.4: format if yaml with no based style, while fallback is 'none'. 15772 Style2 = getStyle("{}", "a.h", "none", "", &FS); 15773 ASSERT_TRUE((bool)Style2); 15774 ASSERT_EQ(*Style2, getLLVMStyle()); 15775 15776 // Test 3: format file in parent directory. 15777 ASSERT_TRUE( 15778 FS.addFile("/c/.clang-format", 0, 15779 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: Google"))); 15780 ASSERT_TRUE(FS.addFile("/c/sub/sub/sub/test.cpp", 0, 15781 llvm::MemoryBuffer::getMemBuffer("int i;"))); 15782 auto Style3 = getStyle("file", "/c/sub/sub/sub/test.cpp", "LLVM", "", &FS); 15783 ASSERT_TRUE((bool)Style3); 15784 ASSERT_EQ(*Style3, getGoogleStyle()); 15785 15786 // Test 4: error on invalid fallback style 15787 auto Style4 = getStyle("file", "a.h", "KungFu", "", &FS); 15788 ASSERT_FALSE((bool)Style4); 15789 llvm::consumeError(Style4.takeError()); 15790 15791 // Test 5: error on invalid yaml on command line 15792 auto Style5 = getStyle("{invalid_key=invalid_value}", "a.h", "LLVM", "", &FS); 15793 ASSERT_FALSE((bool)Style5); 15794 llvm::consumeError(Style5.takeError()); 15795 15796 // Test 6: error on invalid style 15797 auto Style6 = getStyle("KungFu", "a.h", "LLVM", "", &FS); 15798 ASSERT_FALSE((bool)Style6); 15799 llvm::consumeError(Style6.takeError()); 15800 15801 // Test 7: found config file, error on parsing it 15802 ASSERT_TRUE( 15803 FS.addFile("/d/.clang-format", 0, 15804 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM\n" 15805 "InvalidKey: InvalidValue"))); 15806 ASSERT_TRUE( 15807 FS.addFile("/d/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;"))); 15808 auto Style7 = getStyle("file", "/d/.clang-format", "LLVM", "", &FS); 15809 ASSERT_FALSE((bool)Style7); 15810 llvm::consumeError(Style7.takeError()); 15811 15812 // Test 8: inferred per-language defaults apply. 15813 auto StyleTd = getStyle("file", "x.td", "llvm", "", &FS); 15814 ASSERT_TRUE((bool)StyleTd); 15815 ASSERT_EQ(*StyleTd, getLLVMStyle(FormatStyle::LK_TableGen)); 15816 } 15817 15818 TEST_F(ReplacementTest, FormatCodeAfterReplacements) { 15819 // Column limit is 20. 15820 std::string Code = "Type *a =\n" 15821 " new Type();\n" 15822 "g(iiiii, 0, jjjjj,\n" 15823 " 0, kkkkk, 0, mm);\n" 15824 "int bad = format ;"; 15825 std::string Expected = "auto a = new Type();\n" 15826 "g(iiiii, nullptr,\n" 15827 " jjjjj, nullptr,\n" 15828 " kkkkk, nullptr,\n" 15829 " mm);\n" 15830 "int bad = format ;"; 15831 FileID ID = Context.createInMemoryFile("format.cpp", Code); 15832 tooling::Replacements Replaces = toReplacements( 15833 {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 6, 15834 "auto "), 15835 tooling::Replacement(Context.Sources, Context.getLocation(ID, 3, 10), 1, 15836 "nullptr"), 15837 tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 3), 1, 15838 "nullptr"), 15839 tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 13), 1, 15840 "nullptr")}); 15841 15842 format::FormatStyle Style = format::getLLVMStyle(); 15843 Style.ColumnLimit = 20; // Set column limit to 20 to increase readibility. 15844 auto FormattedReplaces = formatReplacements(Code, Replaces, Style); 15845 EXPECT_TRUE(static_cast<bool>(FormattedReplaces)) 15846 << llvm::toString(FormattedReplaces.takeError()) << "\n"; 15847 auto Result = applyAllReplacements(Code, *FormattedReplaces); 15848 EXPECT_TRUE(static_cast<bool>(Result)); 15849 EXPECT_EQ(Expected, *Result); 15850 } 15851 15852 TEST_F(ReplacementTest, SortIncludesAfterReplacement) { 15853 std::string Code = "#include \"a.h\"\n" 15854 "#include \"c.h\"\n" 15855 "\n" 15856 "int main() {\n" 15857 " return 0;\n" 15858 "}"; 15859 std::string Expected = "#include \"a.h\"\n" 15860 "#include \"b.h\"\n" 15861 "#include \"c.h\"\n" 15862 "\n" 15863 "int main() {\n" 15864 " return 0;\n" 15865 "}"; 15866 FileID ID = Context.createInMemoryFile("fix.cpp", Code); 15867 tooling::Replacements Replaces = toReplacements( 15868 {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 0, 15869 "#include \"b.h\"\n")}); 15870 15871 format::FormatStyle Style = format::getLLVMStyle(); 15872 Style.SortIncludes = true; 15873 auto FormattedReplaces = formatReplacements(Code, Replaces, Style); 15874 EXPECT_TRUE(static_cast<bool>(FormattedReplaces)) 15875 << llvm::toString(FormattedReplaces.takeError()) << "\n"; 15876 auto Result = applyAllReplacements(Code, *FormattedReplaces); 15877 EXPECT_TRUE(static_cast<bool>(Result)); 15878 EXPECT_EQ(Expected, *Result); 15879 } 15880 15881 TEST_F(FormatTest, FormatSortsUsingDeclarations) { 15882 EXPECT_EQ("using std::cin;\n" 15883 "using std::cout;", 15884 format("using std::cout;\n" 15885 "using std::cin;", 15886 getGoogleStyle())); 15887 } 15888 15889 TEST_F(FormatTest, UTF8CharacterLiteralCpp03) { 15890 format::FormatStyle Style = format::getLLVMStyle(); 15891 Style.Standard = FormatStyle::LS_Cpp03; 15892 // cpp03 recognize this string as identifier u8 and literal character 'a' 15893 EXPECT_EQ("auto c = u8 'a';", format("auto c = u8'a';", Style)); 15894 } 15895 15896 TEST_F(FormatTest, UTF8CharacterLiteralCpp11) { 15897 // u8'a' is a C++17 feature, utf8 literal character, LS_Cpp11 covers 15898 // all modes, including C++11, C++14 and C++17 15899 EXPECT_EQ("auto c = u8'a';", format("auto c = u8'a';")); 15900 } 15901 15902 TEST_F(FormatTest, DoNotFormatLikelyXml) { 15903 EXPECT_EQ("<!-- ;> -->", format("<!-- ;> -->", getGoogleStyle())); 15904 EXPECT_EQ(" <!-- >; -->", format(" <!-- >; -->", getGoogleStyle())); 15905 } 15906 15907 TEST_F(FormatTest, StructuredBindings) { 15908 // Structured bindings is a C++17 feature. 15909 // all modes, including C++11, C++14 and C++17 15910 verifyFormat("auto [a, b] = f();"); 15911 EXPECT_EQ("auto [a, b] = f();", format("auto[a, b] = f();")); 15912 EXPECT_EQ("const auto [a, b] = f();", format("const auto[a, b] = f();")); 15913 EXPECT_EQ("auto const [a, b] = f();", format("auto const[a, b] = f();")); 15914 EXPECT_EQ("auto const volatile [a, b] = f();", 15915 format("auto const volatile[a, b] = f();")); 15916 EXPECT_EQ("auto [a, b, c] = f();", format("auto [ a , b,c ] = f();")); 15917 EXPECT_EQ("auto &[a, b, c] = f();", 15918 format("auto &[ a , b,c ] = f();")); 15919 EXPECT_EQ("auto &&[a, b, c] = f();", 15920 format("auto &&[ a , b,c ] = f();")); 15921 EXPECT_EQ("auto const &[a, b] = f();", format("auto const&[a, b] = f();")); 15922 EXPECT_EQ("auto const volatile &&[a, b] = f();", 15923 format("auto const volatile &&[a, b] = f();")); 15924 EXPECT_EQ("auto const &&[a, b] = f();", 15925 format("auto const && [a, b] = f();")); 15926 EXPECT_EQ("const auto &[a, b] = f();", 15927 format("const auto & [a, b] = f();")); 15928 EXPECT_EQ("const auto volatile &&[a, b] = f();", 15929 format("const auto volatile &&[a, b] = f();")); 15930 EXPECT_EQ("volatile const auto &&[a, b] = f();", 15931 format("volatile const auto &&[a, b] = f();")); 15932 EXPECT_EQ("const auto &&[a, b] = f();", 15933 format("const auto && [a, b] = f();")); 15934 15935 // Make sure we don't mistake structured bindings for lambdas. 15936 FormatStyle PointerMiddle = getLLVMStyle(); 15937 PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle; 15938 verifyFormat("auto [a1, b]{A * i};", getGoogleStyle()); 15939 verifyFormat("auto [a2, b]{A * i};", getLLVMStyle()); 15940 verifyFormat("auto [a3, b]{A * i};", PointerMiddle); 15941 verifyFormat("auto const [a1, b]{A * i};", getGoogleStyle()); 15942 verifyFormat("auto const [a2, b]{A * i};", getLLVMStyle()); 15943 verifyFormat("auto const [a3, b]{A * i};", PointerMiddle); 15944 verifyFormat("auto const& [a1, b]{A * i};", getGoogleStyle()); 15945 verifyFormat("auto const &[a2, b]{A * i};", getLLVMStyle()); 15946 verifyFormat("auto const & [a3, b]{A * i};", PointerMiddle); 15947 verifyFormat("auto const&& [a1, b]{A * i};", getGoogleStyle()); 15948 verifyFormat("auto const &&[a2, b]{A * i};", getLLVMStyle()); 15949 verifyFormat("auto const && [a3, b]{A * i};", PointerMiddle); 15950 15951 EXPECT_EQ("for (const auto &&[a, b] : some_range) {\n}", 15952 format("for (const auto && [a, b] : some_range) {\n}")); 15953 EXPECT_EQ("for (const auto &[a, b] : some_range) {\n}", 15954 format("for (const auto & [a, b] : some_range) {\n}")); 15955 EXPECT_EQ("for (const auto [a, b] : some_range) {\n}", 15956 format("for (const auto[a, b] : some_range) {\n}")); 15957 EXPECT_EQ("auto [x, y](expr);", format("auto[x,y] (expr);")); 15958 EXPECT_EQ("auto &[x, y](expr);", format("auto & [x,y] (expr);")); 15959 EXPECT_EQ("auto &&[x, y](expr);", format("auto && [x,y] (expr);")); 15960 EXPECT_EQ("auto const &[x, y](expr);", 15961 format("auto const & [x,y] (expr);")); 15962 EXPECT_EQ("auto const &&[x, y](expr);", 15963 format("auto const && [x,y] (expr);")); 15964 EXPECT_EQ("auto [x, y]{expr};", format("auto[x,y] {expr};")); 15965 EXPECT_EQ("auto const &[x, y]{expr};", 15966 format("auto const & [x,y] {expr};")); 15967 EXPECT_EQ("auto const &&[x, y]{expr};", 15968 format("auto const && [x,y] {expr};")); 15969 15970 format::FormatStyle Spaces = format::getLLVMStyle(); 15971 Spaces.SpacesInSquareBrackets = true; 15972 verifyFormat("auto [ a, b ] = f();", Spaces); 15973 verifyFormat("auto &&[ a, b ] = f();", Spaces); 15974 verifyFormat("auto &[ a, b ] = f();", Spaces); 15975 verifyFormat("auto const &&[ a, b ] = f();", Spaces); 15976 verifyFormat("auto const &[ a, b ] = f();", Spaces); 15977 } 15978 15979 TEST_F(FormatTest, FileAndCode) { 15980 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.cc", "")); 15981 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.m", "")); 15982 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.mm", "")); 15983 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "")); 15984 EXPECT_EQ(FormatStyle::LK_ObjC, 15985 guessLanguage("foo.h", "@interface Foo\n@end\n")); 15986 EXPECT_EQ( 15987 FormatStyle::LK_ObjC, 15988 guessLanguage("foo.h", "#define TRY(x, y) @try { x; } @finally { y; }")); 15989 EXPECT_EQ(FormatStyle::LK_ObjC, 15990 guessLanguage("foo.h", "#define AVAIL(x) @available(x, *))")); 15991 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.h", "@class Foo;")); 15992 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo", "")); 15993 EXPECT_EQ(FormatStyle::LK_ObjC, 15994 guessLanguage("foo", "@interface Foo\n@end\n")); 15995 EXPECT_EQ(FormatStyle::LK_ObjC, 15996 guessLanguage("foo.h", "int DoStuff(CGRect rect);\n")); 15997 EXPECT_EQ( 15998 FormatStyle::LK_ObjC, 15999 guessLanguage("foo.h", 16000 "#define MY_POINT_MAKE(x, y) CGPointMake((x), (y));\n")); 16001 EXPECT_EQ( 16002 FormatStyle::LK_Cpp, 16003 guessLanguage("foo.h", "#define FOO(...) auto bar = [] __VA_ARGS__;")); 16004 } 16005 16006 TEST_F(FormatTest, GuessLanguageWithCpp11AttributeSpecifiers) { 16007 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[noreturn]];")); 16008 EXPECT_EQ(FormatStyle::LK_ObjC, 16009 guessLanguage("foo.h", "array[[calculator getIndex]];")); 16010 EXPECT_EQ(FormatStyle::LK_Cpp, 16011 guessLanguage("foo.h", "[[noreturn, deprecated(\"so sorry\")]];")); 16012 EXPECT_EQ( 16013 FormatStyle::LK_Cpp, 16014 guessLanguage("foo.h", "[[noreturn, deprecated(\"gone, sorry\")]];")); 16015 EXPECT_EQ(FormatStyle::LK_ObjC, 16016 guessLanguage("foo.h", "[[noreturn foo] bar];")); 16017 EXPECT_EQ(FormatStyle::LK_Cpp, 16018 guessLanguage("foo.h", "[[clang::fallthrough]];")); 16019 EXPECT_EQ(FormatStyle::LK_ObjC, 16020 guessLanguage("foo.h", "[[clang:fallthrough] foo];")); 16021 EXPECT_EQ(FormatStyle::LK_Cpp, 16022 guessLanguage("foo.h", "[[gsl::suppress(\"type\")]];")); 16023 EXPECT_EQ(FormatStyle::LK_Cpp, 16024 guessLanguage("foo.h", "[[using clang: fallthrough]];")); 16025 EXPECT_EQ(FormatStyle::LK_ObjC, 16026 guessLanguage("foo.h", "[[abusing clang:fallthrough] bar];")); 16027 EXPECT_EQ(FormatStyle::LK_Cpp, 16028 guessLanguage("foo.h", "[[using gsl: suppress(\"type\")]];")); 16029 EXPECT_EQ( 16030 FormatStyle::LK_Cpp, 16031 guessLanguage("foo.h", "for (auto &&[endpoint, stream] : streams_)")); 16032 EXPECT_EQ( 16033 FormatStyle::LK_Cpp, 16034 guessLanguage("foo.h", 16035 "[[clang::callable_when(\"unconsumed\", \"unknown\")]]")); 16036 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[foo::bar, ...]]")); 16037 } 16038 16039 TEST_F(FormatTest, GuessLanguageWithCaret) { 16040 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^);")); 16041 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^, Bar);")); 16042 EXPECT_EQ(FormatStyle::LK_ObjC, 16043 guessLanguage("foo.h", "int(^)(char, float);")); 16044 EXPECT_EQ(FormatStyle::LK_ObjC, 16045 guessLanguage("foo.h", "int(^foo)(char, float);")); 16046 EXPECT_EQ(FormatStyle::LK_ObjC, 16047 guessLanguage("foo.h", "int(^foo[10])(char, float);")); 16048 EXPECT_EQ(FormatStyle::LK_ObjC, 16049 guessLanguage("foo.h", "int(^foo[kNumEntries])(char, float);")); 16050 EXPECT_EQ( 16051 FormatStyle::LK_ObjC, 16052 guessLanguage("foo.h", "int(^foo[(kNumEntries + 10)])(char, float);")); 16053 } 16054 16055 TEST_F(FormatTest, FormatsInlineAsmSymbolicNames) { 16056 // ASM symbolic names are identifiers that must be surrounded by [] without 16057 // space in between: 16058 // https://gcc.gnu.org/onlinedocs/gcc/Extended-Asm.html#InputOperands 16059 16060 // Example from https://bugs.llvm.org/show_bug.cgi?id=45108. 16061 verifyFormat(R"(// 16062 asm volatile("mrs %x[result], FPCR" : [result] "=r"(result)); 16063 )"); 16064 16065 // A list of several ASM symbolic names. 16066 verifyFormat(R"(asm("mov %[e], %[d]" : [d] "=rm"(d), [e] "rm"(*e));)"); 16067 16068 // ASM symbolic names in inline ASM with inputs and outputs. 16069 verifyFormat(R"(// 16070 asm("cmoveq %1, %2, %[result]" 16071 : [result] "=r"(result) 16072 : "r"(test), "r"(new), "[result]"(old)); 16073 )"); 16074 16075 // ASM symbolic names in inline ASM with no outputs. 16076 verifyFormat(R"(asm("mov %[e], %[d]" : : [d] "=rm"(d), [e] "rm"(*e));)"); 16077 } 16078 16079 TEST_F(FormatTest, GuessedLanguageWithInlineAsmClobbers) { 16080 EXPECT_EQ(FormatStyle::LK_Cpp, 16081 guessLanguage("foo.h", "void f() {\n" 16082 " asm (\"mov %[e], %[d]\"\n" 16083 " : [d] \"=rm\" (d)\n" 16084 " [e] \"rm\" (*e));\n" 16085 "}")); 16086 EXPECT_EQ(FormatStyle::LK_Cpp, 16087 guessLanguage("foo.h", "void f() {\n" 16088 " _asm (\"mov %[e], %[d]\"\n" 16089 " : [d] \"=rm\" (d)\n" 16090 " [e] \"rm\" (*e));\n" 16091 "}")); 16092 EXPECT_EQ(FormatStyle::LK_Cpp, 16093 guessLanguage("foo.h", "void f() {\n" 16094 " __asm (\"mov %[e], %[d]\"\n" 16095 " : [d] \"=rm\" (d)\n" 16096 " [e] \"rm\" (*e));\n" 16097 "}")); 16098 EXPECT_EQ(FormatStyle::LK_Cpp, 16099 guessLanguage("foo.h", "void f() {\n" 16100 " __asm__ (\"mov %[e], %[d]\"\n" 16101 " : [d] \"=rm\" (d)\n" 16102 " [e] \"rm\" (*e));\n" 16103 "}")); 16104 EXPECT_EQ(FormatStyle::LK_Cpp, 16105 guessLanguage("foo.h", "void f() {\n" 16106 " asm (\"mov %[e], %[d]\"\n" 16107 " : [d] \"=rm\" (d),\n" 16108 " [e] \"rm\" (*e));\n" 16109 "}")); 16110 EXPECT_EQ(FormatStyle::LK_Cpp, 16111 guessLanguage("foo.h", "void f() {\n" 16112 " asm volatile (\"mov %[e], %[d]\"\n" 16113 " : [d] \"=rm\" (d)\n" 16114 " [e] \"rm\" (*e));\n" 16115 "}")); 16116 } 16117 16118 TEST_F(FormatTest, GuessLanguageWithChildLines) { 16119 EXPECT_EQ(FormatStyle::LK_Cpp, 16120 guessLanguage("foo.h", "#define FOO ({ std::string s; })")); 16121 EXPECT_EQ(FormatStyle::LK_ObjC, 16122 guessLanguage("foo.h", "#define FOO ({ NSString *s; })")); 16123 EXPECT_EQ( 16124 FormatStyle::LK_Cpp, 16125 guessLanguage("foo.h", "#define FOO ({ foo(); ({ std::string s; }) })")); 16126 EXPECT_EQ( 16127 FormatStyle::LK_ObjC, 16128 guessLanguage("foo.h", "#define FOO ({ foo(); ({ NSString *s; }) })")); 16129 } 16130 16131 TEST_F(FormatTest, TypenameMacros) { 16132 std::vector<std::string> TypenameMacros = {"STACK_OF", "LIST", "TAILQ_ENTRY"}; 16133 16134 // Test case reported in https://bugs.llvm.org/show_bug.cgi?id=30353 16135 FormatStyle Google = getGoogleStyleWithColumns(0); 16136 Google.TypenameMacros = TypenameMacros; 16137 verifyFormat("struct foo {\n" 16138 " int bar;\n" 16139 " TAILQ_ENTRY(a) bleh;\n" 16140 "};", 16141 Google); 16142 16143 FormatStyle Macros = getLLVMStyle(); 16144 Macros.TypenameMacros = TypenameMacros; 16145 16146 verifyFormat("STACK_OF(int) a;", Macros); 16147 verifyFormat("STACK_OF(int) *a;", Macros); 16148 verifyFormat("STACK_OF(int const *) *a;", Macros); 16149 verifyFormat("STACK_OF(int *const) *a;", Macros); 16150 verifyFormat("STACK_OF(int, string) a;", Macros); 16151 verifyFormat("STACK_OF(LIST(int)) a;", Macros); 16152 verifyFormat("STACK_OF(LIST(int)) a, b;", Macros); 16153 verifyFormat("for (LIST(int) *a = NULL; a;) {\n}", Macros); 16154 verifyFormat("STACK_OF(int) f(LIST(int) *arg);", Macros); 16155 16156 Macros.PointerAlignment = FormatStyle::PAS_Left; 16157 verifyFormat("STACK_OF(int)* a;", Macros); 16158 verifyFormat("STACK_OF(int*)* a;", Macros); 16159 } 16160 16161 TEST_F(FormatTest, AmbersandInLamda) { 16162 // Test case reported in https://bugs.llvm.org/show_bug.cgi?id=41899 16163 FormatStyle AlignStyle = getLLVMStyle(); 16164 AlignStyle.PointerAlignment = FormatStyle::PAS_Left; 16165 verifyFormat("auto lambda = [&a = a]() { a = 2; };", AlignStyle); 16166 AlignStyle.PointerAlignment = FormatStyle::PAS_Right; 16167 verifyFormat("auto lambda = [&a = a]() { a = 2; };", AlignStyle); 16168 } 16169 16170 TEST_F(FormatTest, SpacesInConditionalStatement) { 16171 FormatStyle Spaces = getLLVMStyle(); 16172 Spaces.SpacesInConditionalStatement = true; 16173 verifyFormat("for ( int i = 0; i; i++ )\n continue;", Spaces); 16174 verifyFormat("if ( !a )\n return;", Spaces); 16175 verifyFormat("if ( a )\n return;", Spaces); 16176 verifyFormat("if constexpr ( a )\n return;", Spaces); 16177 verifyFormat("switch ( a )\ncase 1:\n return;", Spaces); 16178 verifyFormat("while ( a )\n return;", Spaces); 16179 verifyFormat("while ( (a && b) )\n return;", Spaces); 16180 verifyFormat("do {\n} while ( 1 != 0 );", Spaces); 16181 verifyFormat("try {\n} catch ( const std::exception & ) {\n}", Spaces); 16182 // Check that space on the left of "::" is inserted as expected at beginning 16183 // of condition. 16184 verifyFormat("while ( ::func() )\n return;", Spaces); 16185 } 16186 16187 TEST_F(FormatTest, AlternativeOperators) { 16188 // Test case for ensuring alternate operators are not 16189 // combined with their right most neighbour. 16190 verifyFormat("int a and b;"); 16191 verifyFormat("int a and_eq b;"); 16192 verifyFormat("int a bitand b;"); 16193 verifyFormat("int a bitor b;"); 16194 verifyFormat("int a compl b;"); 16195 verifyFormat("int a not b;"); 16196 verifyFormat("int a not_eq b;"); 16197 verifyFormat("int a or b;"); 16198 verifyFormat("int a xor b;"); 16199 verifyFormat("int a xor_eq b;"); 16200 verifyFormat("return this not_eq bitand other;"); 16201 verifyFormat("bool operator not_eq(const X bitand other)"); 16202 16203 verifyFormat("int a and 5;"); 16204 verifyFormat("int a and_eq 5;"); 16205 verifyFormat("int a bitand 5;"); 16206 verifyFormat("int a bitor 5;"); 16207 verifyFormat("int a compl 5;"); 16208 verifyFormat("int a not 5;"); 16209 verifyFormat("int a not_eq 5;"); 16210 verifyFormat("int a or 5;"); 16211 verifyFormat("int a xor 5;"); 16212 verifyFormat("int a xor_eq 5;"); 16213 16214 verifyFormat("int a compl(5);"); 16215 verifyFormat("int a not(5);"); 16216 16217 /* FIXME handle alternate tokens 16218 * https://en.cppreference.com/w/cpp/language/operator_alternative 16219 // alternative tokens 16220 verifyFormat("compl foo();"); // ~foo(); 16221 verifyFormat("foo() <%%>;"); // foo(); 16222 verifyFormat("void foo() <%%>;"); // void foo(){} 16223 verifyFormat("int a <:1:>;"); // int a[1];[ 16224 verifyFormat("%:define ABC abc"); // #define ABC abc 16225 verifyFormat("%:%:"); // ## 16226 */ 16227 } 16228 16229 TEST_F(FormatTest, STLWhileNotDefineChed) { 16230 verifyFormat("#if defined(while)\n" 16231 "#define while EMIT WARNING C4005\n" 16232 "#endif // while"); 16233 } 16234 16235 TEST_F(FormatTest, OperatorSpacing) { 16236 FormatStyle Style = getLLVMStyle(); 16237 Style.PointerAlignment = FormatStyle::PAS_Right; 16238 verifyFormat("Foo::operator*();", Style); 16239 verifyFormat("Foo::operator void *();", Style); 16240 verifyFormat("Foo::operator void **();", Style); 16241 verifyFormat("Foo::operator void *&();", Style); 16242 verifyFormat("Foo::operator void *&&();", Style); 16243 verifyFormat("Foo::operator()(void *);", Style); 16244 verifyFormat("Foo::operator*(void *);", Style); 16245 verifyFormat("Foo::operator*();", Style); 16246 verifyFormat("Foo::operator**();", Style); 16247 verifyFormat("Foo::operator&();", Style); 16248 verifyFormat("Foo::operator<int> *();", Style); 16249 verifyFormat("Foo::operator<Foo> *();", Style); 16250 verifyFormat("Foo::operator<int> **();", Style); 16251 verifyFormat("Foo::operator<Foo> **();", Style); 16252 verifyFormat("Foo::operator<int> &();", Style); 16253 verifyFormat("Foo::operator<Foo> &();", Style); 16254 verifyFormat("Foo::operator<int> &&();", Style); 16255 verifyFormat("Foo::operator<Foo> &&();", Style); 16256 verifyFormat("Foo::operator<int> *&();", Style); 16257 verifyFormat("Foo::operator<Foo> *&();", Style); 16258 verifyFormat("Foo::operator<int> *&&();", Style); 16259 verifyFormat("Foo::operator<Foo> *&&();", Style); 16260 verifyFormat("operator*(int (*)(), class Foo);", Style); 16261 16262 verifyFormat("Foo::operator&();", Style); 16263 verifyFormat("Foo::operator void &();", Style); 16264 verifyFormat("Foo::operator()(void &);", Style); 16265 verifyFormat("Foo::operator&(void &);", Style); 16266 verifyFormat("Foo::operator&();", Style); 16267 verifyFormat("operator&(int (&)(), class Foo);", Style); 16268 16269 verifyFormat("Foo::operator&&();", Style); 16270 verifyFormat("Foo::operator**();", Style); 16271 verifyFormat("Foo::operator void &&();", Style); 16272 verifyFormat("Foo::operator()(void &&);", Style); 16273 verifyFormat("Foo::operator&&(void &&);", Style); 16274 verifyFormat("Foo::operator&&();", Style); 16275 verifyFormat("operator&&(int(&&)(), class Foo);", Style); 16276 verifyFormat("operator const nsTArrayRight<E> &()", Style); 16277 verifyFormat("[[nodiscard]] operator const nsTArrayRight<E, Allocator> &()", 16278 Style); 16279 verifyFormat("operator void **()", Style); 16280 verifyFormat("operator const FooRight<Object> &()", Style); 16281 verifyFormat("operator const FooRight<Object> *()", Style); 16282 verifyFormat("operator const FooRight<Object> **()", Style); 16283 verifyFormat("operator const FooRight<Object> *&()", Style); 16284 verifyFormat("operator const FooRight<Object> *&&()", Style); 16285 16286 Style.PointerAlignment = FormatStyle::PAS_Left; 16287 verifyFormat("Foo::operator*();", Style); 16288 verifyFormat("Foo::operator**();", Style); 16289 verifyFormat("Foo::operator void*();", Style); 16290 verifyFormat("Foo::operator void**();", Style); 16291 verifyFormat("Foo::operator void*&();", Style); 16292 verifyFormat("Foo::operator/*comment*/ void*();", Style); 16293 verifyFormat("Foo::operator/*a*/ const /*b*/ void*();", Style); 16294 verifyFormat("Foo::operator/*a*/ volatile /*b*/ void*();", Style); 16295 verifyFormat("Foo::operator()(void*);", Style); 16296 verifyFormat("Foo::operator*(void*);", Style); 16297 verifyFormat("Foo::operator*();", Style); 16298 verifyFormat("Foo::operator<int>*();", Style); 16299 verifyFormat("Foo::operator<Foo>*();", Style); 16300 verifyFormat("Foo::operator<int>**();", Style); 16301 verifyFormat("Foo::operator<Foo>**();", Style); 16302 verifyFormat("Foo::operator<Foo>*&();", Style); 16303 verifyFormat("Foo::operator<int>&();", Style); 16304 verifyFormat("Foo::operator<Foo>&();", Style); 16305 verifyFormat("Foo::operator<int>&&();", Style); 16306 verifyFormat("Foo::operator<Foo>&&();", Style); 16307 verifyFormat("Foo::operator<int>*&();", Style); 16308 verifyFormat("Foo::operator<Foo>*&();", Style); 16309 verifyFormat("operator*(int (*)(), class Foo);", Style); 16310 16311 verifyFormat("Foo::operator&();", Style); 16312 verifyFormat("Foo::operator void&();", Style); 16313 verifyFormat("Foo::operator/*comment*/ void&();", Style); 16314 verifyFormat("Foo::operator/*a*/ const /*b*/ void&();", Style); 16315 verifyFormat("Foo::operator/*a*/ volatile /*b*/ void&();", Style); 16316 verifyFormat("Foo::operator()(void&);", Style); 16317 verifyFormat("Foo::operator&(void&);", Style); 16318 verifyFormat("Foo::operator&();", Style); 16319 verifyFormat("operator&(int (&)(), class Foo);", Style); 16320 16321 verifyFormat("Foo::operator&&();", Style); 16322 verifyFormat("Foo::operator void&&();", Style); 16323 verifyFormat("Foo::operator/*comment*/ void&&();", Style); 16324 verifyFormat("Foo::operator/*a*/ const /*b*/ void&&();", Style); 16325 verifyFormat("Foo::operator/*a*/ volatile /*b*/ void&&();", Style); 16326 verifyFormat("Foo::operator()(void&&);", Style); 16327 verifyFormat("Foo::operator&&(void&&);", Style); 16328 verifyFormat("Foo::operator&&();", Style); 16329 verifyFormat("operator&&(int(&&)(), class Foo);", Style); 16330 verifyFormat("operator const nsTArrayLeft<E>&()", Style); 16331 verifyFormat("[[nodiscard]] operator const nsTArrayLeft<E, Allocator>&()", 16332 Style); 16333 verifyFormat("operator void**()", Style); 16334 verifyFormat("operator const FooLeft<Object>&()", Style); 16335 verifyFormat("operator const FooLeft<Object>*()", Style); 16336 verifyFormat("operator const FooLeft<Object>**()", Style); 16337 verifyFormat("operator const FooLeft<Object>*&()", Style); 16338 verifyFormat("operator const FooLeft<Object>*&&()", Style); 16339 16340 // PR45107 16341 verifyFormat("operator Vector<String>&();", Style); 16342 verifyFormat("operator const Vector<String>&();", Style); 16343 verifyFormat("operator foo::Bar*();", Style); 16344 verifyFormat("operator const Foo<X>::Bar<Y>*();", Style); 16345 verifyFormat("operator/*a*/ const /*b*/ Foo /*c*/<X> /*d*/ ::Bar<Y>*();", 16346 Style); 16347 16348 Style.PointerAlignment = FormatStyle::PAS_Middle; 16349 verifyFormat("Foo::operator*();", Style); 16350 verifyFormat("Foo::operator void *();", Style); 16351 verifyFormat("Foo::operator()(void *);", Style); 16352 verifyFormat("Foo::operator*(void *);", Style); 16353 verifyFormat("Foo::operator*();", Style); 16354 verifyFormat("operator*(int (*)(), class Foo);", Style); 16355 16356 verifyFormat("Foo::operator&();", Style); 16357 verifyFormat("Foo::operator void &();", Style); 16358 verifyFormat("Foo::operator()(void &);", Style); 16359 verifyFormat("Foo::operator&(void &);", Style); 16360 verifyFormat("Foo::operator&();", Style); 16361 verifyFormat("operator&(int (&)(), class Foo);", Style); 16362 16363 verifyFormat("Foo::operator&&();", Style); 16364 verifyFormat("Foo::operator void &&();", Style); 16365 verifyFormat("Foo::operator()(void &&);", Style); 16366 verifyFormat("Foo::operator&&(void &&);", Style); 16367 verifyFormat("Foo::operator&&();", Style); 16368 verifyFormat("operator&&(int(&&)(), class Foo);", Style); 16369 } 16370 16371 TEST_F(FormatTest, VeryLongNamespaceCommentSplit) { 16372 // These tests are not in NamespaceFixer because that doesn't 16373 // test its interaction with line wrapping 16374 FormatStyle Style = getLLVMStyle(); 16375 Style.ColumnLimit = 80; 16376 verifyFormat("namespace {\n" 16377 "int i;\n" 16378 "int j;\n" 16379 "} // namespace", 16380 Style); 16381 16382 verifyFormat("namespace AAA {\n" 16383 "int i;\n" 16384 "int j;\n" 16385 "} // namespace AAA", 16386 Style); 16387 16388 EXPECT_EQ("namespace Averyveryveryverylongnamespace {\n" 16389 "int i;\n" 16390 "int j;\n" 16391 "} // namespace Averyveryveryverylongnamespace", 16392 format("namespace Averyveryveryverylongnamespace {\n" 16393 "int i;\n" 16394 "int j;\n" 16395 "}", 16396 Style)); 16397 16398 EXPECT_EQ( 16399 "namespace " 16400 "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::\n" 16401 " went::mad::now {\n" 16402 "int i;\n" 16403 "int j;\n" 16404 "} // namespace\n" 16405 " // " 16406 "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::" 16407 "went::mad::now", 16408 format("namespace " 16409 "would::it::save::you::a::lot::of::time::if_::i::" 16410 "just::gave::up::and_::went::mad::now {\n" 16411 "int i;\n" 16412 "int j;\n" 16413 "}", 16414 Style)); 16415 16416 // This used to duplicate the comment again and again on subsequent runs 16417 EXPECT_EQ( 16418 "namespace " 16419 "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::\n" 16420 " went::mad::now {\n" 16421 "int i;\n" 16422 "int j;\n" 16423 "} // namespace\n" 16424 " // " 16425 "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::" 16426 "went::mad::now", 16427 format("namespace " 16428 "would::it::save::you::a::lot::of::time::if_::i::" 16429 "just::gave::up::and_::went::mad::now {\n" 16430 "int i;\n" 16431 "int j;\n" 16432 "} // namespace\n" 16433 " // " 16434 "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::" 16435 "and_::went::mad::now", 16436 Style)); 16437 } 16438 16439 TEST_F(FormatTest, LikelyUnlikely) { 16440 FormatStyle Style = getLLVMStyle(); 16441 16442 verifyFormat("if (argc > 5) [[unlikely]] {\n" 16443 " return 29;\n" 16444 "}", 16445 Style); 16446 16447 verifyFormat("if (argc > 5) [[likely]] {\n" 16448 " return 29;\n" 16449 "}", 16450 Style); 16451 16452 verifyFormat("if (argc > 5) [[unlikely]] {\n" 16453 " return 29;\n" 16454 "} else [[likely]] {\n" 16455 " return 42;\n" 16456 "}\n", 16457 Style); 16458 16459 verifyFormat("if (argc > 5) [[unlikely]] {\n" 16460 " return 29;\n" 16461 "} else if (argc > 10) [[likely]] {\n" 16462 " return 99;\n" 16463 "} else {\n" 16464 " return 42;\n" 16465 "}\n", 16466 Style); 16467 } 16468 16469 } // namespace 16470 } // namespace format 16471 } // namespace clang 16472