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 // As function-like macros. 976 verifyFormat("#define foreach(x, y)\n" 977 "#define Q_FOREACH(x, y)\n" 978 "#define BOOST_FOREACH(x, y)\n" 979 "#define UNKNOWN_FOREACH(x, y)\n"); 980 981 // Not as function-like macros. 982 verifyFormat("#define foreach (x, y)\n" 983 "#define Q_FOREACH (x, y)\n" 984 "#define BOOST_FOREACH (x, y)\n" 985 "#define UNKNOWN_FOREACH (x, y)\n"); 986 } 987 988 TEST_F(FormatTest, FormatsWhileLoop) { 989 verifyFormat("while (true) {\n}"); 990 verifyFormat("while (true)\n" 991 " f();"); 992 verifyFormat("while () {\n}"); 993 verifyFormat("while () {\n" 994 " f();\n" 995 "}"); 996 } 997 998 TEST_F(FormatTest, FormatsDoWhile) { 999 verifyFormat("do {\n" 1000 " do_something();\n" 1001 "} while (something());"); 1002 verifyFormat("do\n" 1003 " do_something();\n" 1004 "while (something());"); 1005 } 1006 1007 TEST_F(FormatTest, FormatsSwitchStatement) { 1008 verifyFormat("switch (x) {\n" 1009 "case 1:\n" 1010 " f();\n" 1011 " break;\n" 1012 "case kFoo:\n" 1013 "case ns::kBar:\n" 1014 "case kBaz:\n" 1015 " break;\n" 1016 "default:\n" 1017 " g();\n" 1018 " break;\n" 1019 "}"); 1020 verifyFormat("switch (x) {\n" 1021 "case 1: {\n" 1022 " f();\n" 1023 " break;\n" 1024 "}\n" 1025 "case 2: {\n" 1026 " break;\n" 1027 "}\n" 1028 "}"); 1029 verifyFormat("switch (x) {\n" 1030 "case 1: {\n" 1031 " f();\n" 1032 " {\n" 1033 " g();\n" 1034 " h();\n" 1035 " }\n" 1036 " break;\n" 1037 "}\n" 1038 "}"); 1039 verifyFormat("switch (x) {\n" 1040 "case 1: {\n" 1041 " f();\n" 1042 " if (foo) {\n" 1043 " g();\n" 1044 " h();\n" 1045 " }\n" 1046 " break;\n" 1047 "}\n" 1048 "}"); 1049 verifyFormat("switch (x) {\n" 1050 "case 1: {\n" 1051 " f();\n" 1052 " g();\n" 1053 "} break;\n" 1054 "}"); 1055 verifyFormat("switch (test)\n" 1056 " ;"); 1057 verifyFormat("switch (x) {\n" 1058 "default: {\n" 1059 " // Do nothing.\n" 1060 "}\n" 1061 "}"); 1062 verifyFormat("switch (x) {\n" 1063 "// comment\n" 1064 "// if 1, do f()\n" 1065 "case 1:\n" 1066 " f();\n" 1067 "}"); 1068 verifyFormat("switch (x) {\n" 1069 "case 1:\n" 1070 " // Do amazing stuff\n" 1071 " {\n" 1072 " f();\n" 1073 " g();\n" 1074 " }\n" 1075 " break;\n" 1076 "}"); 1077 verifyFormat("#define A \\\n" 1078 " switch (x) { \\\n" 1079 " case a: \\\n" 1080 " foo = b; \\\n" 1081 " }", 1082 getLLVMStyleWithColumns(20)); 1083 verifyFormat("#define OPERATION_CASE(name) \\\n" 1084 " case OP_name: \\\n" 1085 " return operations::Operation##name\n", 1086 getLLVMStyleWithColumns(40)); 1087 verifyFormat("switch (x) {\n" 1088 "case 1:;\n" 1089 "default:;\n" 1090 " int i;\n" 1091 "}"); 1092 1093 verifyGoogleFormat("switch (x) {\n" 1094 " case 1:\n" 1095 " f();\n" 1096 " break;\n" 1097 " case kFoo:\n" 1098 " case ns::kBar:\n" 1099 " case kBaz:\n" 1100 " break;\n" 1101 " default:\n" 1102 " g();\n" 1103 " break;\n" 1104 "}"); 1105 verifyGoogleFormat("switch (x) {\n" 1106 " case 1: {\n" 1107 " f();\n" 1108 " break;\n" 1109 " }\n" 1110 "}"); 1111 verifyGoogleFormat("switch (test)\n" 1112 " ;"); 1113 1114 verifyGoogleFormat("#define OPERATION_CASE(name) \\\n" 1115 " case OP_name: \\\n" 1116 " return operations::Operation##name\n"); 1117 verifyGoogleFormat("Operation codeToOperation(OperationCode OpCode) {\n" 1118 " // Get the correction operation class.\n" 1119 " switch (OpCode) {\n" 1120 " CASE(Add);\n" 1121 " CASE(Subtract);\n" 1122 " default:\n" 1123 " return operations::Unknown;\n" 1124 " }\n" 1125 "#undef OPERATION_CASE\n" 1126 "}"); 1127 verifyFormat("DEBUG({\n" 1128 " switch (x) {\n" 1129 " case A:\n" 1130 " f();\n" 1131 " break;\n" 1132 " // fallthrough\n" 1133 " case B:\n" 1134 " g();\n" 1135 " break;\n" 1136 " }\n" 1137 "});"); 1138 EXPECT_EQ("DEBUG({\n" 1139 " switch (x) {\n" 1140 " case A:\n" 1141 " f();\n" 1142 " break;\n" 1143 " // On B:\n" 1144 " case B:\n" 1145 " g();\n" 1146 " break;\n" 1147 " }\n" 1148 "});", 1149 format("DEBUG({\n" 1150 " switch (x) {\n" 1151 " case A:\n" 1152 " f();\n" 1153 " break;\n" 1154 " // On B:\n" 1155 " case B:\n" 1156 " g();\n" 1157 " break;\n" 1158 " }\n" 1159 "});", 1160 getLLVMStyle())); 1161 EXPECT_EQ("switch (n) {\n" 1162 "case 0: {\n" 1163 " return false;\n" 1164 "}\n" 1165 "default: {\n" 1166 " return true;\n" 1167 "}\n" 1168 "}", 1169 format("switch (n)\n" 1170 "{\n" 1171 "case 0: {\n" 1172 " return false;\n" 1173 "}\n" 1174 "default: {\n" 1175 " return true;\n" 1176 "}\n" 1177 "}", 1178 getLLVMStyle())); 1179 verifyFormat("switch (a) {\n" 1180 "case (b):\n" 1181 " return;\n" 1182 "}"); 1183 1184 verifyFormat("switch (a) {\n" 1185 "case some_namespace::\n" 1186 " some_constant:\n" 1187 " return;\n" 1188 "}", 1189 getLLVMStyleWithColumns(34)); 1190 1191 FormatStyle Style = getLLVMStyle(); 1192 Style.IndentCaseLabels = true; 1193 Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Never; 1194 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 1195 Style.BraceWrapping.AfterCaseLabel = true; 1196 Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always; 1197 EXPECT_EQ("switch (n)\n" 1198 "{\n" 1199 " case 0:\n" 1200 " {\n" 1201 " return false;\n" 1202 " }\n" 1203 " default:\n" 1204 " {\n" 1205 " return true;\n" 1206 " }\n" 1207 "}", 1208 format("switch (n) {\n" 1209 " case 0: {\n" 1210 " return false;\n" 1211 " }\n" 1212 " default: {\n" 1213 " return true;\n" 1214 " }\n" 1215 "}", 1216 Style)); 1217 Style.BraceWrapping.AfterCaseLabel = false; 1218 EXPECT_EQ("switch (n)\n" 1219 "{\n" 1220 " case 0: {\n" 1221 " return false;\n" 1222 " }\n" 1223 " default: {\n" 1224 " return true;\n" 1225 " }\n" 1226 "}", 1227 format("switch (n) {\n" 1228 " case 0:\n" 1229 " {\n" 1230 " return false;\n" 1231 " }\n" 1232 " default:\n" 1233 " {\n" 1234 " return true;\n" 1235 " }\n" 1236 "}", 1237 Style)); 1238 Style.IndentCaseLabels = false; 1239 Style.IndentCaseBlocks = true; 1240 EXPECT_EQ("switch (n)\n" 1241 "{\n" 1242 "case 0:\n" 1243 " {\n" 1244 " return false;\n" 1245 " }\n" 1246 "case 1:\n" 1247 " break;\n" 1248 "default:\n" 1249 " {\n" 1250 " return true;\n" 1251 " }\n" 1252 "}", 1253 format("switch (n) {\n" 1254 "case 0: {\n" 1255 " return false;\n" 1256 "}\n" 1257 "case 1:\n" 1258 " break;\n" 1259 "default: {\n" 1260 " return true;\n" 1261 "}\n" 1262 "}", 1263 Style)); 1264 Style.IndentCaseLabels = true; 1265 Style.IndentCaseBlocks = true; 1266 EXPECT_EQ("switch (n)\n" 1267 "{\n" 1268 " case 0:\n" 1269 " {\n" 1270 " return false;\n" 1271 " }\n" 1272 " case 1:\n" 1273 " break;\n" 1274 " default:\n" 1275 " {\n" 1276 " return true;\n" 1277 " }\n" 1278 "}", 1279 format("switch (n) {\n" 1280 "case 0: {\n" 1281 " return false;\n" 1282 "}\n" 1283 "case 1:\n" 1284 " break;\n" 1285 "default: {\n" 1286 " return true;\n" 1287 "}\n" 1288 "}", 1289 Style)); 1290 } 1291 1292 TEST_F(FormatTest, CaseRanges) { 1293 verifyFormat("switch (x) {\n" 1294 "case 'A' ... 'Z':\n" 1295 "case 1 ... 5:\n" 1296 "case a ... b:\n" 1297 " break;\n" 1298 "}"); 1299 } 1300 1301 TEST_F(FormatTest, ShortEnums) { 1302 FormatStyle Style = getLLVMStyle(); 1303 Style.AllowShortEnumsOnASingleLine = true; 1304 verifyFormat("enum { A, B, C } ShortEnum1, ShortEnum2;", Style); 1305 Style.AllowShortEnumsOnASingleLine = false; 1306 verifyFormat("enum\n" 1307 "{\n" 1308 " A,\n" 1309 " B,\n" 1310 " C\n" 1311 "} ShortEnum1, ShortEnum2;", 1312 Style); 1313 } 1314 1315 TEST_F(FormatTest, ShortCaseLabels) { 1316 FormatStyle Style = getLLVMStyle(); 1317 Style.AllowShortCaseLabelsOnASingleLine = true; 1318 verifyFormat("switch (a) {\n" 1319 "case 1: x = 1; break;\n" 1320 "case 2: return;\n" 1321 "case 3:\n" 1322 "case 4:\n" 1323 "case 5: return;\n" 1324 "case 6: // comment\n" 1325 " return;\n" 1326 "case 7:\n" 1327 " // comment\n" 1328 " return;\n" 1329 "case 8:\n" 1330 " x = 8; // comment\n" 1331 " break;\n" 1332 "default: y = 1; break;\n" 1333 "}", 1334 Style); 1335 verifyFormat("switch (a) {\n" 1336 "case 0: return; // comment\n" 1337 "case 1: break; // comment\n" 1338 "case 2: return;\n" 1339 "// comment\n" 1340 "case 3: return;\n" 1341 "// comment 1\n" 1342 "// comment 2\n" 1343 "// comment 3\n" 1344 "case 4: break; /* comment */\n" 1345 "case 5:\n" 1346 " // comment\n" 1347 " break;\n" 1348 "case 6: /* comment */ x = 1; break;\n" 1349 "case 7: x = /* comment */ 1; break;\n" 1350 "case 8:\n" 1351 " x = 1; /* comment */\n" 1352 " break;\n" 1353 "case 9:\n" 1354 " break; // comment line 1\n" 1355 " // comment line 2\n" 1356 "}", 1357 Style); 1358 EXPECT_EQ("switch (a) {\n" 1359 "case 1:\n" 1360 " x = 8;\n" 1361 " // fall through\n" 1362 "case 2: x = 8;\n" 1363 "// comment\n" 1364 "case 3:\n" 1365 " return; /* comment line 1\n" 1366 " * comment line 2 */\n" 1367 "case 4: i = 8;\n" 1368 "// something else\n" 1369 "#if FOO\n" 1370 "case 5: break;\n" 1371 "#endif\n" 1372 "}", 1373 format("switch (a) {\n" 1374 "case 1: x = 8;\n" 1375 " // fall through\n" 1376 "case 2:\n" 1377 " x = 8;\n" 1378 "// comment\n" 1379 "case 3:\n" 1380 " return; /* comment line 1\n" 1381 " * comment line 2 */\n" 1382 "case 4:\n" 1383 " i = 8;\n" 1384 "// something else\n" 1385 "#if FOO\n" 1386 "case 5: break;\n" 1387 "#endif\n" 1388 "}", 1389 Style)); 1390 EXPECT_EQ("switch (a) {\n" 1391 "case 0:\n" 1392 " return; // long long long long long long long long long long " 1393 "long long comment\n" 1394 " // line\n" 1395 "}", 1396 format("switch (a) {\n" 1397 "case 0: return; // long long long long long long long long " 1398 "long long long long comment line\n" 1399 "}", 1400 Style)); 1401 EXPECT_EQ("switch (a) {\n" 1402 "case 0:\n" 1403 " return; /* long long long long long long long long long long " 1404 "long long comment\n" 1405 " line */\n" 1406 "}", 1407 format("switch (a) {\n" 1408 "case 0: return; /* long long long long long long long long " 1409 "long long long long comment line */\n" 1410 "}", 1411 Style)); 1412 verifyFormat("switch (a) {\n" 1413 "#if FOO\n" 1414 "case 0: return 0;\n" 1415 "#endif\n" 1416 "}", 1417 Style); 1418 verifyFormat("switch (a) {\n" 1419 "case 1: {\n" 1420 "}\n" 1421 "case 2: {\n" 1422 " return;\n" 1423 "}\n" 1424 "case 3: {\n" 1425 " x = 1;\n" 1426 " return;\n" 1427 "}\n" 1428 "case 4:\n" 1429 " if (x)\n" 1430 " return;\n" 1431 "}", 1432 Style); 1433 Style.ColumnLimit = 21; 1434 verifyFormat("switch (a) {\n" 1435 "case 1: x = 1; break;\n" 1436 "case 2: return;\n" 1437 "case 3:\n" 1438 "case 4:\n" 1439 "case 5: return;\n" 1440 "default:\n" 1441 " y = 1;\n" 1442 " break;\n" 1443 "}", 1444 Style); 1445 Style.ColumnLimit = 80; 1446 Style.AllowShortCaseLabelsOnASingleLine = false; 1447 Style.IndentCaseLabels = true; 1448 EXPECT_EQ("switch (n) {\n" 1449 " default /*comments*/:\n" 1450 " return true;\n" 1451 " case 0:\n" 1452 " return false;\n" 1453 "}", 1454 format("switch (n) {\n" 1455 "default/*comments*/:\n" 1456 " return true;\n" 1457 "case 0:\n" 1458 " return false;\n" 1459 "}", 1460 Style)); 1461 Style.AllowShortCaseLabelsOnASingleLine = true; 1462 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 1463 Style.BraceWrapping.AfterCaseLabel = true; 1464 Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always; 1465 EXPECT_EQ("switch (n)\n" 1466 "{\n" 1467 " case 0:\n" 1468 " {\n" 1469 " return false;\n" 1470 " }\n" 1471 " default:\n" 1472 " {\n" 1473 " return true;\n" 1474 " }\n" 1475 "}", 1476 format("switch (n) {\n" 1477 " case 0: {\n" 1478 " return false;\n" 1479 " }\n" 1480 " default:\n" 1481 " {\n" 1482 " return true;\n" 1483 " }\n" 1484 "}", 1485 Style)); 1486 } 1487 1488 TEST_F(FormatTest, FormatsLabels) { 1489 verifyFormat("void f() {\n" 1490 " some_code();\n" 1491 "test_label:\n" 1492 " some_other_code();\n" 1493 " {\n" 1494 " some_more_code();\n" 1495 " another_label:\n" 1496 " some_more_code();\n" 1497 " }\n" 1498 "}"); 1499 verifyFormat("{\n" 1500 " some_code();\n" 1501 "test_label:\n" 1502 " some_other_code();\n" 1503 "}"); 1504 verifyFormat("{\n" 1505 " some_code();\n" 1506 "test_label:;\n" 1507 " int i = 0;\n" 1508 "}"); 1509 FormatStyle Style = getLLVMStyle(); 1510 Style.IndentGotoLabels = false; 1511 verifyFormat("void f() {\n" 1512 " some_code();\n" 1513 "test_label:\n" 1514 " some_other_code();\n" 1515 " {\n" 1516 " some_more_code();\n" 1517 "another_label:\n" 1518 " some_more_code();\n" 1519 " }\n" 1520 "}", 1521 Style); 1522 verifyFormat("{\n" 1523 " some_code();\n" 1524 "test_label:\n" 1525 " some_other_code();\n" 1526 "}", 1527 Style); 1528 verifyFormat("{\n" 1529 " some_code();\n" 1530 "test_label:;\n" 1531 " int i = 0;\n" 1532 "}"); 1533 } 1534 1535 TEST_F(FormatTest, MultiLineControlStatements) { 1536 FormatStyle Style = getLLVMStyle(); 1537 Style.BreakBeforeBraces = FormatStyle::BraceBreakingStyle::BS_Custom; 1538 Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_MultiLine; 1539 Style.ColumnLimit = 20; 1540 // Short lines should keep opening brace on same line. 1541 EXPECT_EQ("if (foo) {\n" 1542 " bar();\n" 1543 "}", 1544 format("if(foo){bar();}", Style)); 1545 EXPECT_EQ("if (foo) {\n" 1546 " bar();\n" 1547 "} else {\n" 1548 " baz();\n" 1549 "}", 1550 format("if(foo){bar();}else{baz();}", Style)); 1551 EXPECT_EQ("if (foo && bar) {\n" 1552 " baz();\n" 1553 "}", 1554 format("if(foo&&bar){baz();}", Style)); 1555 EXPECT_EQ("if (foo) {\n" 1556 " bar();\n" 1557 "} else if (baz) {\n" 1558 " quux();\n" 1559 "}", 1560 format("if(foo){bar();}else if(baz){quux();}", Style)); 1561 EXPECT_EQ( 1562 "if (foo) {\n" 1563 " bar();\n" 1564 "} else if (baz) {\n" 1565 " quux();\n" 1566 "} else {\n" 1567 " foobar();\n" 1568 "}", 1569 format("if(foo){bar();}else if(baz){quux();}else{foobar();}", Style)); 1570 EXPECT_EQ("for (;;) {\n" 1571 " foo();\n" 1572 "}", 1573 format("for(;;){foo();}")); 1574 EXPECT_EQ("while (1) {\n" 1575 " foo();\n" 1576 "}", 1577 format("while(1){foo();}", Style)); 1578 EXPECT_EQ("switch (foo) {\n" 1579 "case bar:\n" 1580 " return;\n" 1581 "}", 1582 format("switch(foo){case bar:return;}", Style)); 1583 EXPECT_EQ("try {\n" 1584 " foo();\n" 1585 "} catch (...) {\n" 1586 " bar();\n" 1587 "}", 1588 format("try{foo();}catch(...){bar();}", Style)); 1589 EXPECT_EQ("do {\n" 1590 " foo();\n" 1591 "} while (bar &&\n" 1592 " baz);", 1593 format("do{foo();}while(bar&&baz);", Style)); 1594 // Long lines should put opening brace on new line. 1595 EXPECT_EQ("if (foo && bar &&\n" 1596 " baz)\n" 1597 "{\n" 1598 " quux();\n" 1599 "}", 1600 format("if(foo&&bar&&baz){quux();}", Style)); 1601 EXPECT_EQ("if (foo && bar &&\n" 1602 " baz)\n" 1603 "{\n" 1604 " quux();\n" 1605 "}", 1606 format("if (foo && bar &&\n" 1607 " baz) {\n" 1608 " quux();\n" 1609 "}", 1610 Style)); 1611 EXPECT_EQ("if (foo) {\n" 1612 " bar();\n" 1613 "} else if (baz ||\n" 1614 " quux)\n" 1615 "{\n" 1616 " foobar();\n" 1617 "}", 1618 format("if(foo){bar();}else if(baz||quux){foobar();}", Style)); 1619 EXPECT_EQ( 1620 "if (foo) {\n" 1621 " bar();\n" 1622 "} else if (baz ||\n" 1623 " quux)\n" 1624 "{\n" 1625 " foobar();\n" 1626 "} else {\n" 1627 " barbaz();\n" 1628 "}", 1629 format("if(foo){bar();}else if(baz||quux){foobar();}else{barbaz();}", 1630 Style)); 1631 EXPECT_EQ("for (int i = 0;\n" 1632 " i < 10; ++i)\n" 1633 "{\n" 1634 " foo();\n" 1635 "}", 1636 format("for(int i=0;i<10;++i){foo();}", Style)); 1637 EXPECT_EQ("while (foo || bar ||\n" 1638 " baz)\n" 1639 "{\n" 1640 " quux();\n" 1641 "}", 1642 format("while(foo||bar||baz){quux();}", Style)); 1643 EXPECT_EQ("switch (\n" 1644 " foo = barbaz)\n" 1645 "{\n" 1646 "case quux:\n" 1647 " return;\n" 1648 "}", 1649 format("switch(foo=barbaz){case quux:return;}", Style)); 1650 EXPECT_EQ("try {\n" 1651 " foo();\n" 1652 "} catch (\n" 1653 " Exception &bar)\n" 1654 "{\n" 1655 " baz();\n" 1656 "}", 1657 format("try{foo();}catch(Exception&bar){baz();}", Style)); 1658 Style.ColumnLimit = 1659 40; // to concentrate at brace wrapping, not line wrap due to column limit 1660 EXPECT_EQ("try {\n" 1661 " foo();\n" 1662 "} catch (Exception &bar) {\n" 1663 " baz();\n" 1664 "}", 1665 format("try{foo();}catch(Exception&bar){baz();}", Style)); 1666 Style.ColumnLimit = 1667 20; // to concentrate at brace wrapping, not line wrap due to column limit 1668 1669 Style.BraceWrapping.BeforeElse = true; 1670 EXPECT_EQ( 1671 "if (foo) {\n" 1672 " bar();\n" 1673 "}\n" 1674 "else if (baz ||\n" 1675 " quux)\n" 1676 "{\n" 1677 " foobar();\n" 1678 "}\n" 1679 "else {\n" 1680 " barbaz();\n" 1681 "}", 1682 format("if(foo){bar();}else if(baz||quux){foobar();}else{barbaz();}", 1683 Style)); 1684 1685 Style.BraceWrapping.BeforeCatch = true; 1686 EXPECT_EQ("try {\n" 1687 " foo();\n" 1688 "}\n" 1689 "catch (...) {\n" 1690 " baz();\n" 1691 "}", 1692 format("try{foo();}catch(...){baz();}", Style)); 1693 } 1694 1695 //===----------------------------------------------------------------------===// 1696 // Tests for classes, namespaces, etc. 1697 //===----------------------------------------------------------------------===// 1698 1699 TEST_F(FormatTest, DoesNotBreakSemiAfterClassDecl) { 1700 verifyFormat("class A {};"); 1701 } 1702 1703 TEST_F(FormatTest, UnderstandsAccessSpecifiers) { 1704 verifyFormat("class A {\n" 1705 "public:\n" 1706 "public: // comment\n" 1707 "protected:\n" 1708 "private:\n" 1709 " void f() {}\n" 1710 "};"); 1711 verifyFormat("export class A {\n" 1712 "public:\n" 1713 "public: // comment\n" 1714 "protected:\n" 1715 "private:\n" 1716 " void f() {}\n" 1717 "};"); 1718 verifyGoogleFormat("class A {\n" 1719 " public:\n" 1720 " protected:\n" 1721 " private:\n" 1722 " void f() {}\n" 1723 "};"); 1724 verifyGoogleFormat("export class A {\n" 1725 " public:\n" 1726 " protected:\n" 1727 " private:\n" 1728 " void f() {}\n" 1729 "};"); 1730 verifyFormat("class A {\n" 1731 "public slots:\n" 1732 " void f1() {}\n" 1733 "public Q_SLOTS:\n" 1734 " void f2() {}\n" 1735 "protected slots:\n" 1736 " void f3() {}\n" 1737 "protected Q_SLOTS:\n" 1738 " void f4() {}\n" 1739 "private slots:\n" 1740 " void f5() {}\n" 1741 "private Q_SLOTS:\n" 1742 " void f6() {}\n" 1743 "signals:\n" 1744 " void g1();\n" 1745 "Q_SIGNALS:\n" 1746 " void g2();\n" 1747 "};"); 1748 1749 // Don't interpret 'signals' the wrong way. 1750 verifyFormat("signals.set();"); 1751 verifyFormat("for (Signals signals : f()) {\n}"); 1752 verifyFormat("{\n" 1753 " signals.set(); // This needs indentation.\n" 1754 "}"); 1755 verifyFormat("void f() {\n" 1756 "label:\n" 1757 " signals.baz();\n" 1758 "}"); 1759 } 1760 1761 TEST_F(FormatTest, SeparatesLogicalBlocks) { 1762 EXPECT_EQ("class A {\n" 1763 "public:\n" 1764 " void f();\n" 1765 "\n" 1766 "private:\n" 1767 " void g() {}\n" 1768 " // test\n" 1769 "protected:\n" 1770 " int h;\n" 1771 "};", 1772 format("class A {\n" 1773 "public:\n" 1774 "void f();\n" 1775 "private:\n" 1776 "void g() {}\n" 1777 "// test\n" 1778 "protected:\n" 1779 "int h;\n" 1780 "};")); 1781 EXPECT_EQ("class A {\n" 1782 "protected:\n" 1783 "public:\n" 1784 " void f();\n" 1785 "};", 1786 format("class A {\n" 1787 "protected:\n" 1788 "\n" 1789 "public:\n" 1790 "\n" 1791 " void f();\n" 1792 "};")); 1793 1794 // Even ensure proper spacing inside macros. 1795 EXPECT_EQ("#define B \\\n" 1796 " class A { \\\n" 1797 " protected: \\\n" 1798 " public: \\\n" 1799 " void f(); \\\n" 1800 " };", 1801 format("#define B \\\n" 1802 " class A { \\\n" 1803 " protected: \\\n" 1804 " \\\n" 1805 " public: \\\n" 1806 " \\\n" 1807 " void f(); \\\n" 1808 " };", 1809 getGoogleStyle())); 1810 // But don't remove empty lines after macros ending in access specifiers. 1811 EXPECT_EQ("#define A private:\n" 1812 "\n" 1813 "int i;", 1814 format("#define A private:\n" 1815 "\n" 1816 "int i;")); 1817 } 1818 1819 TEST_F(FormatTest, FormatsClasses) { 1820 verifyFormat("class A : public B {};"); 1821 verifyFormat("class A : public ::B {};"); 1822 1823 verifyFormat( 1824 "class AAAAAAAAAAAAAAAAAAAA : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n" 1825 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};"); 1826 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n" 1827 " : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n" 1828 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};"); 1829 verifyFormat( 1830 "class A : public B, public C, public D, public E, public F {};"); 1831 verifyFormat("class AAAAAAAAAAAA : public B,\n" 1832 " public C,\n" 1833 " public D,\n" 1834 " public E,\n" 1835 " public F,\n" 1836 " public G {};"); 1837 1838 verifyFormat("class\n" 1839 " ReallyReallyLongClassName {\n" 1840 " int i;\n" 1841 "};", 1842 getLLVMStyleWithColumns(32)); 1843 verifyFormat("struct aaaaaaaaaaaaa : public aaaaaaaaaaaaaaaaaaa< // break\n" 1844 " aaaaaaaaaaaaaaaa> {};"); 1845 verifyFormat("struct aaaaaaaaaaaaaaaaaaaa\n" 1846 " : public aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaa,\n" 1847 " aaaaaaaaaaaaaaaaaaaaaa> {};"); 1848 verifyFormat("template <class R, class C>\n" 1849 "struct Aaaaaaaaaaaaaaaaa<R (C::*)(int) const>\n" 1850 " : Aaaaaaaaaaaaaaaaa<R (C::*)(int)> {};"); 1851 verifyFormat("class ::A::B {};"); 1852 } 1853 1854 TEST_F(FormatTest, BreakInheritanceStyle) { 1855 FormatStyle StyleWithInheritanceBreakBeforeComma = getLLVMStyle(); 1856 StyleWithInheritanceBreakBeforeComma.BreakInheritanceList = 1857 FormatStyle::BILS_BeforeComma; 1858 verifyFormat("class MyClass : public X {};", 1859 StyleWithInheritanceBreakBeforeComma); 1860 verifyFormat("class MyClass\n" 1861 " : public X\n" 1862 " , public Y {};", 1863 StyleWithInheritanceBreakBeforeComma); 1864 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAA\n" 1865 " : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n" 1866 " , public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};", 1867 StyleWithInheritanceBreakBeforeComma); 1868 verifyFormat("struct aaaaaaaaaaaaa\n" 1869 " : public aaaaaaaaaaaaaaaaaaa< // break\n" 1870 " aaaaaaaaaaaaaaaa> {};", 1871 StyleWithInheritanceBreakBeforeComma); 1872 1873 FormatStyle StyleWithInheritanceBreakAfterColon = getLLVMStyle(); 1874 StyleWithInheritanceBreakAfterColon.BreakInheritanceList = 1875 FormatStyle::BILS_AfterColon; 1876 verifyFormat("class MyClass : public X {};", 1877 StyleWithInheritanceBreakAfterColon); 1878 verifyFormat("class MyClass : public X, public Y {};", 1879 StyleWithInheritanceBreakAfterColon); 1880 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAA :\n" 1881 " public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n" 1882 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};", 1883 StyleWithInheritanceBreakAfterColon); 1884 verifyFormat("struct aaaaaaaaaaaaa :\n" 1885 " public aaaaaaaaaaaaaaaaaaa< // break\n" 1886 " aaaaaaaaaaaaaaaa> {};", 1887 StyleWithInheritanceBreakAfterColon); 1888 } 1889 1890 TEST_F(FormatTest, FormatsVariableDeclarationsAfterStructOrClass) { 1891 verifyFormat("class A {\n} a, b;"); 1892 verifyFormat("struct A {\n} a, b;"); 1893 verifyFormat("union A {\n} a;"); 1894 } 1895 1896 TEST_F(FormatTest, FormatsEnum) { 1897 verifyFormat("enum {\n" 1898 " Zero,\n" 1899 " One = 1,\n" 1900 " Two = One + 1,\n" 1901 " Three = (One + Two),\n" 1902 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1903 " Five = (One, Two, Three, Four, 5)\n" 1904 "};"); 1905 verifyGoogleFormat("enum {\n" 1906 " Zero,\n" 1907 " One = 1,\n" 1908 " Two = One + 1,\n" 1909 " Three = (One + Two),\n" 1910 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1911 " Five = (One, Two, Three, Four, 5)\n" 1912 "};"); 1913 verifyFormat("enum Enum {};"); 1914 verifyFormat("enum {};"); 1915 verifyFormat("enum X E {} d;"); 1916 verifyFormat("enum __attribute__((...)) E {} d;"); 1917 verifyFormat("enum __declspec__((...)) E {} d;"); 1918 verifyFormat("enum {\n" 1919 " Bar = Foo<int, int>::value\n" 1920 "};", 1921 getLLVMStyleWithColumns(30)); 1922 1923 verifyFormat("enum ShortEnum { A, B, C };"); 1924 verifyGoogleFormat("enum ShortEnum { A, B, C };"); 1925 1926 EXPECT_EQ("enum KeepEmptyLines {\n" 1927 " ONE,\n" 1928 "\n" 1929 " TWO,\n" 1930 "\n" 1931 " THREE\n" 1932 "}", 1933 format("enum KeepEmptyLines {\n" 1934 " ONE,\n" 1935 "\n" 1936 " TWO,\n" 1937 "\n" 1938 "\n" 1939 " THREE\n" 1940 "}")); 1941 verifyFormat("enum E { // comment\n" 1942 " ONE,\n" 1943 " TWO\n" 1944 "};\n" 1945 "int i;"); 1946 1947 FormatStyle EightIndent = getLLVMStyle(); 1948 EightIndent.IndentWidth = 8; 1949 verifyFormat("enum {\n" 1950 " VOID,\n" 1951 " CHAR,\n" 1952 " SHORT,\n" 1953 " INT,\n" 1954 " LONG,\n" 1955 " SIGNED,\n" 1956 " UNSIGNED,\n" 1957 " BOOL,\n" 1958 " FLOAT,\n" 1959 " DOUBLE,\n" 1960 " COMPLEX\n" 1961 "};", 1962 EightIndent); 1963 1964 // Not enums. 1965 verifyFormat("enum X f() {\n" 1966 " a();\n" 1967 " return 42;\n" 1968 "}"); 1969 verifyFormat("enum X Type::f() {\n" 1970 " a();\n" 1971 " return 42;\n" 1972 "}"); 1973 verifyFormat("enum ::X f() {\n" 1974 " a();\n" 1975 " return 42;\n" 1976 "}"); 1977 verifyFormat("enum ns::X f() {\n" 1978 " a();\n" 1979 " return 42;\n" 1980 "}"); 1981 } 1982 1983 TEST_F(FormatTest, FormatsEnumsWithErrors) { 1984 verifyFormat("enum Type {\n" 1985 " One = 0; // These semicolons should be commas.\n" 1986 " Two = 1;\n" 1987 "};"); 1988 verifyFormat("namespace n {\n" 1989 "enum Type {\n" 1990 " One,\n" 1991 " Two, // missing };\n" 1992 " int i;\n" 1993 "}\n" 1994 "void g() {}"); 1995 } 1996 1997 TEST_F(FormatTest, FormatsEnumStruct) { 1998 verifyFormat("enum struct {\n" 1999 " Zero,\n" 2000 " One = 1,\n" 2001 " Two = One + 1,\n" 2002 " Three = (One + Two),\n" 2003 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 2004 " Five = (One, Two, Three, Four, 5)\n" 2005 "};"); 2006 verifyFormat("enum struct Enum {};"); 2007 verifyFormat("enum struct {};"); 2008 verifyFormat("enum struct X E {} d;"); 2009 verifyFormat("enum struct __attribute__((...)) E {} d;"); 2010 verifyFormat("enum struct __declspec__((...)) E {} d;"); 2011 verifyFormat("enum struct X f() {\n a();\n return 42;\n}"); 2012 } 2013 2014 TEST_F(FormatTest, FormatsEnumClass) { 2015 verifyFormat("enum class {\n" 2016 " Zero,\n" 2017 " One = 1,\n" 2018 " Two = One + 1,\n" 2019 " Three = (One + Two),\n" 2020 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 2021 " Five = (One, Two, Three, Four, 5)\n" 2022 "};"); 2023 verifyFormat("enum class Enum {};"); 2024 verifyFormat("enum class {};"); 2025 verifyFormat("enum class X E {} d;"); 2026 verifyFormat("enum class __attribute__((...)) E {} d;"); 2027 verifyFormat("enum class __declspec__((...)) E {} d;"); 2028 verifyFormat("enum class X f() {\n a();\n return 42;\n}"); 2029 } 2030 2031 TEST_F(FormatTest, FormatsEnumTypes) { 2032 verifyFormat("enum X : int {\n" 2033 " A, // Force multiple lines.\n" 2034 " B\n" 2035 "};"); 2036 verifyFormat("enum X : int { A, B };"); 2037 verifyFormat("enum X : std::uint32_t { A, B };"); 2038 } 2039 2040 TEST_F(FormatTest, FormatsTypedefEnum) { 2041 FormatStyle Style = getLLVMStyle(); 2042 Style.ColumnLimit = 40; 2043 verifyFormat("typedef enum {} EmptyEnum;"); 2044 verifyFormat("typedef enum { A, B, C } ShortEnum;"); 2045 verifyFormat("typedef enum {\n" 2046 " ZERO = 0,\n" 2047 " ONE = 1,\n" 2048 " TWO = 2,\n" 2049 " THREE = 3\n" 2050 "} LongEnum;", 2051 Style); 2052 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 2053 Style.BraceWrapping.AfterEnum = true; 2054 verifyFormat("typedef enum {} EmptyEnum;"); 2055 verifyFormat("typedef enum { A, B, C } ShortEnum;"); 2056 verifyFormat("typedef enum\n" 2057 "{\n" 2058 " ZERO = 0,\n" 2059 " ONE = 1,\n" 2060 " TWO = 2,\n" 2061 " THREE = 3\n" 2062 "} LongEnum;", 2063 Style); 2064 } 2065 2066 TEST_F(FormatTest, FormatsNSEnums) { 2067 verifyGoogleFormat("typedef NS_ENUM(NSInteger, SomeName) { AAA, BBB }"); 2068 verifyGoogleFormat( 2069 "typedef NS_CLOSED_ENUM(NSInteger, SomeName) { AAA, BBB }"); 2070 verifyGoogleFormat("typedef NS_ENUM(NSInteger, MyType) {\n" 2071 " // Information about someDecentlyLongValue.\n" 2072 " someDecentlyLongValue,\n" 2073 " // Information about anotherDecentlyLongValue.\n" 2074 " anotherDecentlyLongValue,\n" 2075 " // Information about aThirdDecentlyLongValue.\n" 2076 " aThirdDecentlyLongValue\n" 2077 "};"); 2078 verifyGoogleFormat("typedef NS_CLOSED_ENUM(NSInteger, MyType) {\n" 2079 " // Information about someDecentlyLongValue.\n" 2080 " someDecentlyLongValue,\n" 2081 " // Information about anotherDecentlyLongValue.\n" 2082 " anotherDecentlyLongValue,\n" 2083 " // Information about aThirdDecentlyLongValue.\n" 2084 " aThirdDecentlyLongValue\n" 2085 "};"); 2086 verifyGoogleFormat("typedef NS_OPTIONS(NSInteger, MyType) {\n" 2087 " a = 1,\n" 2088 " b = 2,\n" 2089 " c = 3,\n" 2090 "};"); 2091 verifyGoogleFormat("typedef CF_ENUM(NSInteger, MyType) {\n" 2092 " a = 1,\n" 2093 " b = 2,\n" 2094 " c = 3,\n" 2095 "};"); 2096 verifyGoogleFormat("typedef CF_CLOSED_ENUM(NSInteger, MyType) {\n" 2097 " a = 1,\n" 2098 " b = 2,\n" 2099 " c = 3,\n" 2100 "};"); 2101 verifyGoogleFormat("typedef CF_OPTIONS(NSInteger, MyType) {\n" 2102 " a = 1,\n" 2103 " b = 2,\n" 2104 " c = 3,\n" 2105 "};"); 2106 } 2107 2108 TEST_F(FormatTest, FormatsBitfields) { 2109 verifyFormat("struct Bitfields {\n" 2110 " unsigned sClass : 8;\n" 2111 " unsigned ValueKind : 2;\n" 2112 "};"); 2113 verifyFormat("struct A {\n" 2114 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa : 1,\n" 2115 " bbbbbbbbbbbbbbbbbbbbbbbbb;\n" 2116 "};"); 2117 verifyFormat("struct MyStruct {\n" 2118 " uchar data;\n" 2119 " uchar : 8;\n" 2120 " uchar : 8;\n" 2121 " uchar other;\n" 2122 "};"); 2123 } 2124 2125 TEST_F(FormatTest, FormatsNamespaces) { 2126 FormatStyle LLVMWithNoNamespaceFix = getLLVMStyle(); 2127 LLVMWithNoNamespaceFix.FixNamespaceComments = false; 2128 2129 verifyFormat("namespace some_namespace {\n" 2130 "class A {};\n" 2131 "void f() { f(); }\n" 2132 "}", 2133 LLVMWithNoNamespaceFix); 2134 verifyFormat("namespace N::inline D {\n" 2135 "class A {};\n" 2136 "void f() { f(); }\n" 2137 "}", 2138 LLVMWithNoNamespaceFix); 2139 verifyFormat("namespace N::inline D::E {\n" 2140 "class A {};\n" 2141 "void f() { f(); }\n" 2142 "}", 2143 LLVMWithNoNamespaceFix); 2144 verifyFormat("namespace [[deprecated(\"foo[bar\")]] some_namespace {\n" 2145 "class A {};\n" 2146 "void f() { f(); }\n" 2147 "}", 2148 LLVMWithNoNamespaceFix); 2149 verifyFormat("/* something */ namespace some_namespace {\n" 2150 "class A {};\n" 2151 "void f() { f(); }\n" 2152 "}", 2153 LLVMWithNoNamespaceFix); 2154 verifyFormat("namespace {\n" 2155 "class A {};\n" 2156 "void f() { f(); }\n" 2157 "}", 2158 LLVMWithNoNamespaceFix); 2159 verifyFormat("/* something */ namespace {\n" 2160 "class A {};\n" 2161 "void f() { f(); }\n" 2162 "}", 2163 LLVMWithNoNamespaceFix); 2164 verifyFormat("inline namespace X {\n" 2165 "class A {};\n" 2166 "void f() { f(); }\n" 2167 "}", 2168 LLVMWithNoNamespaceFix); 2169 verifyFormat("/* something */ inline namespace X {\n" 2170 "class A {};\n" 2171 "void f() { f(); }\n" 2172 "}", 2173 LLVMWithNoNamespaceFix); 2174 verifyFormat("export namespace X {\n" 2175 "class A {};\n" 2176 "void f() { f(); }\n" 2177 "}", 2178 LLVMWithNoNamespaceFix); 2179 verifyFormat("using namespace some_namespace;\n" 2180 "class A {};\n" 2181 "void f() { f(); }", 2182 LLVMWithNoNamespaceFix); 2183 2184 // This code is more common than we thought; if we 2185 // layout this correctly the semicolon will go into 2186 // its own line, which is undesirable. 2187 verifyFormat("namespace {};", LLVMWithNoNamespaceFix); 2188 verifyFormat("namespace {\n" 2189 "class A {};\n" 2190 "};", 2191 LLVMWithNoNamespaceFix); 2192 2193 verifyFormat("namespace {\n" 2194 "int SomeVariable = 0; // comment\n" 2195 "} // namespace", 2196 LLVMWithNoNamespaceFix); 2197 EXPECT_EQ("#ifndef HEADER_GUARD\n" 2198 "#define HEADER_GUARD\n" 2199 "namespace my_namespace {\n" 2200 "int i;\n" 2201 "} // my_namespace\n" 2202 "#endif // HEADER_GUARD", 2203 format("#ifndef HEADER_GUARD\n" 2204 " #define HEADER_GUARD\n" 2205 " namespace my_namespace {\n" 2206 "int i;\n" 2207 "} // my_namespace\n" 2208 "#endif // HEADER_GUARD", 2209 LLVMWithNoNamespaceFix)); 2210 2211 EXPECT_EQ("namespace A::B {\n" 2212 "class C {};\n" 2213 "}", 2214 format("namespace A::B {\n" 2215 "class C {};\n" 2216 "}", 2217 LLVMWithNoNamespaceFix)); 2218 2219 FormatStyle Style = getLLVMStyle(); 2220 Style.NamespaceIndentation = FormatStyle::NI_All; 2221 EXPECT_EQ("namespace out {\n" 2222 " int i;\n" 2223 " namespace in {\n" 2224 " int i;\n" 2225 " } // namespace in\n" 2226 "} // namespace out", 2227 format("namespace out {\n" 2228 "int i;\n" 2229 "namespace in {\n" 2230 "int i;\n" 2231 "} // namespace in\n" 2232 "} // namespace out", 2233 Style)); 2234 2235 Style.NamespaceIndentation = FormatStyle::NI_Inner; 2236 EXPECT_EQ("namespace out {\n" 2237 "int i;\n" 2238 "namespace in {\n" 2239 " int i;\n" 2240 "} // namespace in\n" 2241 "} // namespace out", 2242 format("namespace out {\n" 2243 "int i;\n" 2244 "namespace in {\n" 2245 "int i;\n" 2246 "} // namespace in\n" 2247 "} // namespace out", 2248 Style)); 2249 } 2250 2251 TEST_F(FormatTest, NamespaceMacros) { 2252 FormatStyle Style = getLLVMStyle(); 2253 Style.NamespaceMacros.push_back("TESTSUITE"); 2254 2255 verifyFormat("TESTSUITE(A) {\n" 2256 "int foo();\n" 2257 "} // TESTSUITE(A)", 2258 Style); 2259 2260 verifyFormat("TESTSUITE(A, B) {\n" 2261 "int foo();\n" 2262 "} // TESTSUITE(A)", 2263 Style); 2264 2265 // Properly indent according to NamespaceIndentation style 2266 Style.NamespaceIndentation = FormatStyle::NI_All; 2267 verifyFormat("TESTSUITE(A) {\n" 2268 " int foo();\n" 2269 "} // TESTSUITE(A)", 2270 Style); 2271 verifyFormat("TESTSUITE(A) {\n" 2272 " namespace B {\n" 2273 " int foo();\n" 2274 " } // namespace B\n" 2275 "} // TESTSUITE(A)", 2276 Style); 2277 verifyFormat("namespace A {\n" 2278 " TESTSUITE(B) {\n" 2279 " int foo();\n" 2280 " } // TESTSUITE(B)\n" 2281 "} // namespace A", 2282 Style); 2283 2284 Style.NamespaceIndentation = FormatStyle::NI_Inner; 2285 verifyFormat("TESTSUITE(A) {\n" 2286 "TESTSUITE(B) {\n" 2287 " int foo();\n" 2288 "} // TESTSUITE(B)\n" 2289 "} // TESTSUITE(A)", 2290 Style); 2291 verifyFormat("TESTSUITE(A) {\n" 2292 "namespace B {\n" 2293 " int foo();\n" 2294 "} // namespace B\n" 2295 "} // TESTSUITE(A)", 2296 Style); 2297 verifyFormat("namespace A {\n" 2298 "TESTSUITE(B) {\n" 2299 " int foo();\n" 2300 "} // TESTSUITE(B)\n" 2301 "} // namespace A", 2302 Style); 2303 2304 // Properly merge namespace-macros blocks in CompactNamespaces mode 2305 Style.NamespaceIndentation = FormatStyle::NI_None; 2306 Style.CompactNamespaces = true; 2307 verifyFormat("TESTSUITE(A) { TESTSUITE(B) {\n" 2308 "}} // TESTSUITE(A::B)", 2309 Style); 2310 2311 EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n" 2312 "}} // TESTSUITE(out::in)", 2313 format("TESTSUITE(out) {\n" 2314 "TESTSUITE(in) {\n" 2315 "} // TESTSUITE(in)\n" 2316 "} // TESTSUITE(out)", 2317 Style)); 2318 2319 EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n" 2320 "}} // TESTSUITE(out::in)", 2321 format("TESTSUITE(out) {\n" 2322 "TESTSUITE(in) {\n" 2323 "} // TESTSUITE(in)\n" 2324 "} // TESTSUITE(out)", 2325 Style)); 2326 2327 // Do not merge different namespaces/macros 2328 EXPECT_EQ("namespace out {\n" 2329 "TESTSUITE(in) {\n" 2330 "} // TESTSUITE(in)\n" 2331 "} // namespace out", 2332 format("namespace out {\n" 2333 "TESTSUITE(in) {\n" 2334 "} // TESTSUITE(in)\n" 2335 "} // namespace out", 2336 Style)); 2337 EXPECT_EQ("TESTSUITE(out) {\n" 2338 "namespace in {\n" 2339 "} // namespace in\n" 2340 "} // TESTSUITE(out)", 2341 format("TESTSUITE(out) {\n" 2342 "namespace in {\n" 2343 "} // namespace in\n" 2344 "} // TESTSUITE(out)", 2345 Style)); 2346 Style.NamespaceMacros.push_back("FOOBAR"); 2347 EXPECT_EQ("TESTSUITE(out) {\n" 2348 "FOOBAR(in) {\n" 2349 "} // FOOBAR(in)\n" 2350 "} // TESTSUITE(out)", 2351 format("TESTSUITE(out) {\n" 2352 "FOOBAR(in) {\n" 2353 "} // FOOBAR(in)\n" 2354 "} // TESTSUITE(out)", 2355 Style)); 2356 } 2357 2358 TEST_F(FormatTest, FormatsCompactNamespaces) { 2359 FormatStyle Style = getLLVMStyle(); 2360 Style.CompactNamespaces = true; 2361 Style.NamespaceMacros.push_back("TESTSUITE"); 2362 2363 verifyFormat("namespace A { namespace B {\n" 2364 "}} // namespace A::B", 2365 Style); 2366 2367 EXPECT_EQ("namespace out { namespace in {\n" 2368 "}} // namespace out::in", 2369 format("namespace out {\n" 2370 "namespace in {\n" 2371 "} // namespace in\n" 2372 "} // namespace out", 2373 Style)); 2374 2375 // Only namespaces which have both consecutive opening and end get compacted 2376 EXPECT_EQ("namespace out {\n" 2377 "namespace in1 {\n" 2378 "} // namespace in1\n" 2379 "namespace in2 {\n" 2380 "} // namespace in2\n" 2381 "} // namespace out", 2382 format("namespace out {\n" 2383 "namespace in1 {\n" 2384 "} // namespace in1\n" 2385 "namespace in2 {\n" 2386 "} // namespace in2\n" 2387 "} // namespace out", 2388 Style)); 2389 2390 EXPECT_EQ("namespace out {\n" 2391 "int i;\n" 2392 "namespace in {\n" 2393 "int j;\n" 2394 "} // namespace in\n" 2395 "int k;\n" 2396 "} // namespace out", 2397 format("namespace out { int i;\n" 2398 "namespace in { int j; } // namespace in\n" 2399 "int k; } // namespace out", 2400 Style)); 2401 2402 EXPECT_EQ("namespace A { namespace B { namespace C {\n" 2403 "}}} // namespace A::B::C\n", 2404 format("namespace A { namespace B {\n" 2405 "namespace C {\n" 2406 "}} // namespace B::C\n" 2407 "} // namespace A\n", 2408 Style)); 2409 2410 Style.ColumnLimit = 40; 2411 EXPECT_EQ("namespace aaaaaaaaaa {\n" 2412 "namespace bbbbbbbbbb {\n" 2413 "}} // namespace aaaaaaaaaa::bbbbbbbbbb", 2414 format("namespace aaaaaaaaaa {\n" 2415 "namespace bbbbbbbbbb {\n" 2416 "} // namespace bbbbbbbbbb\n" 2417 "} // namespace aaaaaaaaaa", 2418 Style)); 2419 2420 EXPECT_EQ("namespace aaaaaa { namespace bbbbbb {\n" 2421 "namespace cccccc {\n" 2422 "}}} // namespace aaaaaa::bbbbbb::cccccc", 2423 format("namespace aaaaaa {\n" 2424 "namespace bbbbbb {\n" 2425 "namespace cccccc {\n" 2426 "} // namespace cccccc\n" 2427 "} // namespace bbbbbb\n" 2428 "} // namespace aaaaaa", 2429 Style)); 2430 Style.ColumnLimit = 80; 2431 2432 // Extra semicolon after 'inner' closing brace prevents merging 2433 EXPECT_EQ("namespace out { namespace in {\n" 2434 "}; } // namespace out::in", 2435 format("namespace out {\n" 2436 "namespace in {\n" 2437 "}; // namespace in\n" 2438 "} // namespace out", 2439 Style)); 2440 2441 // Extra semicolon after 'outer' closing brace is conserved 2442 EXPECT_EQ("namespace out { namespace in {\n" 2443 "}}; // namespace out::in", 2444 format("namespace out {\n" 2445 "namespace in {\n" 2446 "} // namespace in\n" 2447 "}; // namespace out", 2448 Style)); 2449 2450 Style.NamespaceIndentation = FormatStyle::NI_All; 2451 EXPECT_EQ("namespace out { namespace in {\n" 2452 " int i;\n" 2453 "}} // namespace out::in", 2454 format("namespace out {\n" 2455 "namespace in {\n" 2456 "int i;\n" 2457 "} // namespace in\n" 2458 "} // namespace out", 2459 Style)); 2460 EXPECT_EQ("namespace out { namespace mid {\n" 2461 " namespace in {\n" 2462 " int j;\n" 2463 " } // namespace in\n" 2464 " int k;\n" 2465 "}} // namespace out::mid", 2466 format("namespace out { namespace mid {\n" 2467 "namespace in { int j; } // namespace in\n" 2468 "int k; }} // namespace out::mid", 2469 Style)); 2470 2471 Style.NamespaceIndentation = FormatStyle::NI_Inner; 2472 EXPECT_EQ("namespace out { namespace in {\n" 2473 " int i;\n" 2474 "}} // namespace out::in", 2475 format("namespace out {\n" 2476 "namespace in {\n" 2477 "int i;\n" 2478 "} // namespace in\n" 2479 "} // namespace out", 2480 Style)); 2481 EXPECT_EQ("namespace out { namespace mid { namespace in {\n" 2482 " int i;\n" 2483 "}}} // namespace out::mid::in", 2484 format("namespace out {\n" 2485 "namespace mid {\n" 2486 "namespace in {\n" 2487 "int i;\n" 2488 "} // namespace in\n" 2489 "} // namespace mid\n" 2490 "} // namespace out", 2491 Style)); 2492 } 2493 2494 TEST_F(FormatTest, FormatsExternC) { 2495 verifyFormat("extern \"C\" {\nint a;"); 2496 verifyFormat("extern \"C\" {}"); 2497 verifyFormat("extern \"C\" {\n" 2498 "int foo();\n" 2499 "}"); 2500 verifyFormat("extern \"C\" int foo() {}"); 2501 verifyFormat("extern \"C\" int foo();"); 2502 verifyFormat("extern \"C\" int foo() {\n" 2503 " int i = 42;\n" 2504 " return i;\n" 2505 "}"); 2506 2507 FormatStyle Style = getLLVMStyle(); 2508 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 2509 Style.BraceWrapping.AfterFunction = true; 2510 verifyFormat("extern \"C\" int foo() {}", Style); 2511 verifyFormat("extern \"C\" int foo();", Style); 2512 verifyFormat("extern \"C\" int foo()\n" 2513 "{\n" 2514 " int i = 42;\n" 2515 " return i;\n" 2516 "}", 2517 Style); 2518 2519 Style.BraceWrapping.AfterExternBlock = true; 2520 Style.BraceWrapping.SplitEmptyRecord = false; 2521 verifyFormat("extern \"C\"\n" 2522 "{}", 2523 Style); 2524 verifyFormat("extern \"C\"\n" 2525 "{\n" 2526 " int foo();\n" 2527 "}", 2528 Style); 2529 } 2530 2531 TEST_F(FormatTest, FormatsInlineASM) { 2532 verifyFormat("asm(\"xyz\" : \"=a\"(a), \"=d\"(b) : \"a\"(data));"); 2533 verifyFormat("asm(\"nop\" ::: \"memory\");"); 2534 verifyFormat( 2535 "asm(\"movq\\t%%rbx, %%rsi\\n\\t\"\n" 2536 " \"cpuid\\n\\t\"\n" 2537 " \"xchgq\\t%%rbx, %%rsi\\n\\t\"\n" 2538 " : \"=a\"(*rEAX), \"=S\"(*rEBX), \"=c\"(*rECX), \"=d\"(*rEDX)\n" 2539 " : \"a\"(value));"); 2540 EXPECT_EQ( 2541 "void NS_InvokeByIndex(void *that, unsigned int methodIndex) {\n" 2542 " __asm {\n" 2543 " mov edx,[that] // vtable in edx\n" 2544 " mov eax,methodIndex\n" 2545 " call [edx][eax*4] // stdcall\n" 2546 " }\n" 2547 "}", 2548 format("void NS_InvokeByIndex(void *that, unsigned int methodIndex) {\n" 2549 " __asm {\n" 2550 " mov edx,[that] // vtable in edx\n" 2551 " mov eax,methodIndex\n" 2552 " call [edx][eax*4] // stdcall\n" 2553 " }\n" 2554 "}")); 2555 EXPECT_EQ("_asm {\n" 2556 " xor eax, eax;\n" 2557 " cpuid;\n" 2558 "}", 2559 format("_asm {\n" 2560 " xor eax, eax;\n" 2561 " cpuid;\n" 2562 "}")); 2563 verifyFormat("void function() {\n" 2564 " // comment\n" 2565 " asm(\"\");\n" 2566 "}"); 2567 EXPECT_EQ("__asm {\n" 2568 "}\n" 2569 "int i;", 2570 format("__asm {\n" 2571 "}\n" 2572 "int i;")); 2573 } 2574 2575 TEST_F(FormatTest, FormatTryCatch) { 2576 verifyFormat("try {\n" 2577 " throw a * b;\n" 2578 "} catch (int a) {\n" 2579 " // Do nothing.\n" 2580 "} catch (...) {\n" 2581 " exit(42);\n" 2582 "}"); 2583 2584 // Function-level try statements. 2585 verifyFormat("int f() try { return 4; } catch (...) {\n" 2586 " return 5;\n" 2587 "}"); 2588 verifyFormat("class A {\n" 2589 " int a;\n" 2590 " A() try : a(0) {\n" 2591 " } catch (...) {\n" 2592 " throw;\n" 2593 " }\n" 2594 "};\n"); 2595 2596 // Incomplete try-catch blocks. 2597 verifyIncompleteFormat("try {} catch ("); 2598 } 2599 2600 TEST_F(FormatTest, FormatSEHTryCatch) { 2601 verifyFormat("__try {\n" 2602 " int a = b * c;\n" 2603 "} __except (EXCEPTION_EXECUTE_HANDLER) {\n" 2604 " // Do nothing.\n" 2605 "}"); 2606 2607 verifyFormat("__try {\n" 2608 " int a = b * c;\n" 2609 "} __finally {\n" 2610 " // Do nothing.\n" 2611 "}"); 2612 2613 verifyFormat("DEBUG({\n" 2614 " __try {\n" 2615 " } __finally {\n" 2616 " }\n" 2617 "});\n"); 2618 } 2619 2620 TEST_F(FormatTest, IncompleteTryCatchBlocks) { 2621 verifyFormat("try {\n" 2622 " f();\n" 2623 "} catch {\n" 2624 " g();\n" 2625 "}"); 2626 verifyFormat("try {\n" 2627 " f();\n" 2628 "} catch (A a) MACRO(x) {\n" 2629 " g();\n" 2630 "} catch (B b) MACRO(x) {\n" 2631 " g();\n" 2632 "}"); 2633 } 2634 2635 TEST_F(FormatTest, FormatTryCatchBraceStyles) { 2636 FormatStyle Style = getLLVMStyle(); 2637 for (auto BraceStyle : {FormatStyle::BS_Attach, FormatStyle::BS_Mozilla, 2638 FormatStyle::BS_WebKit}) { 2639 Style.BreakBeforeBraces = BraceStyle; 2640 verifyFormat("try {\n" 2641 " // something\n" 2642 "} catch (...) {\n" 2643 " // something\n" 2644 "}", 2645 Style); 2646 } 2647 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 2648 verifyFormat("try {\n" 2649 " // something\n" 2650 "}\n" 2651 "catch (...) {\n" 2652 " // something\n" 2653 "}", 2654 Style); 2655 verifyFormat("__try {\n" 2656 " // something\n" 2657 "}\n" 2658 "__finally {\n" 2659 " // something\n" 2660 "}", 2661 Style); 2662 verifyFormat("@try {\n" 2663 " // something\n" 2664 "}\n" 2665 "@finally {\n" 2666 " // something\n" 2667 "}", 2668 Style); 2669 Style.BreakBeforeBraces = FormatStyle::BS_Allman; 2670 verifyFormat("try\n" 2671 "{\n" 2672 " // something\n" 2673 "}\n" 2674 "catch (...)\n" 2675 "{\n" 2676 " // something\n" 2677 "}", 2678 Style); 2679 Style.BreakBeforeBraces = FormatStyle::BS_Whitesmiths; 2680 verifyFormat("try\n" 2681 " {\n" 2682 " // something white\n" 2683 " }\n" 2684 "catch (...)\n" 2685 " {\n" 2686 " // something white\n" 2687 " }", 2688 Style); 2689 Style.BreakBeforeBraces = FormatStyle::BS_GNU; 2690 verifyFormat("try\n" 2691 " {\n" 2692 " // something\n" 2693 " }\n" 2694 "catch (...)\n" 2695 " {\n" 2696 " // something\n" 2697 " }", 2698 Style); 2699 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 2700 Style.BraceWrapping.BeforeCatch = true; 2701 verifyFormat("try {\n" 2702 " // something\n" 2703 "}\n" 2704 "catch (...) {\n" 2705 " // something\n" 2706 "}", 2707 Style); 2708 } 2709 2710 TEST_F(FormatTest, StaticInitializers) { 2711 verifyFormat("static SomeClass SC = {1, 'a'};"); 2712 2713 verifyFormat("static SomeClass WithALoooooooooooooooooooongName = {\n" 2714 " 100000000, " 2715 "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"};"); 2716 2717 // Here, everything other than the "}" would fit on a line. 2718 verifyFormat("static int LooooooooooooooooooooooooongVariable[1] = {\n" 2719 " 10000000000000000000000000};"); 2720 EXPECT_EQ("S s = {a,\n" 2721 "\n" 2722 " b};", 2723 format("S s = {\n" 2724 " a,\n" 2725 "\n" 2726 " b\n" 2727 "};")); 2728 2729 // FIXME: This would fit into the column limit if we'd fit "{ {" on the first 2730 // line. However, the formatting looks a bit off and this probably doesn't 2731 // happen often in practice. 2732 verifyFormat("static int Variable[1] = {\n" 2733 " {1000000000000000000000000000000000000}};", 2734 getLLVMStyleWithColumns(40)); 2735 } 2736 2737 TEST_F(FormatTest, DesignatedInitializers) { 2738 verifyFormat("const struct A a = {.a = 1, .b = 2};"); 2739 verifyFormat("const struct A a = {.aaaaaaaaaa = 1,\n" 2740 " .bbbbbbbbbb = 2,\n" 2741 " .cccccccccc = 3,\n" 2742 " .dddddddddd = 4,\n" 2743 " .eeeeeeeeee = 5};"); 2744 verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n" 2745 " .aaaaaaaaaaaaaaaaaaaaaaaaaaa = 1,\n" 2746 " .bbbbbbbbbbbbbbbbbbbbbbbbbbb = 2,\n" 2747 " .ccccccccccccccccccccccccccc = 3,\n" 2748 " .ddddddddddddddddddddddddddd = 4,\n" 2749 " .eeeeeeeeeeeeeeeeeeeeeeeeeee = 5};"); 2750 2751 verifyGoogleFormat("const struct A a = {.a = 1, .b = 2};"); 2752 2753 verifyFormat("const struct A a = {[0] = 1, [1] = 2};"); 2754 verifyFormat("const struct A a = {[1] = aaaaaaaaaa,\n" 2755 " [2] = bbbbbbbbbb,\n" 2756 " [3] = cccccccccc,\n" 2757 " [4] = dddddddddd,\n" 2758 " [5] = eeeeeeeeee};"); 2759 verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n" 2760 " [1] = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 2761 " [2] = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" 2762 " [3] = cccccccccccccccccccccccccccccccccccccc,\n" 2763 " [4] = dddddddddddddddddddddddddddddddddddddd,\n" 2764 " [5] = eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee};"); 2765 } 2766 2767 TEST_F(FormatTest, NestedStaticInitializers) { 2768 verifyFormat("static A x = {{{}}};\n"); 2769 verifyFormat("static A x = {{{init1, init2, init3, init4},\n" 2770 " {init1, init2, init3, init4}}};", 2771 getLLVMStyleWithColumns(50)); 2772 2773 verifyFormat("somes Status::global_reps[3] = {\n" 2774 " {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n" 2775 " {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n" 2776 " {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};", 2777 getLLVMStyleWithColumns(60)); 2778 verifyGoogleFormat("SomeType Status::global_reps[3] = {\n" 2779 " {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n" 2780 " {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n" 2781 " {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};"); 2782 verifyFormat("CGRect cg_rect = {{rect.fLeft, rect.fTop},\n" 2783 " {rect.fRight - rect.fLeft, rect.fBottom - " 2784 "rect.fTop}};"); 2785 2786 verifyFormat( 2787 "SomeArrayOfSomeType a = {\n" 2788 " {{1, 2, 3},\n" 2789 " {1, 2, 3},\n" 2790 " {111111111111111111111111111111, 222222222222222222222222222222,\n" 2791 " 333333333333333333333333333333},\n" 2792 " {1, 2, 3},\n" 2793 " {1, 2, 3}}};"); 2794 verifyFormat( 2795 "SomeArrayOfSomeType a = {\n" 2796 " {{1, 2, 3}},\n" 2797 " {{1, 2, 3}},\n" 2798 " {{111111111111111111111111111111, 222222222222222222222222222222,\n" 2799 " 333333333333333333333333333333}},\n" 2800 " {{1, 2, 3}},\n" 2801 " {{1, 2, 3}}};"); 2802 2803 verifyFormat("struct {\n" 2804 " unsigned bit;\n" 2805 " const char *const name;\n" 2806 "} kBitsToOs[] = {{kOsMac, \"Mac\"},\n" 2807 " {kOsWin, \"Windows\"},\n" 2808 " {kOsLinux, \"Linux\"},\n" 2809 " {kOsCrOS, \"Chrome OS\"}};"); 2810 verifyFormat("struct {\n" 2811 " unsigned bit;\n" 2812 " const char *const name;\n" 2813 "} kBitsToOs[] = {\n" 2814 " {kOsMac, \"Mac\"},\n" 2815 " {kOsWin, \"Windows\"},\n" 2816 " {kOsLinux, \"Linux\"},\n" 2817 " {kOsCrOS, \"Chrome OS\"},\n" 2818 "};"); 2819 } 2820 2821 TEST_F(FormatTest, FormatsSmallMacroDefinitionsInSingleLine) { 2822 verifyFormat("#define ALooooooooooooooooooooooooooooooooooooooongMacro(" 2823 " \\\n" 2824 " aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)"); 2825 } 2826 2827 TEST_F(FormatTest, DoesNotBreakPureVirtualFunctionDefinition) { 2828 verifyFormat("virtual void write(ELFWriter *writerrr,\n" 2829 " OwningPtr<FileOutputBuffer> &buffer) = 0;"); 2830 2831 // Do break defaulted and deleted functions. 2832 verifyFormat("virtual void ~Deeeeeeeestructor() =\n" 2833 " default;", 2834 getLLVMStyleWithColumns(40)); 2835 verifyFormat("virtual void ~Deeeeeeeestructor() =\n" 2836 " delete;", 2837 getLLVMStyleWithColumns(40)); 2838 } 2839 2840 TEST_F(FormatTest, BreaksStringLiteralsOnlyInDefine) { 2841 verifyFormat("# 1111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\" 2 3", 2842 getLLVMStyleWithColumns(40)); 2843 verifyFormat("#line 11111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"", 2844 getLLVMStyleWithColumns(40)); 2845 EXPECT_EQ("#define Q \\\n" 2846 " \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/\" \\\n" 2847 " \"aaaaaaaa.cpp\"", 2848 format("#define Q \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"", 2849 getLLVMStyleWithColumns(40))); 2850 } 2851 2852 TEST_F(FormatTest, UnderstandsLinePPDirective) { 2853 EXPECT_EQ("# 123 \"A string literal\"", 2854 format(" # 123 \"A string literal\"")); 2855 } 2856 2857 TEST_F(FormatTest, LayoutUnknownPPDirective) { 2858 EXPECT_EQ("#;", format("#;")); 2859 verifyFormat("#\n;\n;\n;"); 2860 } 2861 2862 TEST_F(FormatTest, UnescapedEndOfLineEndsPPDirective) { 2863 EXPECT_EQ("#line 42 \"test\"\n", 2864 format("# \\\n line \\\n 42 \\\n \"test\"\n")); 2865 EXPECT_EQ("#define A B\n", format("# \\\n define \\\n A \\\n B\n", 2866 getLLVMStyleWithColumns(12))); 2867 } 2868 2869 TEST_F(FormatTest, EndOfFileEndsPPDirective) { 2870 EXPECT_EQ("#line 42 \"test\"", 2871 format("# \\\n line \\\n 42 \\\n \"test\"")); 2872 EXPECT_EQ("#define A B", format("# \\\n define \\\n A \\\n B")); 2873 } 2874 2875 TEST_F(FormatTest, DoesntRemoveUnknownTokens) { 2876 verifyFormat("#define A \\x20"); 2877 verifyFormat("#define A \\ x20"); 2878 EXPECT_EQ("#define A \\ x20", format("#define A \\ x20")); 2879 verifyFormat("#define A ''"); 2880 verifyFormat("#define A ''qqq"); 2881 verifyFormat("#define A `qqq"); 2882 verifyFormat("f(\"aaaa, bbbb, \"\\\"ccccc\\\"\");"); 2883 EXPECT_EQ("const char *c = STRINGIFY(\n" 2884 "\\na : b);", 2885 format("const char * c = STRINGIFY(\n" 2886 "\\na : b);")); 2887 2888 verifyFormat("a\r\\"); 2889 verifyFormat("a\v\\"); 2890 verifyFormat("a\f\\"); 2891 } 2892 2893 TEST_F(FormatTest, IndentsPPDirectiveInReducedSpace) { 2894 verifyFormat("#define A(BB)", getLLVMStyleWithColumns(13)); 2895 verifyFormat("#define A( \\\n BB)", getLLVMStyleWithColumns(12)); 2896 verifyFormat("#define A( \\\n A, B)", getLLVMStyleWithColumns(12)); 2897 // FIXME: We never break before the macro name. 2898 verifyFormat("#define AA( \\\n B)", getLLVMStyleWithColumns(12)); 2899 2900 verifyFormat("#define A A\n#define A A"); 2901 verifyFormat("#define A(X) A\n#define A A"); 2902 2903 verifyFormat("#define Something Other", getLLVMStyleWithColumns(23)); 2904 verifyFormat("#define Something \\\n Other", getLLVMStyleWithColumns(22)); 2905 } 2906 2907 TEST_F(FormatTest, HandlePreprocessorDirectiveContext) { 2908 EXPECT_EQ("// somecomment\n" 2909 "#include \"a.h\"\n" 2910 "#define A( \\\n" 2911 " A, B)\n" 2912 "#include \"b.h\"\n" 2913 "// somecomment\n", 2914 format(" // somecomment\n" 2915 " #include \"a.h\"\n" 2916 "#define A(A,\\\n" 2917 " B)\n" 2918 " #include \"b.h\"\n" 2919 " // somecomment\n", 2920 getLLVMStyleWithColumns(13))); 2921 } 2922 2923 TEST_F(FormatTest, LayoutSingleHash) { EXPECT_EQ("#\na;", format("#\na;")); } 2924 2925 TEST_F(FormatTest, LayoutCodeInMacroDefinitions) { 2926 EXPECT_EQ("#define A \\\n" 2927 " c; \\\n" 2928 " e;\n" 2929 "f;", 2930 format("#define A c; e;\n" 2931 "f;", 2932 getLLVMStyleWithColumns(14))); 2933 } 2934 2935 TEST_F(FormatTest, LayoutRemainingTokens) { EXPECT_EQ("{}", format("{}")); } 2936 2937 TEST_F(FormatTest, MacroDefinitionInsideStatement) { 2938 EXPECT_EQ("int x,\n" 2939 "#define A\n" 2940 " y;", 2941 format("int x,\n#define A\ny;")); 2942 } 2943 2944 TEST_F(FormatTest, HashInMacroDefinition) { 2945 EXPECT_EQ("#define A(c) L#c", format("#define A(c) L#c", getLLVMStyle())); 2946 verifyFormat("#define A \\\n b #c;", getLLVMStyleWithColumns(11)); 2947 verifyFormat("#define A \\\n" 2948 " { \\\n" 2949 " f(#c); \\\n" 2950 " }", 2951 getLLVMStyleWithColumns(11)); 2952 2953 verifyFormat("#define A(X) \\\n" 2954 " void function##X()", 2955 getLLVMStyleWithColumns(22)); 2956 2957 verifyFormat("#define A(a, b, c) \\\n" 2958 " void a##b##c()", 2959 getLLVMStyleWithColumns(22)); 2960 2961 verifyFormat("#define A void # ## #", getLLVMStyleWithColumns(22)); 2962 } 2963 2964 TEST_F(FormatTest, RespectWhitespaceInMacroDefinitions) { 2965 EXPECT_EQ("#define A (x)", format("#define A (x)")); 2966 EXPECT_EQ("#define A(x)", format("#define A(x)")); 2967 2968 FormatStyle Style = getLLVMStyle(); 2969 Style.SpaceBeforeParens = FormatStyle::SBPO_Never; 2970 verifyFormat("#define true ((foo)1)", Style); 2971 Style.SpaceBeforeParens = FormatStyle::SBPO_Always; 2972 verifyFormat("#define false((foo)0)", Style); 2973 } 2974 2975 TEST_F(FormatTest, EmptyLinesInMacroDefinitions) { 2976 EXPECT_EQ("#define A b;", format("#define A \\\n" 2977 " \\\n" 2978 " b;", 2979 getLLVMStyleWithColumns(25))); 2980 EXPECT_EQ("#define A \\\n" 2981 " \\\n" 2982 " a; \\\n" 2983 " b;", 2984 format("#define A \\\n" 2985 " \\\n" 2986 " a; \\\n" 2987 " b;", 2988 getLLVMStyleWithColumns(11))); 2989 EXPECT_EQ("#define A \\\n" 2990 " a; \\\n" 2991 " \\\n" 2992 " b;", 2993 format("#define A \\\n" 2994 " a; \\\n" 2995 " \\\n" 2996 " b;", 2997 getLLVMStyleWithColumns(11))); 2998 } 2999 3000 TEST_F(FormatTest, MacroDefinitionsWithIncompleteCode) { 3001 verifyIncompleteFormat("#define A :"); 3002 verifyFormat("#define SOMECASES \\\n" 3003 " case 1: \\\n" 3004 " case 2\n", 3005 getLLVMStyleWithColumns(20)); 3006 verifyFormat("#define MACRO(a) \\\n" 3007 " if (a) \\\n" 3008 " f(); \\\n" 3009 " else \\\n" 3010 " g()", 3011 getLLVMStyleWithColumns(18)); 3012 verifyFormat("#define A template <typename T>"); 3013 verifyIncompleteFormat("#define STR(x) #x\n" 3014 "f(STR(this_is_a_string_literal{));"); 3015 verifyFormat("#pragma omp threadprivate( \\\n" 3016 " y)), // expected-warning", 3017 getLLVMStyleWithColumns(28)); 3018 verifyFormat("#d, = };"); 3019 verifyFormat("#if \"a"); 3020 verifyIncompleteFormat("({\n" 3021 "#define b \\\n" 3022 " } \\\n" 3023 " a\n" 3024 "a", 3025 getLLVMStyleWithColumns(15)); 3026 verifyFormat("#define A \\\n" 3027 " { \\\n" 3028 " {\n" 3029 "#define B \\\n" 3030 " } \\\n" 3031 " }", 3032 getLLVMStyleWithColumns(15)); 3033 verifyNoCrash("#if a\na(\n#else\n#endif\n{a"); 3034 verifyNoCrash("a={0,1\n#if a\n#else\n;\n#endif\n}"); 3035 verifyNoCrash("#if a\na(\n#else\n#endif\n) a {a,b,c,d,f,g};"); 3036 verifyNoCrash("#ifdef A\n a(\n #else\n #endif\n) = []() { \n)}"); 3037 } 3038 3039 TEST_F(FormatTest, MacrosWithoutTrailingSemicolon) { 3040 verifyFormat("SOME_TYPE_NAME abc;"); // Gated on the newline. 3041 EXPECT_EQ("class A : public QObject {\n" 3042 " Q_OBJECT\n" 3043 "\n" 3044 " A() {}\n" 3045 "};", 3046 format("class A : public QObject {\n" 3047 " Q_OBJECT\n" 3048 "\n" 3049 " A() {\n}\n" 3050 "} ;")); 3051 EXPECT_EQ("MACRO\n" 3052 "/*static*/ int i;", 3053 format("MACRO\n" 3054 " /*static*/ int i;")); 3055 EXPECT_EQ("SOME_MACRO\n" 3056 "namespace {\n" 3057 "void f();\n" 3058 "} // namespace", 3059 format("SOME_MACRO\n" 3060 " namespace {\n" 3061 "void f( );\n" 3062 "} // namespace")); 3063 // Only if the identifier contains at least 5 characters. 3064 EXPECT_EQ("HTTP f();", format("HTTP\nf();")); 3065 EXPECT_EQ("MACRO\nf();", format("MACRO\nf();")); 3066 // Only if everything is upper case. 3067 EXPECT_EQ("class A : public QObject {\n" 3068 " Q_Object A() {}\n" 3069 "};", 3070 format("class A : public QObject {\n" 3071 " Q_Object\n" 3072 " A() {\n}\n" 3073 "} ;")); 3074 3075 // Only if the next line can actually start an unwrapped line. 3076 EXPECT_EQ("SOME_WEIRD_LOG_MACRO << SomeThing;", 3077 format("SOME_WEIRD_LOG_MACRO\n" 3078 "<< SomeThing;")); 3079 3080 verifyFormat("VISIT_GL_CALL(GenBuffers, void, (GLsizei n, GLuint* buffers), " 3081 "(n, buffers))\n", 3082 getChromiumStyle(FormatStyle::LK_Cpp)); 3083 3084 // See PR41483 3085 EXPECT_EQ("/**/ FOO(a)\n" 3086 "FOO(b)", 3087 format("/**/ FOO(a)\n" 3088 "FOO(b)")); 3089 } 3090 3091 TEST_F(FormatTest, MacroCallsWithoutTrailingSemicolon) { 3092 EXPECT_EQ("INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n" 3093 "INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n" 3094 "INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n" 3095 "class X {};\n" 3096 "INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n" 3097 "int *createScopDetectionPass() { return 0; }", 3098 format(" INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n" 3099 " INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n" 3100 " INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n" 3101 " class X {};\n" 3102 " INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n" 3103 " int *createScopDetectionPass() { return 0; }")); 3104 // FIXME: We could probably treat IPC_BEGIN_MESSAGE_MAP/IPC_END_MESSAGE_MAP as 3105 // braces, so that inner block is indented one level more. 3106 EXPECT_EQ("int q() {\n" 3107 " IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n" 3108 " IPC_MESSAGE_HANDLER(xxx, qqq)\n" 3109 " IPC_END_MESSAGE_MAP()\n" 3110 "}", 3111 format("int q() {\n" 3112 " IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n" 3113 " IPC_MESSAGE_HANDLER(xxx, qqq)\n" 3114 " IPC_END_MESSAGE_MAP()\n" 3115 "}")); 3116 3117 // Same inside macros. 3118 EXPECT_EQ("#define LIST(L) \\\n" 3119 " L(A) \\\n" 3120 " L(B) \\\n" 3121 " L(C)", 3122 format("#define LIST(L) \\\n" 3123 " L(A) \\\n" 3124 " L(B) \\\n" 3125 " L(C)", 3126 getGoogleStyle())); 3127 3128 // These must not be recognized as macros. 3129 EXPECT_EQ("int q() {\n" 3130 " f(x);\n" 3131 " f(x) {}\n" 3132 " f(x)->g();\n" 3133 " f(x)->*g();\n" 3134 " f(x).g();\n" 3135 " f(x) = x;\n" 3136 " f(x) += x;\n" 3137 " f(x) -= x;\n" 3138 " f(x) *= x;\n" 3139 " f(x) /= x;\n" 3140 " f(x) %= x;\n" 3141 " f(x) &= x;\n" 3142 " f(x) |= x;\n" 3143 " f(x) ^= x;\n" 3144 " f(x) >>= x;\n" 3145 " f(x) <<= x;\n" 3146 " f(x)[y].z();\n" 3147 " LOG(INFO) << x;\n" 3148 " ifstream(x) >> x;\n" 3149 "}\n", 3150 format("int q() {\n" 3151 " f(x)\n;\n" 3152 " f(x)\n {}\n" 3153 " f(x)\n->g();\n" 3154 " f(x)\n->*g();\n" 3155 " f(x)\n.g();\n" 3156 " f(x)\n = x;\n" 3157 " f(x)\n += x;\n" 3158 " f(x)\n -= x;\n" 3159 " f(x)\n *= x;\n" 3160 " f(x)\n /= x;\n" 3161 " f(x)\n %= x;\n" 3162 " f(x)\n &= x;\n" 3163 " f(x)\n |= x;\n" 3164 " f(x)\n ^= x;\n" 3165 " f(x)\n >>= x;\n" 3166 " f(x)\n <<= x;\n" 3167 " f(x)\n[y].z();\n" 3168 " LOG(INFO)\n << x;\n" 3169 " ifstream(x)\n >> x;\n" 3170 "}\n")); 3171 EXPECT_EQ("int q() {\n" 3172 " F(x)\n" 3173 " if (1) {\n" 3174 " }\n" 3175 " F(x)\n" 3176 " while (1) {\n" 3177 " }\n" 3178 " F(x)\n" 3179 " G(x);\n" 3180 " F(x)\n" 3181 " try {\n" 3182 " Q();\n" 3183 " } catch (...) {\n" 3184 " }\n" 3185 "}\n", 3186 format("int q() {\n" 3187 "F(x)\n" 3188 "if (1) {}\n" 3189 "F(x)\n" 3190 "while (1) {}\n" 3191 "F(x)\n" 3192 "G(x);\n" 3193 "F(x)\n" 3194 "try { Q(); } catch (...) {}\n" 3195 "}\n")); 3196 EXPECT_EQ("class A {\n" 3197 " A() : t(0) {}\n" 3198 " A(int i) noexcept() : {}\n" 3199 " A(X x)\n" // FIXME: function-level try blocks are broken. 3200 " try : t(0) {\n" 3201 " } catch (...) {\n" 3202 " }\n" 3203 "};", 3204 format("class A {\n" 3205 " A()\n : t(0) {}\n" 3206 " A(int i)\n noexcept() : {}\n" 3207 " A(X x)\n" 3208 " try : t(0) {} catch (...) {}\n" 3209 "};")); 3210 FormatStyle Style = getLLVMStyle(); 3211 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 3212 Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always; 3213 Style.BraceWrapping.AfterFunction = true; 3214 EXPECT_EQ("void f()\n" 3215 "try\n" 3216 "{\n" 3217 "}", 3218 format("void f() try {\n" 3219 "}", 3220 Style)); 3221 EXPECT_EQ("class SomeClass {\n" 3222 "public:\n" 3223 " SomeClass() EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 3224 "};", 3225 format("class SomeClass {\n" 3226 "public:\n" 3227 " SomeClass()\n" 3228 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 3229 "};")); 3230 EXPECT_EQ("class SomeClass {\n" 3231 "public:\n" 3232 " SomeClass()\n" 3233 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 3234 "};", 3235 format("class SomeClass {\n" 3236 "public:\n" 3237 " SomeClass()\n" 3238 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 3239 "};", 3240 getLLVMStyleWithColumns(40))); 3241 3242 verifyFormat("MACRO(>)"); 3243 3244 // Some macros contain an implicit semicolon. 3245 Style = getLLVMStyle(); 3246 Style.StatementMacros.push_back("FOO"); 3247 verifyFormat("FOO(a) int b = 0;"); 3248 verifyFormat("FOO(a)\n" 3249 "int b = 0;", 3250 Style); 3251 verifyFormat("FOO(a);\n" 3252 "int b = 0;", 3253 Style); 3254 verifyFormat("FOO(argc, argv, \"4.0.2\")\n" 3255 "int b = 0;", 3256 Style); 3257 verifyFormat("FOO()\n" 3258 "int b = 0;", 3259 Style); 3260 verifyFormat("FOO\n" 3261 "int b = 0;", 3262 Style); 3263 verifyFormat("void f() {\n" 3264 " FOO(a)\n" 3265 " return a;\n" 3266 "}", 3267 Style); 3268 verifyFormat("FOO(a)\n" 3269 "FOO(b)", 3270 Style); 3271 verifyFormat("int a = 0;\n" 3272 "FOO(b)\n" 3273 "int c = 0;", 3274 Style); 3275 verifyFormat("int a = 0;\n" 3276 "int x = FOO(a)\n" 3277 "int b = 0;", 3278 Style); 3279 verifyFormat("void foo(int a) { FOO(a) }\n" 3280 "uint32_t bar() {}", 3281 Style); 3282 } 3283 3284 TEST_F(FormatTest, LayoutMacroDefinitionsStatementsSpanningBlocks) { 3285 verifyFormat("#define A \\\n" 3286 " f({ \\\n" 3287 " g(); \\\n" 3288 " });", 3289 getLLVMStyleWithColumns(11)); 3290 } 3291 3292 TEST_F(FormatTest, IndentPreprocessorDirectives) { 3293 FormatStyle Style = getLLVMStyle(); 3294 Style.IndentPPDirectives = FormatStyle::PPDIS_None; 3295 Style.ColumnLimit = 40; 3296 verifyFormat("#ifdef _WIN32\n" 3297 "#define A 0\n" 3298 "#ifdef VAR2\n" 3299 "#define B 1\n" 3300 "#include <someheader.h>\n" 3301 "#define MACRO \\\n" 3302 " some_very_long_func_aaaaaaaaaa();\n" 3303 "#endif\n" 3304 "#else\n" 3305 "#define A 1\n" 3306 "#endif", 3307 Style); 3308 Style.IndentPPDirectives = FormatStyle::PPDIS_AfterHash; 3309 verifyFormat("#ifdef _WIN32\n" 3310 "# define A 0\n" 3311 "# ifdef VAR2\n" 3312 "# define B 1\n" 3313 "# include <someheader.h>\n" 3314 "# define MACRO \\\n" 3315 " some_very_long_func_aaaaaaaaaa();\n" 3316 "# endif\n" 3317 "#else\n" 3318 "# define A 1\n" 3319 "#endif", 3320 Style); 3321 verifyFormat("#if A\n" 3322 "# define MACRO \\\n" 3323 " void a(int x) { \\\n" 3324 " b(); \\\n" 3325 " c(); \\\n" 3326 " d(); \\\n" 3327 " e(); \\\n" 3328 " f(); \\\n" 3329 " }\n" 3330 "#endif", 3331 Style); 3332 // Comments before include guard. 3333 verifyFormat("// file comment\n" 3334 "// file comment\n" 3335 "#ifndef HEADER_H\n" 3336 "#define HEADER_H\n" 3337 "code();\n" 3338 "#endif", 3339 Style); 3340 // Test with include guards. 3341 verifyFormat("#ifndef HEADER_H\n" 3342 "#define HEADER_H\n" 3343 "code();\n" 3344 "#endif", 3345 Style); 3346 // Include guards must have a #define with the same variable immediately 3347 // after #ifndef. 3348 verifyFormat("#ifndef NOT_GUARD\n" 3349 "# define FOO\n" 3350 "code();\n" 3351 "#endif", 3352 Style); 3353 3354 // Include guards must cover the entire file. 3355 verifyFormat("code();\n" 3356 "code();\n" 3357 "#ifndef NOT_GUARD\n" 3358 "# define NOT_GUARD\n" 3359 "code();\n" 3360 "#endif", 3361 Style); 3362 verifyFormat("#ifndef NOT_GUARD\n" 3363 "# define NOT_GUARD\n" 3364 "code();\n" 3365 "#endif\n" 3366 "code();", 3367 Style); 3368 // Test with trailing blank lines. 3369 verifyFormat("#ifndef HEADER_H\n" 3370 "#define HEADER_H\n" 3371 "code();\n" 3372 "#endif\n", 3373 Style); 3374 // Include guards don't have #else. 3375 verifyFormat("#ifndef NOT_GUARD\n" 3376 "# define NOT_GUARD\n" 3377 "code();\n" 3378 "#else\n" 3379 "#endif", 3380 Style); 3381 verifyFormat("#ifndef NOT_GUARD\n" 3382 "# define NOT_GUARD\n" 3383 "code();\n" 3384 "#elif FOO\n" 3385 "#endif", 3386 Style); 3387 // Non-identifier #define after potential include guard. 3388 verifyFormat("#ifndef FOO\n" 3389 "# define 1\n" 3390 "#endif\n", 3391 Style); 3392 // #if closes past last non-preprocessor line. 3393 verifyFormat("#ifndef FOO\n" 3394 "#define FOO\n" 3395 "#if 1\n" 3396 "int i;\n" 3397 "# define A 0\n" 3398 "#endif\n" 3399 "#endif\n", 3400 Style); 3401 // Don't crash if there is an #elif directive without a condition. 3402 verifyFormat("#if 1\n" 3403 "int x;\n" 3404 "#elif\n" 3405 "int y;\n" 3406 "#else\n" 3407 "int z;\n" 3408 "#endif", 3409 Style); 3410 // FIXME: This doesn't handle the case where there's code between the 3411 // #ifndef and #define but all other conditions hold. This is because when 3412 // the #define line is parsed, UnwrappedLineParser::Lines doesn't hold the 3413 // previous code line yet, so we can't detect it. 3414 EXPECT_EQ("#ifndef NOT_GUARD\n" 3415 "code();\n" 3416 "#define NOT_GUARD\n" 3417 "code();\n" 3418 "#endif", 3419 format("#ifndef NOT_GUARD\n" 3420 "code();\n" 3421 "# define NOT_GUARD\n" 3422 "code();\n" 3423 "#endif", 3424 Style)); 3425 // FIXME: This doesn't handle cases where legitimate preprocessor lines may 3426 // be outside an include guard. Examples are #pragma once and 3427 // #pragma GCC diagnostic, or anything else that does not change the meaning 3428 // of the file if it's included multiple times. 3429 EXPECT_EQ("#ifdef WIN32\n" 3430 "# pragma once\n" 3431 "#endif\n" 3432 "#ifndef HEADER_H\n" 3433 "# define HEADER_H\n" 3434 "code();\n" 3435 "#endif", 3436 format("#ifdef WIN32\n" 3437 "# pragma once\n" 3438 "#endif\n" 3439 "#ifndef HEADER_H\n" 3440 "#define HEADER_H\n" 3441 "code();\n" 3442 "#endif", 3443 Style)); 3444 // FIXME: This does not detect when there is a single non-preprocessor line 3445 // in front of an include-guard-like structure where other conditions hold 3446 // because ScopedLineState hides the line. 3447 EXPECT_EQ("code();\n" 3448 "#ifndef HEADER_H\n" 3449 "#define HEADER_H\n" 3450 "code();\n" 3451 "#endif", 3452 format("code();\n" 3453 "#ifndef HEADER_H\n" 3454 "# define HEADER_H\n" 3455 "code();\n" 3456 "#endif", 3457 Style)); 3458 // Keep comments aligned with #, otherwise indent comments normally. These 3459 // tests cannot use verifyFormat because messUp manipulates leading 3460 // whitespace. 3461 { 3462 const char *Expected = "" 3463 "void f() {\n" 3464 "#if 1\n" 3465 "// Preprocessor aligned.\n" 3466 "# define A 0\n" 3467 " // Code. Separated by blank line.\n" 3468 "\n" 3469 "# define B 0\n" 3470 " // Code. Not aligned with #\n" 3471 "# define C 0\n" 3472 "#endif"; 3473 const char *ToFormat = "" 3474 "void f() {\n" 3475 "#if 1\n" 3476 "// Preprocessor aligned.\n" 3477 "# define A 0\n" 3478 "// Code. Separated by blank line.\n" 3479 "\n" 3480 "# define B 0\n" 3481 " // Code. Not aligned with #\n" 3482 "# define C 0\n" 3483 "#endif"; 3484 EXPECT_EQ(Expected, format(ToFormat, Style)); 3485 EXPECT_EQ(Expected, format(Expected, Style)); 3486 } 3487 // Keep block quotes aligned. 3488 { 3489 const char *Expected = "" 3490 "void f() {\n" 3491 "#if 1\n" 3492 "/* Preprocessor aligned. */\n" 3493 "# define A 0\n" 3494 " /* Code. Separated by blank line. */\n" 3495 "\n" 3496 "# define B 0\n" 3497 " /* Code. Not aligned with # */\n" 3498 "# define C 0\n" 3499 "#endif"; 3500 const char *ToFormat = "" 3501 "void f() {\n" 3502 "#if 1\n" 3503 "/* Preprocessor aligned. */\n" 3504 "# define A 0\n" 3505 "/* Code. Separated by blank line. */\n" 3506 "\n" 3507 "# define B 0\n" 3508 " /* Code. Not aligned with # */\n" 3509 "# define C 0\n" 3510 "#endif"; 3511 EXPECT_EQ(Expected, format(ToFormat, Style)); 3512 EXPECT_EQ(Expected, format(Expected, Style)); 3513 } 3514 // Keep comments aligned with un-indented directives. 3515 { 3516 const char *Expected = "" 3517 "void f() {\n" 3518 "// Preprocessor aligned.\n" 3519 "#define A 0\n" 3520 " // Code. Separated by blank line.\n" 3521 "\n" 3522 "#define B 0\n" 3523 " // Code. Not aligned with #\n" 3524 "#define C 0\n"; 3525 const char *ToFormat = "" 3526 "void f() {\n" 3527 "// Preprocessor aligned.\n" 3528 "#define A 0\n" 3529 "// Code. Separated by blank line.\n" 3530 "\n" 3531 "#define B 0\n" 3532 " // Code. Not aligned with #\n" 3533 "#define C 0\n"; 3534 EXPECT_EQ(Expected, format(ToFormat, Style)); 3535 EXPECT_EQ(Expected, format(Expected, Style)); 3536 } 3537 // Test AfterHash with tabs. 3538 { 3539 FormatStyle Tabbed = Style; 3540 Tabbed.UseTab = FormatStyle::UT_Always; 3541 Tabbed.IndentWidth = 8; 3542 Tabbed.TabWidth = 8; 3543 verifyFormat("#ifdef _WIN32\n" 3544 "#\tdefine A 0\n" 3545 "#\tifdef VAR2\n" 3546 "#\t\tdefine B 1\n" 3547 "#\t\tinclude <someheader.h>\n" 3548 "#\t\tdefine MACRO \\\n" 3549 "\t\t\tsome_very_long_func_aaaaaaaaaa();\n" 3550 "#\tendif\n" 3551 "#else\n" 3552 "#\tdefine A 1\n" 3553 "#endif", 3554 Tabbed); 3555 } 3556 3557 // Regression test: Multiline-macro inside include guards. 3558 verifyFormat("#ifndef HEADER_H\n" 3559 "#define HEADER_H\n" 3560 "#define A() \\\n" 3561 " int i; \\\n" 3562 " int j;\n" 3563 "#endif // HEADER_H", 3564 getLLVMStyleWithColumns(20)); 3565 3566 Style.IndentPPDirectives = FormatStyle::PPDIS_BeforeHash; 3567 // Basic before hash indent tests 3568 verifyFormat("#ifdef _WIN32\n" 3569 " #define A 0\n" 3570 " #ifdef VAR2\n" 3571 " #define B 1\n" 3572 " #include <someheader.h>\n" 3573 " #define MACRO \\\n" 3574 " some_very_long_func_aaaaaaaaaa();\n" 3575 " #endif\n" 3576 "#else\n" 3577 " #define A 1\n" 3578 "#endif", 3579 Style); 3580 verifyFormat("#if A\n" 3581 " #define MACRO \\\n" 3582 " void a(int x) { \\\n" 3583 " b(); \\\n" 3584 " c(); \\\n" 3585 " d(); \\\n" 3586 " e(); \\\n" 3587 " f(); \\\n" 3588 " }\n" 3589 "#endif", 3590 Style); 3591 // Keep comments aligned with indented directives. These 3592 // tests cannot use verifyFormat because messUp manipulates leading 3593 // whitespace. 3594 { 3595 const char *Expected = "void f() {\n" 3596 "// Aligned to preprocessor.\n" 3597 "#if 1\n" 3598 " // Aligned to code.\n" 3599 " int a;\n" 3600 " #if 1\n" 3601 " // Aligned to preprocessor.\n" 3602 " #define A 0\n" 3603 " // Aligned to code.\n" 3604 " int b;\n" 3605 " #endif\n" 3606 "#endif\n" 3607 "}"; 3608 const char *ToFormat = "void f() {\n" 3609 "// Aligned to preprocessor.\n" 3610 "#if 1\n" 3611 "// Aligned to code.\n" 3612 "int a;\n" 3613 "#if 1\n" 3614 "// Aligned to preprocessor.\n" 3615 "#define A 0\n" 3616 "// Aligned to code.\n" 3617 "int b;\n" 3618 "#endif\n" 3619 "#endif\n" 3620 "}"; 3621 EXPECT_EQ(Expected, format(ToFormat, Style)); 3622 EXPECT_EQ(Expected, format(Expected, Style)); 3623 } 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 // Test single comment before preprocessor 3656 verifyFormat("// Comment\n" 3657 "\n" 3658 "#if 1\n" 3659 "#endif", 3660 Style); 3661 } 3662 3663 TEST_F(FormatTest, FormatHashIfNotAtStartOfLine) { 3664 verifyFormat("{\n { a #c; }\n}"); 3665 } 3666 3667 TEST_F(FormatTest, FormatUnbalancedStructuralElements) { 3668 EXPECT_EQ("#define A \\\n { \\\n {\nint i;", 3669 format("#define A { {\nint i;", getLLVMStyleWithColumns(11))); 3670 EXPECT_EQ("#define A \\\n } \\\n }\nint i;", 3671 format("#define A } }\nint i;", getLLVMStyleWithColumns(11))); 3672 } 3673 3674 TEST_F(FormatTest, EscapedNewlines) { 3675 FormatStyle Narrow = getLLVMStyleWithColumns(11); 3676 EXPECT_EQ("#define A \\\n int i; \\\n int j;", 3677 format("#define A \\\nint i;\\\n int j;", Narrow)); 3678 EXPECT_EQ("#define A\n\nint i;", format("#define A \\\n\n int i;")); 3679 EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();")); 3680 EXPECT_EQ("/* \\ \\ \\\n */", format("\\\n/* \\ \\ \\\n */")); 3681 EXPECT_EQ("<a\n\\\\\n>", format("<a\n\\\\\n>")); 3682 3683 FormatStyle AlignLeft = getLLVMStyle(); 3684 AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left; 3685 EXPECT_EQ("#define MACRO(x) \\\n" 3686 "private: \\\n" 3687 " int x(int a);\n", 3688 format("#define MACRO(x) \\\n" 3689 "private: \\\n" 3690 " int x(int a);\n", 3691 AlignLeft)); 3692 3693 // CRLF line endings 3694 EXPECT_EQ("#define A \\\r\n int i; \\\r\n int j;", 3695 format("#define A \\\r\nint i;\\\r\n int j;", Narrow)); 3696 EXPECT_EQ("#define A\r\n\r\nint i;", format("#define A \\\r\n\r\n int i;")); 3697 EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();")); 3698 EXPECT_EQ("/* \\ \\ \\\r\n */", format("\\\r\n/* \\ \\ \\\r\n */")); 3699 EXPECT_EQ("<a\r\n\\\\\r\n>", format("<a\r\n\\\\\r\n>")); 3700 EXPECT_EQ("#define MACRO(x) \\\r\n" 3701 "private: \\\r\n" 3702 " int x(int a);\r\n", 3703 format("#define MACRO(x) \\\r\n" 3704 "private: \\\r\n" 3705 " int x(int a);\r\n", 3706 AlignLeft)); 3707 3708 FormatStyle DontAlign = getLLVMStyle(); 3709 DontAlign.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign; 3710 DontAlign.MaxEmptyLinesToKeep = 3; 3711 // FIXME: can't use verifyFormat here because the newline before 3712 // "public:" is not inserted the first time it's reformatted 3713 EXPECT_EQ("#define A \\\n" 3714 " class Foo { \\\n" 3715 " void bar(); \\\n" 3716 "\\\n" 3717 "\\\n" 3718 "\\\n" 3719 " public: \\\n" 3720 " void baz(); \\\n" 3721 " };", 3722 format("#define A \\\n" 3723 " class Foo { \\\n" 3724 " void bar(); \\\n" 3725 "\\\n" 3726 "\\\n" 3727 "\\\n" 3728 " public: \\\n" 3729 " void baz(); \\\n" 3730 " };", 3731 DontAlign)); 3732 } 3733 3734 TEST_F(FormatTest, CalculateSpaceOnConsecutiveLinesInMacro) { 3735 verifyFormat("#define A \\\n" 3736 " int v( \\\n" 3737 " a); \\\n" 3738 " int i;", 3739 getLLVMStyleWithColumns(11)); 3740 } 3741 3742 TEST_F(FormatTest, MixingPreprocessorDirectivesAndNormalCode) { 3743 EXPECT_EQ( 3744 "#define ALooooooooooooooooooooooooooooooooooooooongMacro(" 3745 " \\\n" 3746 " aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n" 3747 "\n" 3748 "AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n" 3749 " aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n", 3750 format(" #define ALooooooooooooooooooooooooooooooooooooooongMacro(" 3751 "\\\n" 3752 "aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n" 3753 " \n" 3754 " AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n" 3755 " aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n")); 3756 } 3757 3758 TEST_F(FormatTest, LayoutStatementsAroundPreprocessorDirectives) { 3759 EXPECT_EQ("int\n" 3760 "#define A\n" 3761 " a;", 3762 format("int\n#define A\na;")); 3763 verifyFormat("functionCallTo(\n" 3764 " someOtherFunction(\n" 3765 " withSomeParameters, whichInSequence,\n" 3766 " areLongerThanALine(andAnotherCall,\n" 3767 "#define A B\n" 3768 " withMoreParamters,\n" 3769 " whichStronglyInfluenceTheLayout),\n" 3770 " andMoreParameters),\n" 3771 " trailing);", 3772 getLLVMStyleWithColumns(69)); 3773 verifyFormat("Foo::Foo()\n" 3774 "#ifdef BAR\n" 3775 " : baz(0)\n" 3776 "#endif\n" 3777 "{\n" 3778 "}"); 3779 verifyFormat("void f() {\n" 3780 " if (true)\n" 3781 "#ifdef A\n" 3782 " f(42);\n" 3783 " x();\n" 3784 "#else\n" 3785 " g();\n" 3786 " x();\n" 3787 "#endif\n" 3788 "}"); 3789 verifyFormat("void f(param1, param2,\n" 3790 " param3,\n" 3791 "#ifdef A\n" 3792 " param4(param5,\n" 3793 "#ifdef A1\n" 3794 " param6,\n" 3795 "#ifdef A2\n" 3796 " param7),\n" 3797 "#else\n" 3798 " param8),\n" 3799 " param9,\n" 3800 "#endif\n" 3801 " param10,\n" 3802 "#endif\n" 3803 " param11)\n" 3804 "#else\n" 3805 " param12)\n" 3806 "#endif\n" 3807 "{\n" 3808 " x();\n" 3809 "}", 3810 getLLVMStyleWithColumns(28)); 3811 verifyFormat("#if 1\n" 3812 "int i;"); 3813 verifyFormat("#if 1\n" 3814 "#endif\n" 3815 "#if 1\n" 3816 "#else\n" 3817 "#endif\n"); 3818 verifyFormat("DEBUG({\n" 3819 " return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3820 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n" 3821 "});\n" 3822 "#if a\n" 3823 "#else\n" 3824 "#endif"); 3825 3826 verifyIncompleteFormat("void f(\n" 3827 "#if A\n" 3828 ");\n" 3829 "#else\n" 3830 "#endif"); 3831 } 3832 3833 TEST_F(FormatTest, GraciouslyHandleIncorrectPreprocessorConditions) { 3834 verifyFormat("#endif\n" 3835 "#if B"); 3836 } 3837 3838 TEST_F(FormatTest, FormatsJoinedLinesOnSubsequentRuns) { 3839 FormatStyle SingleLine = getLLVMStyle(); 3840 SingleLine.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_WithoutElse; 3841 verifyFormat("#if 0\n" 3842 "#elif 1\n" 3843 "#endif\n" 3844 "void foo() {\n" 3845 " if (test) foo2();\n" 3846 "}", 3847 SingleLine); 3848 } 3849 3850 TEST_F(FormatTest, LayoutBlockInsideParens) { 3851 verifyFormat("functionCall({ int i; });"); 3852 verifyFormat("functionCall({\n" 3853 " int i;\n" 3854 " int j;\n" 3855 "});"); 3856 verifyFormat("functionCall(\n" 3857 " {\n" 3858 " int i;\n" 3859 " int j;\n" 3860 " },\n" 3861 " aaaa, bbbb, cccc);"); 3862 verifyFormat("functionA(functionB({\n" 3863 " int i;\n" 3864 " int j;\n" 3865 " }),\n" 3866 " aaaa, bbbb, cccc);"); 3867 verifyFormat("functionCall(\n" 3868 " {\n" 3869 " int i;\n" 3870 " int j;\n" 3871 " },\n" 3872 " aaaa, bbbb, // comment\n" 3873 " cccc);"); 3874 verifyFormat("functionA(functionB({\n" 3875 " int i;\n" 3876 " int j;\n" 3877 " }),\n" 3878 " aaaa, bbbb, // comment\n" 3879 " cccc);"); 3880 verifyFormat("functionCall(aaaa, bbbb, { int i; });"); 3881 verifyFormat("functionCall(aaaa, bbbb, {\n" 3882 " int i;\n" 3883 " int j;\n" 3884 "});"); 3885 verifyFormat( 3886 "Aaa(\n" // FIXME: There shouldn't be a linebreak here. 3887 " {\n" 3888 " int i; // break\n" 3889 " },\n" 3890 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" 3891 " ccccccccccccccccc));"); 3892 verifyFormat("DEBUG({\n" 3893 " if (a)\n" 3894 " f();\n" 3895 "});"); 3896 } 3897 3898 TEST_F(FormatTest, LayoutBlockInsideStatement) { 3899 EXPECT_EQ("SOME_MACRO { int i; }\n" 3900 "int i;", 3901 format(" SOME_MACRO {int i;} int i;")); 3902 } 3903 3904 TEST_F(FormatTest, LayoutNestedBlocks) { 3905 verifyFormat("void AddOsStrings(unsigned bitmask) {\n" 3906 " struct s {\n" 3907 " int i;\n" 3908 " };\n" 3909 " s kBitsToOs[] = {{10}};\n" 3910 " for (int i = 0; i < 10; ++i)\n" 3911 " return;\n" 3912 "}"); 3913 verifyFormat("call(parameter, {\n" 3914 " something();\n" 3915 " // Comment using all columns.\n" 3916 " somethingelse();\n" 3917 "});", 3918 getLLVMStyleWithColumns(40)); 3919 verifyFormat("DEBUG( //\n" 3920 " { f(); }, a);"); 3921 verifyFormat("DEBUG( //\n" 3922 " {\n" 3923 " f(); //\n" 3924 " },\n" 3925 " a);"); 3926 3927 EXPECT_EQ("call(parameter, {\n" 3928 " something();\n" 3929 " // Comment too\n" 3930 " // looooooooooong.\n" 3931 " somethingElse();\n" 3932 "});", 3933 format("call(parameter, {\n" 3934 " something();\n" 3935 " // Comment too looooooooooong.\n" 3936 " somethingElse();\n" 3937 "});", 3938 getLLVMStyleWithColumns(29))); 3939 EXPECT_EQ("DEBUG({ int i; });", format("DEBUG({ int i; });")); 3940 EXPECT_EQ("DEBUG({ // comment\n" 3941 " int i;\n" 3942 "});", 3943 format("DEBUG({ // comment\n" 3944 "int i;\n" 3945 "});")); 3946 EXPECT_EQ("DEBUG({\n" 3947 " int i;\n" 3948 "\n" 3949 " // comment\n" 3950 " int j;\n" 3951 "});", 3952 format("DEBUG({\n" 3953 " int i;\n" 3954 "\n" 3955 " // comment\n" 3956 " int j;\n" 3957 "});")); 3958 3959 verifyFormat("DEBUG({\n" 3960 " if (a)\n" 3961 " return;\n" 3962 "});"); 3963 verifyGoogleFormat("DEBUG({\n" 3964 " if (a) return;\n" 3965 "});"); 3966 FormatStyle Style = getGoogleStyle(); 3967 Style.ColumnLimit = 45; 3968 verifyFormat("Debug(\n" 3969 " aaaaa,\n" 3970 " {\n" 3971 " if (aaaaaaaaaaaaaaaaaaaaaaaa) return;\n" 3972 " },\n" 3973 " a);", 3974 Style); 3975 3976 verifyFormat("SomeFunction({MACRO({ return output; }), b});"); 3977 3978 verifyNoCrash("^{v^{a}}"); 3979 } 3980 3981 TEST_F(FormatTest, FormatNestedBlocksInMacros) { 3982 EXPECT_EQ("#define MACRO() \\\n" 3983 " Debug(aaa, /* force line break */ \\\n" 3984 " { \\\n" 3985 " int i; \\\n" 3986 " int j; \\\n" 3987 " })", 3988 format("#define MACRO() Debug(aaa, /* force line break */ \\\n" 3989 " { int i; int j; })", 3990 getGoogleStyle())); 3991 3992 EXPECT_EQ("#define A \\\n" 3993 " [] { \\\n" 3994 " xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n" 3995 " xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); \\\n" 3996 " }", 3997 format("#define A [] { xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n" 3998 "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); }", 3999 getGoogleStyle())); 4000 } 4001 4002 TEST_F(FormatTest, PutEmptyBlocksIntoOneLine) { 4003 EXPECT_EQ("{}", format("{}")); 4004 verifyFormat("enum E {};"); 4005 verifyFormat("enum E {}"); 4006 FormatStyle Style = getLLVMStyle(); 4007 Style.SpaceInEmptyBlock = true; 4008 EXPECT_EQ("void f() { }", format("void f() {}", Style)); 4009 Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty; 4010 EXPECT_EQ("while (true) { }", format("while (true) {}", Style)); 4011 } 4012 4013 TEST_F(FormatTest, FormatBeginBlockEndMacros) { 4014 FormatStyle Style = getLLVMStyle(); 4015 Style.MacroBlockBegin = "^[A-Z_]+_BEGIN$"; 4016 Style.MacroBlockEnd = "^[A-Z_]+_END$"; 4017 verifyFormat("FOO_BEGIN\n" 4018 " FOO_ENTRY\n" 4019 "FOO_END", 4020 Style); 4021 verifyFormat("FOO_BEGIN\n" 4022 " NESTED_FOO_BEGIN\n" 4023 " NESTED_FOO_ENTRY\n" 4024 " NESTED_FOO_END\n" 4025 "FOO_END", 4026 Style); 4027 verifyFormat("FOO_BEGIN(Foo, Bar)\n" 4028 " int x;\n" 4029 " x = 1;\n" 4030 "FOO_END(Baz)", 4031 Style); 4032 } 4033 4034 //===----------------------------------------------------------------------===// 4035 // Line break tests. 4036 //===----------------------------------------------------------------------===// 4037 4038 TEST_F(FormatTest, PreventConfusingIndents) { 4039 verifyFormat( 4040 "void f() {\n" 4041 " SomeLongMethodName(SomeReallyLongMethod(CallOtherReallyLongMethod(\n" 4042 " parameter, parameter, parameter)),\n" 4043 " SecondLongCall(parameter));\n" 4044 "}"); 4045 verifyFormat( 4046 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4047 " aaaaaaaaaaaaaaaaaaaaaaaa(\n" 4048 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4049 " aaaaaaaaaaaaaaaaaaaaaaaa);"); 4050 verifyFormat( 4051 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4052 " [aaaaaaaaaaaaaaaaaaaaaaaa\n" 4053 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n" 4054 " [aaaaaaaaaaaaaaaaaaaaaaaa]];"); 4055 verifyFormat( 4056 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n" 4057 " aaaaaaaaaaaaaaaaaaaaaaaa<\n" 4058 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>,\n" 4059 " aaaaaaaaaaaaaaaaaaaaaaaa>;"); 4060 verifyFormat("int a = bbbb && ccc &&\n" 4061 " fffff(\n" 4062 "#define A Just forcing a new line\n" 4063 " ddd);"); 4064 } 4065 4066 TEST_F(FormatTest, LineBreakingInBinaryExpressions) { 4067 verifyFormat( 4068 "bool aaaaaaa =\n" 4069 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() ||\n" 4070 " bbbbbbbb();"); 4071 verifyFormat( 4072 "bool aaaaaaa =\n" 4073 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() or\n" 4074 " bbbbbbbb();"); 4075 4076 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n" 4077 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb &&\n" 4078 " ccccccccc == ddddddddddd;"); 4079 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n" 4080 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb and\n" 4081 " ccccccccc == ddddddddddd;"); 4082 verifyFormat( 4083 "bool aaaaaaaaaaaaaaaaaaaaa =\n" 4084 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa not_eq bbbbbbbbbbbbbbbbbb and\n" 4085 " ccccccccc == ddddddddddd;"); 4086 4087 verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n" 4088 " aaaaaa) &&\n" 4089 " bbbbbb && cccccc;"); 4090 verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n" 4091 " aaaaaa) >>\n" 4092 " bbbbbb;"); 4093 verifyFormat("aa = Whitespaces.addUntouchableComment(\n" 4094 " SourceMgr.getSpellingColumnNumber(\n" 4095 " TheLine.Last->FormatTok.Tok.getLocation()) -\n" 4096 " 1);"); 4097 4098 verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 4099 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaaaaaaa\n" 4100 " cccccc) {\n}"); 4101 verifyFormat("if constexpr ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 4102 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaa\n" 4103 " cccccc) {\n}"); 4104 verifyFormat("if CONSTEXPR ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 4105 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaa\n" 4106 " cccccc) {\n}"); 4107 verifyFormat("b = a &&\n" 4108 " // Comment\n" 4109 " b.c && d;"); 4110 4111 // If the LHS of a comparison is not a binary expression itself, the 4112 // additional linebreak confuses many people. 4113 verifyFormat( 4114 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4115 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) > 5) {\n" 4116 "}"); 4117 verifyFormat( 4118 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4119 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n" 4120 "}"); 4121 verifyFormat( 4122 "if (aaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaa(\n" 4123 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n" 4124 "}"); 4125 verifyFormat( 4126 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4127 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) <=> 5) {\n" 4128 "}"); 4129 // Even explicit parentheses stress the precedence enough to make the 4130 // additional break unnecessary. 4131 verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4132 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n" 4133 "}"); 4134 // This cases is borderline, but with the indentation it is still readable. 4135 verifyFormat( 4136 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4137 " aaaaaaaaaaaaaaa) > aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4138 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 4139 "}", 4140 getLLVMStyleWithColumns(75)); 4141 4142 // If the LHS is a binary expression, we should still use the additional break 4143 // as otherwise the formatting hides the operator precedence. 4144 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4145 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 4146 " 5) {\n" 4147 "}"); 4148 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4149 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa <=>\n" 4150 " 5) {\n" 4151 "}"); 4152 4153 FormatStyle OnePerLine = getLLVMStyle(); 4154 OnePerLine.BinPackParameters = false; 4155 verifyFormat( 4156 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 4157 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 4158 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}", 4159 OnePerLine); 4160 4161 verifyFormat("int i = someFunction(aaaaaaa, 0)\n" 4162 " .aaa(aaaaaaaaaaaaa) *\n" 4163 " aaaaaaa +\n" 4164 " aaaaaaa;", 4165 getLLVMStyleWithColumns(40)); 4166 } 4167 4168 TEST_F(FormatTest, ExpressionIndentation) { 4169 verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4170 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4171 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 4172 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 4173 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb +\n" 4174 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb &&\n" 4175 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 4176 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >\n" 4177 " ccccccccccccccccccccccccccccccccccccccccc;"); 4178 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 4179 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4180 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 4181 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); 4182 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4183 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 4184 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 4185 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); 4186 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 4187 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 4188 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4189 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); 4190 verifyFormat("if () {\n" 4191 "} else if (aaaaa && bbbbb > // break\n" 4192 " ccccc) {\n" 4193 "}"); 4194 verifyFormat("if () {\n" 4195 "} else if constexpr (aaaaa && bbbbb > // break\n" 4196 " ccccc) {\n" 4197 "}"); 4198 verifyFormat("if () {\n" 4199 "} else if CONSTEXPR (aaaaa && bbbbb > // break\n" 4200 " ccccc) {\n" 4201 "}"); 4202 verifyFormat("if () {\n" 4203 "} else if (aaaaa &&\n" 4204 " bbbbb > // break\n" 4205 " ccccc &&\n" 4206 " ddddd) {\n" 4207 "}"); 4208 4209 // Presence of a trailing comment used to change indentation of b. 4210 verifyFormat("return aaaaaaaaaaaaaaaaaaa +\n" 4211 " b;\n" 4212 "return aaaaaaaaaaaaaaaaaaa +\n" 4213 " b; //", 4214 getLLVMStyleWithColumns(30)); 4215 } 4216 4217 TEST_F(FormatTest, ExpressionIndentationBreakingBeforeOperators) { 4218 // Not sure what the best system is here. Like this, the LHS can be found 4219 // immediately above an operator (everything with the same or a higher 4220 // indent). The RHS is aligned right of the operator and so compasses 4221 // everything until something with the same indent as the operator is found. 4222 // FIXME: Is this a good system? 4223 FormatStyle Style = getLLVMStyle(); 4224 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 4225 verifyFormat( 4226 "bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4227 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4228 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4229 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4230 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4231 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4232 " && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4233 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4234 " > ccccccccccccccccccccccccccccccccccccccccc;", 4235 Style); 4236 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4237 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4238 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4239 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 4240 Style); 4241 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4242 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4243 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4244 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 4245 Style); 4246 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4247 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4248 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4249 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 4250 Style); 4251 verifyFormat("if () {\n" 4252 "} else if (aaaaa\n" 4253 " && bbbbb // break\n" 4254 " > ccccc) {\n" 4255 "}", 4256 Style); 4257 verifyFormat("return (a)\n" 4258 " // comment\n" 4259 " + b;", 4260 Style); 4261 verifyFormat( 4262 "int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4263 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4264 " + cc;", 4265 Style); 4266 4267 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4268 " = aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 4269 Style); 4270 4271 // Forced by comments. 4272 verifyFormat( 4273 "unsigned ContentSize =\n" 4274 " sizeof(int16_t) // DWARF ARange version number\n" 4275 " + sizeof(int32_t) // Offset of CU in the .debug_info section\n" 4276 " + sizeof(int8_t) // Pointer Size (in bytes)\n" 4277 " + sizeof(int8_t); // Segment Size (in bytes)"); 4278 4279 verifyFormat("return boost::fusion::at_c<0>(iiii).second\n" 4280 " == boost::fusion::at_c<1>(iiii).second;", 4281 Style); 4282 4283 Style.ColumnLimit = 60; 4284 verifyFormat("zzzzzzzzzz\n" 4285 " = bbbbbbbbbbbbbbbbb\n" 4286 " >> aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa);", 4287 Style); 4288 4289 Style.ColumnLimit = 80; 4290 Style.IndentWidth = 4; 4291 Style.TabWidth = 4; 4292 Style.UseTab = FormatStyle::UT_Always; 4293 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 4294 Style.AlignOperands = false; 4295 EXPECT_EQ("return someVeryVeryLongConditionThatBarelyFitsOnALine\n" 4296 "\t&& (someOtherLongishConditionPart1\n" 4297 "\t\t|| someOtherEvenLongerNestedConditionPart2);", 4298 format("return someVeryVeryLongConditionThatBarelyFitsOnALine && " 4299 "(someOtherLongishConditionPart1 || " 4300 "someOtherEvenLongerNestedConditionPart2);", 4301 Style)); 4302 } 4303 4304 TEST_F(FormatTest, EnforcedOperatorWraps) { 4305 // Here we'd like to wrap after the || operators, but a comment is forcing an 4306 // earlier wrap. 4307 verifyFormat("bool x = aaaaa //\n" 4308 " || bbbbb\n" 4309 " //\n" 4310 " || cccc;"); 4311 } 4312 4313 TEST_F(FormatTest, NoOperandAlignment) { 4314 FormatStyle Style = getLLVMStyle(); 4315 Style.AlignOperands = false; 4316 verifyFormat("aaaaaaaaaaaaaa(aaaaaaaaaaaa,\n" 4317 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4318 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 4319 Style); 4320 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment; 4321 verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4322 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4323 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4324 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4325 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4326 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4327 " && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4328 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4329 " > ccccccccccccccccccccccccccccccccccccccccc;", 4330 Style); 4331 4332 verifyFormat("int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4333 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4334 " + cc;", 4335 Style); 4336 verifyFormat("int a = aa\n" 4337 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4338 " * cccccccccccccccccccccccccccccccccccc;\n", 4339 Style); 4340 4341 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 4342 verifyFormat("return (a > b\n" 4343 " // comment1\n" 4344 " // comment2\n" 4345 " || c);", 4346 Style); 4347 } 4348 4349 TEST_F(FormatTest, BreakingBeforeNonAssigmentOperators) { 4350 FormatStyle Style = getLLVMStyle(); 4351 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment; 4352 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 4353 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4354 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;", 4355 Style); 4356 } 4357 4358 TEST_F(FormatTest, AllowBinPackingInsideArguments) { 4359 FormatStyle Style = getLLVMStyle(); 4360 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment; 4361 Style.BinPackArguments = false; 4362 Style.ColumnLimit = 40; 4363 verifyFormat("void test() {\n" 4364 " someFunction(\n" 4365 " this + argument + is + quite\n" 4366 " + long + so + it + gets + wrapped\n" 4367 " + but + remains + bin - packed);\n" 4368 "}", 4369 Style); 4370 verifyFormat("void test() {\n" 4371 " someFunction(arg1,\n" 4372 " this + argument + is\n" 4373 " + quite + long + so\n" 4374 " + it + gets + wrapped\n" 4375 " + but + remains + bin\n" 4376 " - packed,\n" 4377 " arg3);\n" 4378 "}", 4379 Style); 4380 verifyFormat("void test() {\n" 4381 " someFunction(\n" 4382 " arg1,\n" 4383 " this + argument + has\n" 4384 " + anotherFunc(nested,\n" 4385 " calls + whose\n" 4386 " + arguments\n" 4387 " + are + also\n" 4388 " + wrapped,\n" 4389 " in + addition)\n" 4390 " + to + being + bin - packed,\n" 4391 " arg3);\n" 4392 "}", 4393 Style); 4394 4395 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 4396 verifyFormat("void test() {\n" 4397 " someFunction(\n" 4398 " arg1,\n" 4399 " this + argument + has +\n" 4400 " anotherFunc(nested,\n" 4401 " calls + whose +\n" 4402 " arguments +\n" 4403 " are + also +\n" 4404 " wrapped,\n" 4405 " in + addition) +\n" 4406 " to + being + bin - packed,\n" 4407 " arg3);\n" 4408 "}", 4409 Style); 4410 } 4411 4412 TEST_F(FormatTest, ConstructorInitializers) { 4413 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}"); 4414 verifyFormat("Constructor() : Inttializer(FitsOnTheLine) {}", 4415 getLLVMStyleWithColumns(45)); 4416 verifyFormat("Constructor()\n" 4417 " : Inttializer(FitsOnTheLine) {}", 4418 getLLVMStyleWithColumns(44)); 4419 verifyFormat("Constructor()\n" 4420 " : Inttializer(FitsOnTheLine) {}", 4421 getLLVMStyleWithColumns(43)); 4422 4423 verifyFormat("template <typename T>\n" 4424 "Constructor() : Initializer(FitsOnTheLine) {}", 4425 getLLVMStyleWithColumns(45)); 4426 4427 verifyFormat( 4428 "SomeClass::Constructor()\n" 4429 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}"); 4430 4431 verifyFormat( 4432 "SomeClass::Constructor()\n" 4433 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4434 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}"); 4435 verifyFormat( 4436 "SomeClass::Constructor()\n" 4437 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4438 " aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}"); 4439 verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4440 " aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 4441 " : aaaaaaaaaa(aaaaaa) {}"); 4442 4443 verifyFormat("Constructor()\n" 4444 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4445 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4446 " aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4447 " aaaaaaaaaaaaaaaaaaaaaaa() {}"); 4448 4449 verifyFormat("Constructor()\n" 4450 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4451 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); 4452 4453 verifyFormat("Constructor(int Parameter = 0)\n" 4454 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n" 4455 " aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}"); 4456 verifyFormat("Constructor()\n" 4457 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n" 4458 "}", 4459 getLLVMStyleWithColumns(60)); 4460 verifyFormat("Constructor()\n" 4461 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4462 " aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}"); 4463 4464 // Here a line could be saved by splitting the second initializer onto two 4465 // lines, but that is not desirable. 4466 verifyFormat("Constructor()\n" 4467 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n" 4468 " aaaaaaaaaaa(aaaaaaaaaaa),\n" 4469 " aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); 4470 4471 FormatStyle OnePerLine = getLLVMStyle(); 4472 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4473 OnePerLine.AllowAllParametersOfDeclarationOnNextLine = false; 4474 verifyFormat("SomeClass::Constructor()\n" 4475 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4476 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4477 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4478 OnePerLine); 4479 verifyFormat("SomeClass::Constructor()\n" 4480 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n" 4481 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4482 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4483 OnePerLine); 4484 verifyFormat("MyClass::MyClass(int var)\n" 4485 " : some_var_(var), // 4 space indent\n" 4486 " some_other_var_(var + 1) { // lined up\n" 4487 "}", 4488 OnePerLine); 4489 verifyFormat("Constructor()\n" 4490 " : aaaaa(aaaaaa),\n" 4491 " aaaaa(aaaaaa),\n" 4492 " aaaaa(aaaaaa),\n" 4493 " aaaaa(aaaaaa),\n" 4494 " aaaaa(aaaaaa) {}", 4495 OnePerLine); 4496 verifyFormat("Constructor()\n" 4497 " : aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n" 4498 " aaaaaaaaaaaaaaaaaaaaaa) {}", 4499 OnePerLine); 4500 OnePerLine.BinPackParameters = false; 4501 verifyFormat( 4502 "Constructor()\n" 4503 " : aaaaaaaaaaaaaaaaaaaaaaaa(\n" 4504 " aaaaaaaaaaa().aaa(),\n" 4505 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4506 OnePerLine); 4507 OnePerLine.ColumnLimit = 60; 4508 verifyFormat("Constructor()\n" 4509 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4510 " bbbbbbbbbbbbbbbbbbbbbbbb(b) {}", 4511 OnePerLine); 4512 4513 EXPECT_EQ("Constructor()\n" 4514 " : // Comment forcing unwanted break.\n" 4515 " aaaa(aaaa) {}", 4516 format("Constructor() :\n" 4517 " // Comment forcing unwanted break.\n" 4518 " aaaa(aaaa) {}")); 4519 } 4520 4521 TEST_F(FormatTest, AllowAllConstructorInitializersOnNextLine) { 4522 FormatStyle Style = getLLVMStyle(); 4523 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 4524 Style.ColumnLimit = 60; 4525 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4526 Style.AllowAllConstructorInitializersOnNextLine = true; 4527 Style.BinPackParameters = false; 4528 4529 for (int i = 0; i < 4; ++i) { 4530 // Test all combinations of parameters that should not have an effect. 4531 Style.AllowAllParametersOfDeclarationOnNextLine = i & 1; 4532 Style.AllowAllArgumentsOnNextLine = i & 2; 4533 4534 Style.AllowAllConstructorInitializersOnNextLine = true; 4535 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 4536 verifyFormat("Constructor()\n" 4537 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4538 Style); 4539 verifyFormat("Constructor() : a(a), b(b) {}", Style); 4540 4541 Style.AllowAllConstructorInitializersOnNextLine = false; 4542 verifyFormat("Constructor()\n" 4543 " : aaaaaaaaaaaaaaaaaaaa(a)\n" 4544 " , bbbbbbbbbbbbbbbbbbbbb(b) {}", 4545 Style); 4546 verifyFormat("Constructor() : a(a), b(b) {}", Style); 4547 4548 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon; 4549 Style.AllowAllConstructorInitializersOnNextLine = true; 4550 verifyFormat("Constructor()\n" 4551 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4552 Style); 4553 4554 Style.AllowAllConstructorInitializersOnNextLine = false; 4555 verifyFormat("Constructor()\n" 4556 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4557 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4558 Style); 4559 4560 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 4561 Style.AllowAllConstructorInitializersOnNextLine = true; 4562 verifyFormat("Constructor() :\n" 4563 " aaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4564 Style); 4565 4566 Style.AllowAllConstructorInitializersOnNextLine = false; 4567 verifyFormat("Constructor() :\n" 4568 " aaaaaaaaaaaaaaaaaa(a),\n" 4569 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4570 Style); 4571 } 4572 4573 // Test interactions between AllowAllParametersOfDeclarationOnNextLine and 4574 // AllowAllConstructorInitializersOnNextLine in all 4575 // BreakConstructorInitializers modes 4576 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 4577 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4578 Style.AllowAllConstructorInitializersOnNextLine = false; 4579 verifyFormat("SomeClassWithALongName::Constructor(\n" 4580 " int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb)\n" 4581 " : aaaaaaaaaaaaaaaaaaaa(a)\n" 4582 " , bbbbbbbbbbbbbbbbbbbbb(b) {}", 4583 Style); 4584 4585 Style.AllowAllConstructorInitializersOnNextLine = true; 4586 verifyFormat("SomeClassWithALongName::Constructor(\n" 4587 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4588 " int bbbbbbbbbbbbb,\n" 4589 " int cccccccccccccccc)\n" 4590 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4591 Style); 4592 4593 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4594 Style.AllowAllConstructorInitializersOnNextLine = false; 4595 verifyFormat("SomeClassWithALongName::Constructor(\n" 4596 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4597 " int bbbbbbbbbbbbb)\n" 4598 " : aaaaaaaaaaaaaaaaaaaa(a)\n" 4599 " , bbbbbbbbbbbbbbbbbbbbb(b) {}", 4600 Style); 4601 4602 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon; 4603 4604 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4605 verifyFormat("SomeClassWithALongName::Constructor(\n" 4606 " int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb)\n" 4607 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4608 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4609 Style); 4610 4611 Style.AllowAllConstructorInitializersOnNextLine = true; 4612 verifyFormat("SomeClassWithALongName::Constructor(\n" 4613 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4614 " int bbbbbbbbbbbbb,\n" 4615 " int cccccccccccccccc)\n" 4616 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4617 Style); 4618 4619 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4620 Style.AllowAllConstructorInitializersOnNextLine = false; 4621 verifyFormat("SomeClassWithALongName::Constructor(\n" 4622 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4623 " int bbbbbbbbbbbbb)\n" 4624 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4625 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4626 Style); 4627 4628 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 4629 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4630 verifyFormat("SomeClassWithALongName::Constructor(\n" 4631 " int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb) :\n" 4632 " aaaaaaaaaaaaaaaaaaaa(a),\n" 4633 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4634 Style); 4635 4636 Style.AllowAllConstructorInitializersOnNextLine = true; 4637 verifyFormat("SomeClassWithALongName::Constructor(\n" 4638 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4639 " int bbbbbbbbbbbbb,\n" 4640 " int cccccccccccccccc) :\n" 4641 " aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4642 Style); 4643 4644 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4645 Style.AllowAllConstructorInitializersOnNextLine = false; 4646 verifyFormat("SomeClassWithALongName::Constructor(\n" 4647 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4648 " int bbbbbbbbbbbbb) :\n" 4649 " aaaaaaaaaaaaaaaaaaaa(a),\n" 4650 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4651 Style); 4652 } 4653 4654 TEST_F(FormatTest, AllowAllArgumentsOnNextLine) { 4655 FormatStyle Style = getLLVMStyle(); 4656 Style.ColumnLimit = 60; 4657 Style.BinPackArguments = false; 4658 for (int i = 0; i < 4; ++i) { 4659 // Test all combinations of parameters that should not have an effect. 4660 Style.AllowAllParametersOfDeclarationOnNextLine = i & 1; 4661 Style.AllowAllConstructorInitializersOnNextLine = i & 2; 4662 4663 Style.AllowAllArgumentsOnNextLine = true; 4664 verifyFormat("void foo() {\n" 4665 " FunctionCallWithReallyLongName(\n" 4666 " aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbb);\n" 4667 "}", 4668 Style); 4669 Style.AllowAllArgumentsOnNextLine = false; 4670 verifyFormat("void foo() {\n" 4671 " FunctionCallWithReallyLongName(\n" 4672 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4673 " bbbbbbbbbbbb);\n" 4674 "}", 4675 Style); 4676 4677 Style.AllowAllArgumentsOnNextLine = true; 4678 verifyFormat("void foo() {\n" 4679 " auto VariableWithReallyLongName = {\n" 4680 " aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbb};\n" 4681 "}", 4682 Style); 4683 Style.AllowAllArgumentsOnNextLine = false; 4684 verifyFormat("void foo() {\n" 4685 " auto VariableWithReallyLongName = {\n" 4686 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4687 " bbbbbbbbbbbb};\n" 4688 "}", 4689 Style); 4690 } 4691 4692 // This parameter should not affect declarations. 4693 Style.BinPackParameters = false; 4694 Style.AllowAllArgumentsOnNextLine = false; 4695 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4696 verifyFormat("void FunctionCallWithReallyLongName(\n" 4697 " int aaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbb);", 4698 Style); 4699 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4700 verifyFormat("void FunctionCallWithReallyLongName(\n" 4701 " int aaaaaaaaaaaaaaaaaaaaaaa,\n" 4702 " int bbbbbbbbbbbb);", 4703 Style); 4704 } 4705 4706 TEST_F(FormatTest, BreakConstructorInitializersAfterColon) { 4707 FormatStyle Style = getLLVMStyle(); 4708 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 4709 4710 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}"); 4711 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}", 4712 getStyleWithColumns(Style, 45)); 4713 verifyFormat("Constructor() :\n" 4714 " Initializer(FitsOnTheLine) {}", 4715 getStyleWithColumns(Style, 44)); 4716 verifyFormat("Constructor() :\n" 4717 " Initializer(FitsOnTheLine) {}", 4718 getStyleWithColumns(Style, 43)); 4719 4720 verifyFormat("template <typename T>\n" 4721 "Constructor() : Initializer(FitsOnTheLine) {}", 4722 getStyleWithColumns(Style, 50)); 4723 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4724 verifyFormat( 4725 "SomeClass::Constructor() :\n" 4726 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}", 4727 Style); 4728 4729 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = false; 4730 verifyFormat( 4731 "SomeClass::Constructor() :\n" 4732 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}", 4733 Style); 4734 4735 verifyFormat( 4736 "SomeClass::Constructor() :\n" 4737 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4738 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4739 Style); 4740 verifyFormat( 4741 "SomeClass::Constructor() :\n" 4742 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4743 " aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}", 4744 Style); 4745 verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4746 " aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n" 4747 " aaaaaaaaaa(aaaaaa) {}", 4748 Style); 4749 4750 verifyFormat("Constructor() :\n" 4751 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4752 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4753 " aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4754 " aaaaaaaaaaaaaaaaaaaaaaa() {}", 4755 Style); 4756 4757 verifyFormat("Constructor() :\n" 4758 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4759 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4760 Style); 4761 4762 verifyFormat("Constructor(int Parameter = 0) :\n" 4763 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n" 4764 " aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}", 4765 Style); 4766 verifyFormat("Constructor() :\n" 4767 " aaaaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n" 4768 "}", 4769 getStyleWithColumns(Style, 60)); 4770 verifyFormat("Constructor() :\n" 4771 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4772 " aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}", 4773 Style); 4774 4775 // Here a line could be saved by splitting the second initializer onto two 4776 // lines, but that is not desirable. 4777 verifyFormat("Constructor() :\n" 4778 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n" 4779 " aaaaaaaaaaa(aaaaaaaaaaa),\n" 4780 " aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4781 Style); 4782 4783 FormatStyle OnePerLine = Style; 4784 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4785 OnePerLine.AllowAllConstructorInitializersOnNextLine = false; 4786 verifyFormat("SomeClass::Constructor() :\n" 4787 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4788 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4789 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4790 OnePerLine); 4791 verifyFormat("SomeClass::Constructor() :\n" 4792 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n" 4793 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4794 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4795 OnePerLine); 4796 verifyFormat("MyClass::MyClass(int var) :\n" 4797 " some_var_(var), // 4 space indent\n" 4798 " some_other_var_(var + 1) { // lined up\n" 4799 "}", 4800 OnePerLine); 4801 verifyFormat("Constructor() :\n" 4802 " aaaaa(aaaaaa),\n" 4803 " aaaaa(aaaaaa),\n" 4804 " aaaaa(aaaaaa),\n" 4805 " aaaaa(aaaaaa),\n" 4806 " aaaaa(aaaaaa) {}", 4807 OnePerLine); 4808 verifyFormat("Constructor() :\n" 4809 " aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n" 4810 " aaaaaaaaaaaaaaaaaaaaaa) {}", 4811 OnePerLine); 4812 OnePerLine.BinPackParameters = false; 4813 verifyFormat("Constructor() :\n" 4814 " aaaaaaaaaaaaaaaaaaaaaaaa(\n" 4815 " aaaaaaaaaaa().aaa(),\n" 4816 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4817 OnePerLine); 4818 OnePerLine.ColumnLimit = 60; 4819 verifyFormat("Constructor() :\n" 4820 " aaaaaaaaaaaaaaaaaaaa(a),\n" 4821 " bbbbbbbbbbbbbbbbbbbbbbbb(b) {}", 4822 OnePerLine); 4823 4824 EXPECT_EQ("Constructor() :\n" 4825 " // Comment forcing unwanted break.\n" 4826 " aaaa(aaaa) {}", 4827 format("Constructor() :\n" 4828 " // Comment forcing unwanted break.\n" 4829 " aaaa(aaaa) {}", 4830 Style)); 4831 4832 Style.ColumnLimit = 0; 4833 verifyFormat("SomeClass::Constructor() :\n" 4834 " a(a) {}", 4835 Style); 4836 verifyFormat("SomeClass::Constructor() noexcept :\n" 4837 " a(a) {}", 4838 Style); 4839 verifyFormat("SomeClass::Constructor() :\n" 4840 " a(a), b(b), c(c) {}", 4841 Style); 4842 verifyFormat("SomeClass::Constructor() :\n" 4843 " a(a) {\n" 4844 " foo();\n" 4845 " bar();\n" 4846 "}", 4847 Style); 4848 4849 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 4850 verifyFormat("SomeClass::Constructor() :\n" 4851 " a(a), b(b), c(c) {\n" 4852 "}", 4853 Style); 4854 verifyFormat("SomeClass::Constructor() :\n" 4855 " a(a) {\n" 4856 "}", 4857 Style); 4858 4859 Style.ColumnLimit = 80; 4860 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 4861 Style.ConstructorInitializerIndentWidth = 2; 4862 verifyFormat("SomeClass::Constructor() : a(a), b(b), c(c) {}", Style); 4863 verifyFormat("SomeClass::Constructor() :\n" 4864 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4865 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {}", 4866 Style); 4867 4868 // `ConstructorInitializerIndentWidth` actually applies to InheritanceList as 4869 // well 4870 Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon; 4871 verifyFormat( 4872 "class SomeClass\n" 4873 " : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4874 " public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};", 4875 Style); 4876 Style.BreakInheritanceList = FormatStyle::BILS_BeforeComma; 4877 verifyFormat( 4878 "class SomeClass\n" 4879 " : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4880 " , public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};", 4881 Style); 4882 Style.BreakInheritanceList = FormatStyle::BILS_AfterColon; 4883 verifyFormat( 4884 "class SomeClass :\n" 4885 " public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4886 " public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};", 4887 Style); 4888 } 4889 4890 #ifndef EXPENSIVE_CHECKS 4891 // Expensive checks enables libstdc++ checking which includes validating the 4892 // state of ranges used in std::priority_queue - this blows out the 4893 // runtime/scalability of the function and makes this test unacceptably slow. 4894 TEST_F(FormatTest, MemoizationTests) { 4895 // This breaks if the memoization lookup does not take \c Indent and 4896 // \c LastSpace into account. 4897 verifyFormat( 4898 "extern CFRunLoopTimerRef\n" 4899 "CFRunLoopTimerCreate(CFAllocatorRef allocato, CFAbsoluteTime fireDate,\n" 4900 " CFTimeInterval interval, CFOptionFlags flags,\n" 4901 " CFIndex order, CFRunLoopTimerCallBack callout,\n" 4902 " CFRunLoopTimerContext *context) {}"); 4903 4904 // Deep nesting somewhat works around our memoization. 4905 verifyFormat( 4906 "aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 4907 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 4908 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 4909 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 4910 " aaaaa())))))))))))))))))))))))))))))))))))))));", 4911 getLLVMStyleWithColumns(65)); 4912 verifyFormat( 4913 "aaaaa(\n" 4914 " aaaaa,\n" 4915 " aaaaa(\n" 4916 " aaaaa,\n" 4917 " aaaaa(\n" 4918 " aaaaa,\n" 4919 " aaaaa(\n" 4920 " aaaaa,\n" 4921 " aaaaa(\n" 4922 " aaaaa,\n" 4923 " aaaaa(\n" 4924 " aaaaa,\n" 4925 " aaaaa(\n" 4926 " aaaaa,\n" 4927 " aaaaa(\n" 4928 " aaaaa,\n" 4929 " aaaaa(\n" 4930 " aaaaa,\n" 4931 " aaaaa(\n" 4932 " aaaaa,\n" 4933 " aaaaa(\n" 4934 " aaaaa,\n" 4935 " aaaaa(\n" 4936 " aaaaa,\n" 4937 " aaaaa))))))))))));", 4938 getLLVMStyleWithColumns(65)); 4939 verifyFormat( 4940 "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" 4941 " a),\n" 4942 " a),\n" 4943 " a),\n" 4944 " a),\n" 4945 " a),\n" 4946 " a),\n" 4947 " a),\n" 4948 " a),\n" 4949 " a),\n" 4950 " a),\n" 4951 " a),\n" 4952 " a),\n" 4953 " a),\n" 4954 " a),\n" 4955 " a),\n" 4956 " a),\n" 4957 " a)", 4958 getLLVMStyleWithColumns(65)); 4959 4960 // This test takes VERY long when memoization is broken. 4961 FormatStyle OnePerLine = getLLVMStyle(); 4962 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4963 OnePerLine.BinPackParameters = false; 4964 std::string input = "Constructor()\n" 4965 " : aaaa(a,\n"; 4966 for (unsigned i = 0, e = 80; i != e; ++i) { 4967 input += " a,\n"; 4968 } 4969 input += " a) {}"; 4970 verifyFormat(input, OnePerLine); 4971 } 4972 #endif 4973 4974 TEST_F(FormatTest, BreaksAsHighAsPossible) { 4975 verifyFormat( 4976 "void f() {\n" 4977 " if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaaaaaaaa) ||\n" 4978 " (bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb && bbbbbbbbbbbbbbbbbbbbbbbbbb))\n" 4979 " f();\n" 4980 "}"); 4981 verifyFormat("if (Intervals[i].getRange().getFirst() <\n" 4982 " Intervals[i - 1].getRange().getLast()) {\n}"); 4983 } 4984 4985 TEST_F(FormatTest, BreaksFunctionDeclarations) { 4986 // Principially, we break function declarations in a certain order: 4987 // 1) break amongst arguments. 4988 verifyFormat("Aaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccc,\n" 4989 " Cccccccccccccc cccccccccccccc);"); 4990 verifyFormat("template <class TemplateIt>\n" 4991 "SomeReturnType SomeFunction(TemplateIt begin, TemplateIt end,\n" 4992 " TemplateIt *stop) {}"); 4993 4994 // 2) break after return type. 4995 verifyFormat( 4996 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4997 "bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccccccccccccccc);", 4998 getGoogleStyle()); 4999 5000 // 3) break after (. 5001 verifyFormat( 5002 "Aaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbb(\n" 5003 " Cccccccccccccccccccccccccccccc cccccccccccccccccccccccccccccccc);", 5004 getGoogleStyle()); 5005 5006 // 4) break before after nested name specifiers. 5007 verifyFormat( 5008 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5009 "SomeClasssssssssssssssssssssssssssssssssssssss::\n" 5010 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc);", 5011 getGoogleStyle()); 5012 5013 // However, there are exceptions, if a sufficient amount of lines can be 5014 // saved. 5015 // FIXME: The precise cut-offs wrt. the number of saved lines might need some 5016 // more adjusting. 5017 verifyFormat("Aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n" 5018 " Cccccccccccccc cccccccccc,\n" 5019 " Cccccccccccccc cccccccccc,\n" 5020 " Cccccccccccccc cccccccccc,\n" 5021 " Cccccccccccccc cccccccccc);"); 5022 verifyFormat( 5023 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5024 "bbbbbbbbbbb(Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 5025 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 5026 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);", 5027 getGoogleStyle()); 5028 verifyFormat( 5029 "Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n" 5030 " Cccccccccccccc cccccccccc,\n" 5031 " Cccccccccccccc cccccccccc,\n" 5032 " Cccccccccccccc cccccccccc,\n" 5033 " Cccccccccccccc cccccccccc,\n" 5034 " Cccccccccccccc cccccccccc,\n" 5035 " Cccccccccccccc cccccccccc);"); 5036 verifyFormat("Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 5037 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 5038 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 5039 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 5040 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);"); 5041 5042 // Break after multi-line parameters. 5043 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5044 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5045 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5046 " bbbb bbbb);"); 5047 verifyFormat("void SomeLoooooooooooongFunction(\n" 5048 " std::unique_ptr<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n" 5049 " aaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5050 " int bbbbbbbbbbbbb);"); 5051 5052 // Treat overloaded operators like other functions. 5053 verifyFormat("SomeLoooooooooooooooooooooooooogType\n" 5054 "operator>(const SomeLoooooooooooooooooooooooooogType &other);"); 5055 verifyFormat("SomeLoooooooooooooooooooooooooogType\n" 5056 "operator>>(const SomeLooooooooooooooooooooooooogType &other);"); 5057 verifyFormat("SomeLoooooooooooooooooooooooooogType\n" 5058 "operator<<(const SomeLooooooooooooooooooooooooogType &other);"); 5059 verifyGoogleFormat( 5060 "SomeLoooooooooooooooooooooooooooooogType operator>>(\n" 5061 " const SomeLooooooooogType &a, const SomeLooooooooogType &b);"); 5062 verifyGoogleFormat( 5063 "SomeLoooooooooooooooooooooooooooooogType operator<<(\n" 5064 " const SomeLooooooooogType &a, const SomeLooooooooogType &b);"); 5065 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5066 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = 1);"); 5067 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa\n" 5068 "aaaaaaaaaaaaaaaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaa = 1);"); 5069 verifyGoogleFormat( 5070 "typename aaaaaaaaaa<aaaaaa>::aaaaaaaaaaa\n" 5071 "aaaaaaaaaa<aaaaaa>::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5072 " bool *aaaaaaaaaaaaaaaaaa, bool *aa) {}"); 5073 verifyGoogleFormat("template <typename T>\n" 5074 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5075 "aaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaaaaa(\n" 5076 " aaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaa);"); 5077 5078 FormatStyle Style = getLLVMStyle(); 5079 Style.PointerAlignment = FormatStyle::PAS_Left; 5080 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5081 " aaaaaaaaaaaaaaaaaaaaaaaaa* const aaaaaaaaaaaa) {}", 5082 Style); 5083 verifyFormat("void aaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*\n" 5084 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 5085 Style); 5086 } 5087 5088 TEST_F(FormatTest, DontBreakBeforeQualifiedOperator) { 5089 // Regression test for https://bugs.llvm.org/show_bug.cgi?id=40516: 5090 // Prefer keeping `::` followed by `operator` together. 5091 EXPECT_EQ("const aaaa::bbbbbbb &\n" 5092 "ccccccccc::operator++() {\n" 5093 " stuff();\n" 5094 "}", 5095 format("const aaaa::bbbbbbb\n" 5096 "&ccccccccc::operator++() { stuff(); }", 5097 getLLVMStyleWithColumns(40))); 5098 } 5099 5100 TEST_F(FormatTest, TrailingReturnType) { 5101 verifyFormat("auto foo() -> int;\n"); 5102 // correct trailing return type spacing 5103 verifyFormat("auto operator->() -> int;\n"); 5104 verifyFormat("auto operator++(int) -> int;\n"); 5105 5106 verifyFormat("struct S {\n" 5107 " auto bar() const -> int;\n" 5108 "};"); 5109 verifyFormat("template <size_t Order, typename T>\n" 5110 "auto load_img(const std::string &filename)\n" 5111 " -> alias::tensor<Order, T, mem::tag::cpu> {}"); 5112 verifyFormat("auto SomeFunction(A aaaaaaaaaaaaaaaaaaaaa) const\n" 5113 " -> decltype(f(aaaaaaaaaaaaaaaaaaaaa)) {}"); 5114 verifyFormat("auto doSomething(Aaaaaa *aaaaaa) -> decltype(aaaaaa->f()) {}"); 5115 verifyFormat("template <typename T>\n" 5116 "auto aaaaaaaaaaaaaaaaaaaaaa(T t)\n" 5117 " -> decltype(eaaaaaaaaaaaaaaa<T>(t.a).aaaaaaaa());"); 5118 5119 // Not trailing return types. 5120 verifyFormat("void f() { auto a = b->c(); }"); 5121 } 5122 5123 TEST_F(FormatTest, DeductionGuides) { 5124 verifyFormat("template <class T> A(const T &, const T &) -> A<T &>;"); 5125 verifyFormat("template <class T> explicit A(T &, T &&) -> A<T>;"); 5126 verifyFormat("template <class... Ts> S(Ts...) -> S<Ts...>;"); 5127 verifyFormat( 5128 "template <class... T>\n" 5129 "array(T &&... t) -> array<std::common_type_t<T...>, sizeof...(T)>;"); 5130 verifyFormat("template <class T> A() -> A<decltype(p->foo<3>())>;"); 5131 verifyFormat("template <class T> A() -> A<decltype(foo<traits<1>>)>;"); 5132 verifyFormat("template <class T> A() -> A<sizeof(p->foo<1>)>;"); 5133 verifyFormat("template <class T> A() -> A<(3 < 2)>;"); 5134 verifyFormat("template <class T> A() -> A<((3) < (2))>;"); 5135 verifyFormat("template <class T> x() -> x<1>;"); 5136 verifyFormat("template <class T> explicit x(T &) -> x<1>;"); 5137 5138 // Ensure not deduction guides. 5139 verifyFormat("c()->f<int>();"); 5140 verifyFormat("x()->foo<1>;"); 5141 verifyFormat("x = p->foo<3>();"); 5142 verifyFormat("x()->x<1>();"); 5143 verifyFormat("x()->x<1>;"); 5144 } 5145 5146 TEST_F(FormatTest, BreaksFunctionDeclarationsWithTrailingTokens) { 5147 // Avoid breaking before trailing 'const' or other trailing annotations, if 5148 // they are not function-like. 5149 FormatStyle Style = getGoogleStyle(); 5150 Style.ColumnLimit = 47; 5151 verifyFormat("void someLongFunction(\n" 5152 " int someLoooooooooooooongParameter) const {\n}", 5153 getLLVMStyleWithColumns(47)); 5154 verifyFormat("LoooooongReturnType\n" 5155 "someLoooooooongFunction() const {}", 5156 getLLVMStyleWithColumns(47)); 5157 verifyFormat("LoooooongReturnType someLoooooooongFunction()\n" 5158 " const {}", 5159 Style); 5160 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n" 5161 " aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE;"); 5162 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n" 5163 " aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE FINAL;"); 5164 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n" 5165 " aaaaa aaaaaaaaaaaaaaaaaaaa) override final;"); 5166 verifyFormat("virtual void aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa,\n" 5167 " aaaaaaaaaaa aaaaa) const override;"); 5168 verifyGoogleFormat( 5169 "virtual void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5170 " const override;"); 5171 5172 // Even if the first parameter has to be wrapped. 5173 verifyFormat("void someLongFunction(\n" 5174 " int someLongParameter) const {}", 5175 getLLVMStyleWithColumns(46)); 5176 verifyFormat("void someLongFunction(\n" 5177 " int someLongParameter) const {}", 5178 Style); 5179 verifyFormat("void someLongFunction(\n" 5180 " int someLongParameter) override {}", 5181 Style); 5182 verifyFormat("void someLongFunction(\n" 5183 " int someLongParameter) OVERRIDE {}", 5184 Style); 5185 verifyFormat("void someLongFunction(\n" 5186 " int someLongParameter) final {}", 5187 Style); 5188 verifyFormat("void someLongFunction(\n" 5189 " int someLongParameter) FINAL {}", 5190 Style); 5191 verifyFormat("void someLongFunction(\n" 5192 " int parameter) const override {}", 5193 Style); 5194 5195 Style.BreakBeforeBraces = FormatStyle::BS_Allman; 5196 verifyFormat("void someLongFunction(\n" 5197 " int someLongParameter) const\n" 5198 "{\n" 5199 "}", 5200 Style); 5201 5202 Style.BreakBeforeBraces = FormatStyle::BS_Whitesmiths; 5203 verifyFormat("void someLongFunction(\n" 5204 " int someLongParameter) const\n" 5205 " {\n" 5206 " }", 5207 Style); 5208 5209 // Unless these are unknown annotations. 5210 verifyFormat("void SomeFunction(aaaaaaaaaa aaaaaaaaaaaaaaa,\n" 5211 " aaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5212 " LONG_AND_UGLY_ANNOTATION;"); 5213 5214 // Breaking before function-like trailing annotations is fine to keep them 5215 // close to their arguments. 5216 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5217 " LOCKS_EXCLUDED(aaaaaaaaaaaaa);"); 5218 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n" 5219 " LOCKS_EXCLUDED(aaaaaaaaaaaaa);"); 5220 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n" 5221 " LOCKS_EXCLUDED(aaaaaaaaaaaaa) {}"); 5222 verifyGoogleFormat("void aaaaaaaaaaaaaa(aaaaaaaa aaa) override\n" 5223 " AAAAAAAAAAAAAAAAAAAAAAAA(aaaaaaaaaaaaaaa);"); 5224 verifyFormat("SomeFunction([](int i) LOCKS_EXCLUDED(a) {});"); 5225 5226 verifyFormat( 5227 "void aaaaaaaaaaaaaaaaaa()\n" 5228 " __attribute__((aaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaa,\n" 5229 " aaaaaaaaaaaaaaaaaaaaaaaaa));"); 5230 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5231 " __attribute__((unused));"); 5232 verifyGoogleFormat( 5233 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5234 " GUARDED_BY(aaaaaaaaaaaa);"); 5235 verifyGoogleFormat( 5236 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5237 " GUARDED_BY(aaaaaaaaaaaa);"); 5238 verifyGoogleFormat( 5239 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n" 5240 " aaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5241 verifyGoogleFormat( 5242 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n" 5243 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5244 } 5245 5246 TEST_F(FormatTest, FunctionAnnotations) { 5247 verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n" 5248 "int OldFunction(const string ¶meter) {}"); 5249 verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n" 5250 "string OldFunction(const string ¶meter) {}"); 5251 verifyFormat("template <typename T>\n" 5252 "DEPRECATED(\"Use NewClass::NewFunction instead.\")\n" 5253 "string OldFunction(const string ¶meter) {}"); 5254 5255 // Not function annotations. 5256 verifyFormat("ASSERT(\"aaaaa\") << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5257 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"); 5258 verifyFormat("TEST_F(ThisIsATestFixtureeeeeeeeeeeee,\n" 5259 " ThisIsATestWithAReallyReallyReallyReallyLongName) {}"); 5260 verifyFormat("MACRO(abc).function() // wrap\n" 5261 " << abc;"); 5262 verifyFormat("MACRO(abc)->function() // wrap\n" 5263 " << abc;"); 5264 verifyFormat("MACRO(abc)::function() // wrap\n" 5265 " << abc;"); 5266 } 5267 5268 TEST_F(FormatTest, BreaksDesireably) { 5269 verifyFormat("if (aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n" 5270 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n" 5271 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa)) {\n}"); 5272 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5273 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n" 5274 "}"); 5275 5276 verifyFormat( 5277 "aaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5278 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); 5279 5280 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5281 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5282 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 5283 5284 verifyFormat( 5285 "aaaaaaaa(aaaaaaaaaaaaa,\n" 5286 " aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5287 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n" 5288 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5289 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));"); 5290 5291 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 5292 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5293 5294 verifyFormat( 5295 "void f() {\n" 5296 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&\n" 5297 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 5298 "}"); 5299 verifyFormat( 5300 "aaaaaa(new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5301 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 5302 verifyFormat( 5303 "aaaaaa(aaa, new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5304 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 5305 verifyFormat( 5306 "aaaaaa(aaa,\n" 5307 " new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5308 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5309 " aaaa);"); 5310 verifyFormat("aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5311 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5312 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5313 5314 // Indent consistently independent of call expression and unary operator. 5315 verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 5316 " dddddddddddddddddddddddddddddd));"); 5317 verifyFormat("aaaaaaaaaaa(!bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 5318 " dddddddddddddddddddddddddddddd));"); 5319 verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbb.ccccccccccccccccc(\n" 5320 " dddddddddddddddddddddddddddddd));"); 5321 5322 // This test case breaks on an incorrect memoization, i.e. an optimization not 5323 // taking into account the StopAt value. 5324 verifyFormat( 5325 "return aaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 5326 " aaaaaaaaaaa(aaaaaaaaa) || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 5327 " aaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 5328 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5329 5330 verifyFormat("{\n {\n {\n" 5331 " Annotation.SpaceRequiredBefore =\n" 5332 " Line.Tokens[i - 1].Tok.isNot(tok::l_paren) &&\n" 5333 " Line.Tokens[i - 1].Tok.isNot(tok::l_square);\n" 5334 " }\n }\n}"); 5335 5336 // Break on an outer level if there was a break on an inner level. 5337 EXPECT_EQ("f(g(h(a, // comment\n" 5338 " b, c),\n" 5339 " d, e),\n" 5340 " x, y);", 5341 format("f(g(h(a, // comment\n" 5342 " b, c), d, e), x, y);")); 5343 5344 // Prefer breaking similar line breaks. 5345 verifyFormat( 5346 "const int kTrackingOptions = NSTrackingMouseMoved |\n" 5347 " NSTrackingMouseEnteredAndExited |\n" 5348 " NSTrackingActiveAlways;"); 5349 } 5350 5351 TEST_F(FormatTest, FormatsDeclarationsOnePerLine) { 5352 FormatStyle NoBinPacking = getGoogleStyle(); 5353 NoBinPacking.BinPackParameters = false; 5354 NoBinPacking.BinPackArguments = true; 5355 verifyFormat("void f() {\n" 5356 " f(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa,\n" 5357 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 5358 "}", 5359 NoBinPacking); 5360 verifyFormat("void f(int aaaaaaaaaaaaaaaaaaaa,\n" 5361 " int aaaaaaaaaaaaaaaaaaaa,\n" 5362 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 5363 NoBinPacking); 5364 5365 NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false; 5366 verifyFormat("void aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5367 " vector<int> bbbbbbbbbbbbbbb);", 5368 NoBinPacking); 5369 // FIXME: This behavior difference is probably not wanted. However, currently 5370 // we cannot distinguish BreakBeforeParameter being set because of the wrapped 5371 // template arguments from BreakBeforeParameter being set because of the 5372 // one-per-line formatting. 5373 verifyFormat( 5374 "void fffffffffff(aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa,\n" 5375 " aaaaaaaaaa> aaaaaaaaaa);", 5376 NoBinPacking); 5377 verifyFormat( 5378 "void fffffffffff(\n" 5379 " aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaa>\n" 5380 " aaaaaaaaaa);"); 5381 } 5382 5383 TEST_F(FormatTest, FormatsOneParameterPerLineIfNecessary) { 5384 FormatStyle NoBinPacking = getGoogleStyle(); 5385 NoBinPacking.BinPackParameters = false; 5386 NoBinPacking.BinPackArguments = false; 5387 verifyFormat("f(aaaaaaaaaaaaaaaaaaaa,\n" 5388 " aaaaaaaaaaaaaaaaaaaa,\n" 5389 " aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaa);", 5390 NoBinPacking); 5391 verifyFormat("aaaaaaa(aaaaaaaaaaaaa,\n" 5392 " aaaaaaaaaaaaa,\n" 5393 " aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));", 5394 NoBinPacking); 5395 verifyFormat( 5396 "aaaaaaaa(aaaaaaaaaaaaa,\n" 5397 " aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5398 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n" 5399 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5400 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));", 5401 NoBinPacking); 5402 verifyFormat("aaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n" 5403 " .aaaaaaaaaaaaaaaaaa();", 5404 NoBinPacking); 5405 verifyFormat("void f() {\n" 5406 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5407 " aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaa);\n" 5408 "}", 5409 NoBinPacking); 5410 5411 verifyFormat( 5412 "aaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5413 " aaaaaaaaaaaa,\n" 5414 " aaaaaaaaaaaa);", 5415 NoBinPacking); 5416 verifyFormat( 5417 "somefunction(someotherFunction(ddddddddddddddddddddddddddddddddddd,\n" 5418 " ddddddddddddddddddddddddddddd),\n" 5419 " test);", 5420 NoBinPacking); 5421 5422 verifyFormat("std::vector<aaaaaaaaaaaaaaaaaaaaaaa,\n" 5423 " aaaaaaaaaaaaaaaaaaaaaaa,\n" 5424 " aaaaaaaaaaaaaaaaaaaaaaa>\n" 5425 " aaaaaaaaaaaaaaaaaa;", 5426 NoBinPacking); 5427 verifyFormat("a(\"a\"\n" 5428 " \"a\",\n" 5429 " a);"); 5430 5431 NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false; 5432 verifyFormat("void aaaaaaaaaa(aaaaaaaaa,\n" 5433 " aaaaaaaaa,\n" 5434 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5435 NoBinPacking); 5436 verifyFormat( 5437 "void f() {\n" 5438 " aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n" 5439 " .aaaaaaa();\n" 5440 "}", 5441 NoBinPacking); 5442 verifyFormat( 5443 "template <class SomeType, class SomeOtherType>\n" 5444 "SomeType SomeFunction(SomeType Type, SomeOtherType OtherType) {}", 5445 NoBinPacking); 5446 } 5447 5448 TEST_F(FormatTest, AdaptiveOnePerLineFormatting) { 5449 FormatStyle Style = getLLVMStyleWithColumns(15); 5450 Style.ExperimentalAutoDetectBinPacking = true; 5451 EXPECT_EQ("aaa(aaaa,\n" 5452 " aaaa,\n" 5453 " aaaa);\n" 5454 "aaa(aaaa,\n" 5455 " aaaa,\n" 5456 " aaaa);", 5457 format("aaa(aaaa,\n" // one-per-line 5458 " aaaa,\n" 5459 " aaaa );\n" 5460 "aaa(aaaa, aaaa, aaaa);", // inconclusive 5461 Style)); 5462 EXPECT_EQ("aaa(aaaa, aaaa,\n" 5463 " aaaa);\n" 5464 "aaa(aaaa, aaaa,\n" 5465 " aaaa);", 5466 format("aaa(aaaa, aaaa,\n" // bin-packed 5467 " aaaa );\n" 5468 "aaa(aaaa, aaaa, aaaa);", // inconclusive 5469 Style)); 5470 } 5471 5472 TEST_F(FormatTest, FormatsBuilderPattern) { 5473 verifyFormat("return llvm::StringSwitch<Reference::Kind>(name)\n" 5474 " .StartsWith(\".eh_frame_hdr\", ORDER_EH_FRAMEHDR)\n" 5475 " .StartsWith(\".eh_frame\", ORDER_EH_FRAME)\n" 5476 " .StartsWith(\".init\", ORDER_INIT)\n" 5477 " .StartsWith(\".fini\", ORDER_FINI)\n" 5478 " .StartsWith(\".hash\", ORDER_HASH)\n" 5479 " .Default(ORDER_TEXT);\n"); 5480 5481 verifyFormat("return aaaaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa() <\n" 5482 " aaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa();"); 5483 verifyFormat("aaaaaaa->aaaaaaa\n" 5484 " ->aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5485 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5486 " ->aaaaaaaa(aaaaaaaaaaaaaaa);"); 5487 verifyFormat( 5488 "aaaaaaa->aaaaaaa\n" 5489 " ->aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5490 " ->aaaaaaaa(aaaaaaaaaaaaaaa);"); 5491 verifyFormat( 5492 "aaaaaaaaaaaaaaaaaaa()->aaaaaa(bbbbb)->aaaaaaaaaaaaaaaaaaa( // break\n" 5493 " aaaaaaaaaaaaaa);"); 5494 verifyFormat( 5495 "aaaaaaaaaaaaaaaaaaaaaaa *aaaaaaaaa =\n" 5496 " aaaaaa->aaaaaaaaaaaa()\n" 5497 " ->aaaaaaaaaaaaaaaa(\n" 5498 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5499 " ->aaaaaaaaaaaaaaaaa();"); 5500 verifyGoogleFormat( 5501 "void f() {\n" 5502 " someo->Add((new util::filetools::Handler(dir))\n" 5503 " ->OnEvent1(NewPermanentCallback(\n" 5504 " this, &HandlerHolderClass::EventHandlerCBA))\n" 5505 " ->OnEvent2(NewPermanentCallback(\n" 5506 " this, &HandlerHolderClass::EventHandlerCBB))\n" 5507 " ->OnEvent3(NewPermanentCallback(\n" 5508 " this, &HandlerHolderClass::EventHandlerCBC))\n" 5509 " ->OnEvent5(NewPermanentCallback(\n" 5510 " this, &HandlerHolderClass::EventHandlerCBD))\n" 5511 " ->OnEvent6(NewPermanentCallback(\n" 5512 " this, &HandlerHolderClass::EventHandlerCBE)));\n" 5513 "}"); 5514 5515 verifyFormat( 5516 "aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa();"); 5517 verifyFormat("aaaaaaaaaaaaaaa()\n" 5518 " .aaaaaaaaaaaaaaa()\n" 5519 " .aaaaaaaaaaaaaaa()\n" 5520 " .aaaaaaaaaaaaaaa()\n" 5521 " .aaaaaaaaaaaaaaa();"); 5522 verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n" 5523 " .aaaaaaaaaaaaaaa()\n" 5524 " .aaaaaaaaaaaaaaa()\n" 5525 " .aaaaaaaaaaaaaaa();"); 5526 verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n" 5527 " .aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n" 5528 " .aaaaaaaaaaaaaaa();"); 5529 verifyFormat("aaaaaaaaaaaaa->aaaaaaaaaaaaaaaaaaaaaaaa()\n" 5530 " ->aaaaaaaaaaaaaae(0)\n" 5531 " ->aaaaaaaaaaaaaaa();"); 5532 5533 // Don't linewrap after very short segments. 5534 verifyFormat("a().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5535 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5536 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 5537 verifyFormat("aa().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5538 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5539 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 5540 verifyFormat("aaa()\n" 5541 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5542 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5543 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 5544 5545 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n" 5546 " .aaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5547 " .has<bbbbbbbbbbbbbbbbbbbbb>();"); 5548 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n" 5549 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n" 5550 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>();"); 5551 5552 // Prefer not to break after empty parentheses. 5553 verifyFormat("FirstToken->WhitespaceRange.getBegin().getLocWithOffset(\n" 5554 " First->LastNewlineOffset);"); 5555 5556 // Prefer not to create "hanging" indents. 5557 verifyFormat( 5558 "return !soooooooooooooome_map\n" 5559 " .insert(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5560 " .second;"); 5561 verifyFormat( 5562 "return aaaaaaaaaaaaaaaa\n" 5563 " .aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa)\n" 5564 " .aaaa(aaaaaaaaaaaaaa);"); 5565 // No hanging indent here. 5566 verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa.aaaaaaaaaaaaaaa(\n" 5567 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5568 verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa().aaaaaaaaaaaaaaa(\n" 5569 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5570 verifyFormat("aaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n" 5571 " .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5572 getLLVMStyleWithColumns(60)); 5573 verifyFormat("aaaaaaaaaaaaaaaaaa\n" 5574 " .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n" 5575 " .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5576 getLLVMStyleWithColumns(59)); 5577 verifyFormat("aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5578 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5579 " .aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5580 5581 // Dont break if only closing statements before member call 5582 verifyFormat("test() {\n" 5583 " ([]() -> {\n" 5584 " int b = 32;\n" 5585 " return 3;\n" 5586 " }).foo();\n" 5587 "}"); 5588 verifyFormat("test() {\n" 5589 " (\n" 5590 " []() -> {\n" 5591 " int b = 32;\n" 5592 " return 3;\n" 5593 " },\n" 5594 " foo, bar)\n" 5595 " .foo();\n" 5596 "}"); 5597 verifyFormat("test() {\n" 5598 " ([]() -> {\n" 5599 " int b = 32;\n" 5600 " return 3;\n" 5601 " })\n" 5602 " .foo()\n" 5603 " .bar();\n" 5604 "}"); 5605 verifyFormat("test() {\n" 5606 " ([]() -> {\n" 5607 " int b = 32;\n" 5608 " return 3;\n" 5609 " })\n" 5610 " .foo(\"aaaaaaaaaaaaaaaaa\"\n" 5611 " \"bbbb\");\n" 5612 "}", 5613 getLLVMStyleWithColumns(30)); 5614 } 5615 5616 TEST_F(FormatTest, BreaksAccordingToOperatorPrecedence) { 5617 verifyFormat( 5618 "if (aaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 5619 " bbbbbbbbbbbbbbbbbbbbbbbbb && ccccccccccccccccccccccccc) {\n}"); 5620 verifyFormat( 5621 "if (aaaaaaaaaaaaaaaaaaaaaaaaa or\n" 5622 " bbbbbbbbbbbbbbbbbbbbbbbbb and cccccccccccccccccccccccc) {\n}"); 5623 5624 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa && bbbbbbbbbbbbbbbbbbbbbbbbb ||\n" 5625 " ccccccccccccccccccccccccc) {\n}"); 5626 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa and bbbbbbbbbbbbbbbbbbbbbbbb or\n" 5627 " ccccccccccccccccccccccccc) {\n}"); 5628 5629 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb ||\n" 5630 " ccccccccccccccccccccccccc) {\n}"); 5631 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb or\n" 5632 " ccccccccccccccccccccccccc) {\n}"); 5633 5634 verifyFormat( 5635 "if ((aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb) &&\n" 5636 " ccccccccccccccccccccccccc) {\n}"); 5637 verifyFormat( 5638 "if ((aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb) and\n" 5639 " ccccccccccccccccccccccccc) {\n}"); 5640 5641 verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA ||\n" 5642 " bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB ||\n" 5643 " cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC ||\n" 5644 " dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;"); 5645 verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA or\n" 5646 " bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB or\n" 5647 " cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC or\n" 5648 " dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;"); 5649 5650 verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa ||\n" 5651 " aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) &&\n" 5652 " aaaaaaaaaaaaaaa != aa) {\n}"); 5653 verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa or\n" 5654 " aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) and\n" 5655 " aaaaaaaaaaaaaaa != aa) {\n}"); 5656 } 5657 5658 TEST_F(FormatTest, BreaksAfterAssignments) { 5659 verifyFormat( 5660 "unsigned Cost =\n" 5661 " TTI.getMemoryOpCost(I->getOpcode(), VectorTy, SI->getAlignment(),\n" 5662 " SI->getPointerAddressSpaceee());\n"); 5663 verifyFormat( 5664 "CharSourceRange LineRange = CharSourceRange::getTokenRange(\n" 5665 " Line.Tokens.front().Tok.getLo(), Line.Tokens.back().Tok.getLoc());"); 5666 5667 verifyFormat( 5668 "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa = aaaaaaaaaaaaaa(0).aaaa().aaaaaaaaa(\n" 5669 " aaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaa);"); 5670 verifyFormat("unsigned OriginalStartColumn =\n" 5671 " SourceMgr.getSpellingColumnNumber(\n" 5672 " Current.FormatTok.getStartOfNonWhitespace()) -\n" 5673 " 1;"); 5674 } 5675 5676 TEST_F(FormatTest, ConfigurableBreakAssignmentPenalty) { 5677 FormatStyle Style = getLLVMStyle(); 5678 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 5679 " bbbbbbbbbbbbbbbbbbbbbbbbbb + cccccccccccccccccccccccccc;", 5680 Style); 5681 5682 Style.PenaltyBreakAssignment = 20; 5683 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa = bbbbbbbbbbbbbbbbbbbbbbbbbb +\n" 5684 " cccccccccccccccccccccccccc;", 5685 Style); 5686 } 5687 5688 TEST_F(FormatTest, AlignsAfterAssignments) { 5689 verifyFormat( 5690 "int Result = aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5691 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5692 verifyFormat( 5693 "Result += aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5694 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5695 verifyFormat( 5696 "Result >>= aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5697 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5698 verifyFormat( 5699 "int Result = (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5700 " aaaaaaaaaaaaaaaaaaaaaaaaa);"); 5701 verifyFormat( 5702 "double LooooooooooooooooooooooooongResult = aaaaaaaaaaaaaaaaaaaaaaaa +\n" 5703 " aaaaaaaaaaaaaaaaaaaaaaaa +\n" 5704 " aaaaaaaaaaaaaaaaaaaaaaaa;"); 5705 } 5706 5707 TEST_F(FormatTest, AlignsAfterReturn) { 5708 verifyFormat( 5709 "return aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5710 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5711 verifyFormat( 5712 "return (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5713 " aaaaaaaaaaaaaaaaaaaaaaaaa);"); 5714 verifyFormat( 5715 "return aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n" 5716 " aaaaaaaaaaaaaaaaaaaaaa();"); 5717 verifyFormat( 5718 "return (aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n" 5719 " aaaaaaaaaaaaaaaaaaaaaa());"); 5720 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5721 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5722 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5723 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) &&\n" 5724 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5725 verifyFormat("return\n" 5726 " // true if code is one of a or b.\n" 5727 " code == a || code == b;"); 5728 } 5729 5730 TEST_F(FormatTest, AlignsAfterOpenBracket) { 5731 verifyFormat( 5732 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n" 5733 " aaaaaaaaa aaaaaaa) {}"); 5734 verifyFormat( 5735 "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n" 5736 " aaaaaaaaaaa aaaaaaaaa);"); 5737 verifyFormat( 5738 "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n" 5739 " aaaaaaaaaaaaaaaaaaaaa));"); 5740 FormatStyle Style = getLLVMStyle(); 5741 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 5742 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5743 " aaaaaaaaaaa aaaaaaaa, aaaaaaaaa aaaaaaa) {}", 5744 Style); 5745 verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n" 5746 " aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaa aaaaaaaaa);", 5747 Style); 5748 verifyFormat("SomeLongVariableName->someFunction(\n" 5749 " foooooooo(aaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa));", 5750 Style); 5751 verifyFormat( 5752 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n" 5753 " aaaaaaaaa aaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 5754 Style); 5755 verifyFormat( 5756 "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n" 5757 " aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5758 Style); 5759 verifyFormat( 5760 "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n" 5761 " aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));", 5762 Style); 5763 5764 verifyFormat("bbbbbbbbbbbb(aaaaaaaaaaaaaaaaaaaaaaaa, //\n" 5765 " ccccccc(aaaaaaaaaaaaaaaaa, //\n" 5766 " b));", 5767 Style); 5768 5769 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 5770 Style.BinPackArguments = false; 5771 Style.BinPackParameters = false; 5772 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5773 " aaaaaaaaaaa aaaaaaaa,\n" 5774 " aaaaaaaaa aaaaaaa,\n" 5775 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 5776 Style); 5777 verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n" 5778 " aaaaaaaaaaa aaaaaaaaa,\n" 5779 " aaaaaaaaaaa aaaaaaaaa,\n" 5780 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5781 Style); 5782 verifyFormat("SomeLongVariableName->someFunction(foooooooo(\n" 5783 " aaaaaaaaaaaaaaa,\n" 5784 " aaaaaaaaaaaaaaaaaaaaa,\n" 5785 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));", 5786 Style); 5787 verifyFormat( 5788 "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa(\n" 5789 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));", 5790 Style); 5791 verifyFormat( 5792 "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaa.aaaaaaaaaa(\n" 5793 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));", 5794 Style); 5795 verifyFormat( 5796 "aaaaaaaaaaaaaaaaaaaaaaaa(\n" 5797 " aaaaaaaaaaaaaaaaaaaaa(\n" 5798 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)),\n" 5799 " aaaaaaaaaaaaaaaa);", 5800 Style); 5801 verifyFormat( 5802 "aaaaaaaaaaaaaaaaaaaaaaaa(\n" 5803 " aaaaaaaaaaaaaaaaaaaaa(\n" 5804 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)) &&\n" 5805 " aaaaaaaaaaaaaaaa);", 5806 Style); 5807 } 5808 5809 TEST_F(FormatTest, ParenthesesAndOperandAlignment) { 5810 FormatStyle Style = getLLVMStyleWithColumns(40); 5811 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5812 " bbbbbbbbbbbbbbbbbbbbbb);", 5813 Style); 5814 Style.AlignAfterOpenBracket = FormatStyle::BAS_Align; 5815 Style.AlignOperands = false; 5816 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5817 " bbbbbbbbbbbbbbbbbbbbbb);", 5818 Style); 5819 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 5820 Style.AlignOperands = true; 5821 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5822 " bbbbbbbbbbbbbbbbbbbbbb);", 5823 Style); 5824 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 5825 Style.AlignOperands = false; 5826 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5827 " bbbbbbbbbbbbbbbbbbbbbb);", 5828 Style); 5829 } 5830 5831 TEST_F(FormatTest, BreaksConditionalExpressions) { 5832 verifyFormat( 5833 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5834 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5835 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5836 verifyFormat( 5837 "aaaa(aaaaaaaaaa, aaaaaaaa,\n" 5838 " aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5839 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5840 verifyFormat( 5841 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5842 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5843 verifyFormat("aaaa(aaaaaaaaa, aaaaaaaaa,\n" 5844 " aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5845 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5846 verifyFormat( 5847 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa)\n" 5848 " : aaaaaaaaaaaaa);"); 5849 verifyFormat( 5850 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5851 " aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5852 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5853 " aaaaaaaaaaaaa);"); 5854 verifyFormat( 5855 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5856 " aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5857 " aaaaaaaaaaaaa);"); 5858 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5859 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5860 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5861 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5862 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5863 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5864 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5865 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5866 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5867 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5868 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5869 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5870 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5871 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5872 " ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5873 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5874 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5875 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5876 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5877 " : aaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5878 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n" 5879 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5880 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5881 " : aaaaaaaaaaaaaaaa;"); 5882 verifyFormat( 5883 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5884 " ? aaaaaaaaaaaaaaa\n" 5885 " : aaaaaaaaaaaaaaa;"); 5886 verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n" 5887 " aaaaaaaaa\n" 5888 " ? b\n" 5889 " : c);"); 5890 verifyFormat("return aaaa == bbbb\n" 5891 " // comment\n" 5892 " ? aaaa\n" 5893 " : bbbb;"); 5894 verifyFormat("unsigned Indent =\n" 5895 " format(TheLine.First,\n" 5896 " IndentForLevel[TheLine.Level] >= 0\n" 5897 " ? IndentForLevel[TheLine.Level]\n" 5898 " : TheLine * 2,\n" 5899 " TheLine.InPPDirective, PreviousEndOfLineColumn);", 5900 getLLVMStyleWithColumns(60)); 5901 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n" 5902 " ? aaaaaaaaaaaaaaa\n" 5903 " : bbbbbbbbbbbbbbb //\n" 5904 " ? ccccccccccccccc\n" 5905 " : ddddddddddddddd;"); 5906 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n" 5907 " ? aaaaaaaaaaaaaaa\n" 5908 " : (bbbbbbbbbbbbbbb //\n" 5909 " ? ccccccccccccccc\n" 5910 " : ddddddddddddddd);"); 5911 verifyFormat( 5912 "int aaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5913 " ? aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5914 " aaaaaaaaaaaaaaaaaaaaa +\n" 5915 " aaaaaaaaaaaaaaaaaaaaa\n" 5916 " : aaaaaaaaaa;"); 5917 verifyFormat( 5918 "aaaaaa = aaaaaaaaaaaa ? aaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5919 " : aaaaaaaaaaaaaaaaaaaaaa\n" 5920 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5921 5922 FormatStyle NoBinPacking = getLLVMStyle(); 5923 NoBinPacking.BinPackArguments = false; 5924 verifyFormat( 5925 "void f() {\n" 5926 " g(aaa,\n" 5927 " aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n" 5928 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5929 " ? aaaaaaaaaaaaaaa\n" 5930 " : aaaaaaaaaaaaaaa);\n" 5931 "}", 5932 NoBinPacking); 5933 verifyFormat( 5934 "void f() {\n" 5935 " g(aaa,\n" 5936 " aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n" 5937 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5938 " ?: aaaaaaaaaaaaaaa);\n" 5939 "}", 5940 NoBinPacking); 5941 5942 verifyFormat("SomeFunction(aaaaaaaaaaaaaaaaa,\n" 5943 " // comment.\n" 5944 " ccccccccccccccccccccccccccccccccccccccc\n" 5945 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5946 " : bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);"); 5947 5948 // Assignments in conditional expressions. Apparently not uncommon :-(. 5949 verifyFormat("return a != b\n" 5950 " // comment\n" 5951 " ? a = b\n" 5952 " : a = b;"); 5953 verifyFormat("return a != b\n" 5954 " // comment\n" 5955 " ? a = a != b\n" 5956 " // comment\n" 5957 " ? a = b\n" 5958 " : a\n" 5959 " : a;\n"); 5960 verifyFormat("return a != b\n" 5961 " // comment\n" 5962 " ? a\n" 5963 " : a = a != b\n" 5964 " // comment\n" 5965 " ? a = b\n" 5966 " : a;"); 5967 } 5968 5969 TEST_F(FormatTest, BreaksConditionalExpressionsAfterOperator) { 5970 FormatStyle Style = getLLVMStyle(); 5971 Style.BreakBeforeTernaryOperators = false; 5972 Style.ColumnLimit = 70; 5973 verifyFormat( 5974 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5975 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5976 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5977 Style); 5978 verifyFormat( 5979 "aaaa(aaaaaaaaaa, aaaaaaaa,\n" 5980 " aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5981 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5982 Style); 5983 verifyFormat( 5984 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5985 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5986 Style); 5987 verifyFormat("aaaa(aaaaaaaa, aaaaaaaaaa,\n" 5988 " aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5989 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5990 Style); 5991 verifyFormat( 5992 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa) :\n" 5993 " aaaaaaaaaaaaa);", 5994 Style); 5995 verifyFormat( 5996 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5997 " aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5998 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5999 " aaaaaaaaaaaaa);", 6000 Style); 6001 verifyFormat( 6002 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6003 " aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6004 " aaaaaaaaaaaaa);", 6005 Style); 6006 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 6007 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6008 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n" 6009 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6010 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 6011 Style); 6012 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6013 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 6014 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6015 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n" 6016 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6017 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 6018 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);", 6019 Style); 6020 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6021 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?:\n" 6022 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6023 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 6024 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);", 6025 Style); 6026 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 6027 " aaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 6028 " aaaaaaaaaaaaaaaaaaaaaaaaaaa;", 6029 Style); 6030 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n" 6031 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 6032 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 6033 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 6034 Style); 6035 verifyFormat( 6036 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 6037 " aaaaaaaaaaaaaaa :\n" 6038 " aaaaaaaaaaaaaaa;", 6039 Style); 6040 verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n" 6041 " aaaaaaaaa ?\n" 6042 " b :\n" 6043 " c);", 6044 Style); 6045 verifyFormat("unsigned Indent =\n" 6046 " format(TheLine.First,\n" 6047 " IndentForLevel[TheLine.Level] >= 0 ?\n" 6048 " IndentForLevel[TheLine.Level] :\n" 6049 " TheLine * 2,\n" 6050 " TheLine.InPPDirective, PreviousEndOfLineColumn);", 6051 Style); 6052 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n" 6053 " aaaaaaaaaaaaaaa :\n" 6054 " bbbbbbbbbbbbbbb ? //\n" 6055 " ccccccccccccccc :\n" 6056 " ddddddddddddddd;", 6057 Style); 6058 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n" 6059 " aaaaaaaaaaaaaaa :\n" 6060 " (bbbbbbbbbbbbbbb ? //\n" 6061 " ccccccccccccccc :\n" 6062 " ddddddddddddddd);", 6063 Style); 6064 verifyFormat("int i = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 6065 " /*bbbbbbbbbbbbbbb=*/bbbbbbbbbbbbbbbbbbbbbbbbb :\n" 6066 " ccccccccccccccccccccccccccc;", 6067 Style); 6068 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 6069 " aaaaa :\n" 6070 " bbbbbbbbbbbbbbb + cccccccccccccccc;", 6071 Style); 6072 } 6073 6074 TEST_F(FormatTest, DeclarationsOfMultipleVariables) { 6075 verifyFormat("bool aaaaaaaaaaaaaaaaa = aaaaaa->aaaaaaaaaaaaaaaaa(),\n" 6076 " aaaaaaaaaaa = aaaaaa->aaaaaaaaaaa();"); 6077 verifyFormat("bool a = true, b = false;"); 6078 6079 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaa =\n" 6080 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa),\n" 6081 " bbbbbbbbbbbbbbbbbbbbbbbbb =\n" 6082 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(bbbbbbbbbbbbbbbb);"); 6083 verifyFormat( 6084 "bool aaaaaaaaaaaaaaaaaaaaa =\n" 6085 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb && cccccccccccccccccccccccccccc,\n" 6086 " d = e && f;"); 6087 verifyFormat("aaaaaaaaa a = aaaaaaaaaaaaaaaaaaaa, b = bbbbbbbbbbbbbbbbbbbb,\n" 6088 " c = cccccccccccccccccccc, d = dddddddddddddddddddd;"); 6089 verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n" 6090 " *c = ccccccccccccccccccc, *d = ddddddddddddddddddd;"); 6091 verifyFormat("aaaaaaaaa ***a = aaaaaaaaaaaaaaaaaaa, ***b = bbbbbbbbbbbbbbb,\n" 6092 " ***c = ccccccccccccccccccc, ***d = ddddddddddddddd;"); 6093 6094 FormatStyle Style = getGoogleStyle(); 6095 Style.PointerAlignment = FormatStyle::PAS_Left; 6096 Style.DerivePointerAlignment = false; 6097 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6098 " *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaa,\n" 6099 " *b = bbbbbbbbbbbbbbbbbbb;", 6100 Style); 6101 verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n" 6102 " *b = bbbbbbbbbbbbbbbbbbb, *d = ddddddddddddddddddd;", 6103 Style); 6104 verifyFormat("vector<int*> a, b;", Style); 6105 verifyFormat("for (int *p, *q; p != q; p = p->next) {\n}", Style); 6106 } 6107 6108 TEST_F(FormatTest, ConditionalExpressionsInBrackets) { 6109 verifyFormat("arr[foo ? bar : baz];"); 6110 verifyFormat("f()[foo ? bar : baz];"); 6111 verifyFormat("(a + b)[foo ? bar : baz];"); 6112 verifyFormat("arr[foo ? (4 > 5 ? 4 : 5) : 5 < 5 ? 5 : 7];"); 6113 } 6114 6115 TEST_F(FormatTest, AlignsStringLiterals) { 6116 verifyFormat("loooooooooooooooooooooooooongFunction(\"short literal \"\n" 6117 " \"short literal\");"); 6118 verifyFormat( 6119 "looooooooooooooooooooooooongFunction(\n" 6120 " \"short literal\"\n" 6121 " \"looooooooooooooooooooooooooooooooooooooooooooooooong literal\");"); 6122 verifyFormat("someFunction(\"Always break between multi-line\"\n" 6123 " \" string literals\",\n" 6124 " and, other, parameters);"); 6125 EXPECT_EQ("fun + \"1243\" /* comment */\n" 6126 " \"5678\";", 6127 format("fun + \"1243\" /* comment */\n" 6128 " \"5678\";", 6129 getLLVMStyleWithColumns(28))); 6130 EXPECT_EQ( 6131 "aaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 6132 " \"aaaaaaaaaaaaaaaaaaaaa\"\n" 6133 " \"aaaaaaaaaaaaaaaa\";", 6134 format("aaaaaa =" 6135 "\"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa " 6136 "aaaaaaaaaaaaaaaaaaaaa\" " 6137 "\"aaaaaaaaaaaaaaaa\";")); 6138 verifyFormat("a = a + \"a\"\n" 6139 " \"a\"\n" 6140 " \"a\";"); 6141 verifyFormat("f(\"a\", \"b\"\n" 6142 " \"c\");"); 6143 6144 verifyFormat( 6145 "#define LL_FORMAT \"ll\"\n" 6146 "printf(\"aaaaa: %d, bbbbbb: %\" LL_FORMAT \"d, cccccccc: %\" LL_FORMAT\n" 6147 " \"d, ddddddddd: %\" LL_FORMAT \"d\");"); 6148 6149 verifyFormat("#define A(X) \\\n" 6150 " \"aaaaa\" #X \"bbbbbb\" \\\n" 6151 " \"ccccc\"", 6152 getLLVMStyleWithColumns(23)); 6153 verifyFormat("#define A \"def\"\n" 6154 "f(\"abc\" A \"ghi\"\n" 6155 " \"jkl\");"); 6156 6157 verifyFormat("f(L\"a\"\n" 6158 " L\"b\");"); 6159 verifyFormat("#define A(X) \\\n" 6160 " L\"aaaaa\" #X L\"bbbbbb\" \\\n" 6161 " L\"ccccc\"", 6162 getLLVMStyleWithColumns(25)); 6163 6164 verifyFormat("f(@\"a\"\n" 6165 " @\"b\");"); 6166 verifyFormat("NSString s = @\"a\"\n" 6167 " @\"b\"\n" 6168 " @\"c\";"); 6169 verifyFormat("NSString s = @\"a\"\n" 6170 " \"b\"\n" 6171 " \"c\";"); 6172 } 6173 6174 TEST_F(FormatTest, ReturnTypeBreakingStyle) { 6175 FormatStyle Style = getLLVMStyle(); 6176 // No declarations or definitions should be moved to own line. 6177 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_None; 6178 verifyFormat("class A {\n" 6179 " int f() { return 1; }\n" 6180 " int g();\n" 6181 "};\n" 6182 "int f() { return 1; }\n" 6183 "int g();\n", 6184 Style); 6185 6186 // All declarations and definitions should have the return type moved to its 6187 // own 6188 // line. 6189 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All; 6190 verifyFormat("class E {\n" 6191 " int\n" 6192 " f() {\n" 6193 " return 1;\n" 6194 " }\n" 6195 " int\n" 6196 " g();\n" 6197 "};\n" 6198 "int\n" 6199 "f() {\n" 6200 " return 1;\n" 6201 "}\n" 6202 "int\n" 6203 "g();\n", 6204 Style); 6205 6206 // Top-level definitions, and no kinds of declarations should have the 6207 // return type moved to its own line. 6208 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevelDefinitions; 6209 verifyFormat("class B {\n" 6210 " int f() { return 1; }\n" 6211 " int g();\n" 6212 "};\n" 6213 "int\n" 6214 "f() {\n" 6215 " return 1;\n" 6216 "}\n" 6217 "int g();\n", 6218 Style); 6219 6220 // Top-level definitions and declarations should have the return type moved 6221 // to its own line. 6222 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevel; 6223 verifyFormat("class C {\n" 6224 " int f() { return 1; }\n" 6225 " int g();\n" 6226 "};\n" 6227 "int\n" 6228 "f() {\n" 6229 " return 1;\n" 6230 "}\n" 6231 "int\n" 6232 "g();\n", 6233 Style); 6234 6235 // All definitions should have the return type moved to its own line, but no 6236 // kinds of declarations. 6237 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions; 6238 verifyFormat("class D {\n" 6239 " int\n" 6240 " f() {\n" 6241 " return 1;\n" 6242 " }\n" 6243 " int g();\n" 6244 "};\n" 6245 "int\n" 6246 "f() {\n" 6247 " return 1;\n" 6248 "}\n" 6249 "int g();\n", 6250 Style); 6251 verifyFormat("const char *\n" 6252 "f(void) {\n" // Break here. 6253 " return \"\";\n" 6254 "}\n" 6255 "const char *bar(void);\n", // No break here. 6256 Style); 6257 verifyFormat("template <class T>\n" 6258 "T *\n" 6259 "f(T &c) {\n" // Break here. 6260 " return NULL;\n" 6261 "}\n" 6262 "template <class T> T *f(T &c);\n", // No break here. 6263 Style); 6264 verifyFormat("class C {\n" 6265 " int\n" 6266 " operator+() {\n" 6267 " return 1;\n" 6268 " }\n" 6269 " int\n" 6270 " operator()() {\n" 6271 " return 1;\n" 6272 " }\n" 6273 "};\n", 6274 Style); 6275 verifyFormat("void\n" 6276 "A::operator()() {}\n" 6277 "void\n" 6278 "A::operator>>() {}\n" 6279 "void\n" 6280 "A::operator+() {}\n" 6281 "void\n" 6282 "A::operator*() {}\n" 6283 "void\n" 6284 "A::operator->() {}\n" 6285 "void\n" 6286 "A::operator void *() {}\n" 6287 "void\n" 6288 "A::operator void &() {}\n" 6289 "void\n" 6290 "A::operator void &&() {}\n" 6291 "void\n" 6292 "A::operator char *() {}\n" 6293 "void\n" 6294 "A::operator[]() {}\n" 6295 "void\n" 6296 "A::operator!() {}\n" 6297 "void\n" 6298 "A::operator**() {}\n" 6299 "void\n" 6300 "A::operator<Foo> *() {}\n" 6301 "void\n" 6302 "A::operator<Foo> **() {}\n" 6303 "void\n" 6304 "A::operator<Foo> &() {}\n" 6305 "void\n" 6306 "A::operator void **() {}\n", 6307 Style); 6308 verifyFormat("constexpr auto\n" 6309 "operator()() const -> reference {}\n" 6310 "constexpr auto\n" 6311 "operator>>() const -> reference {}\n" 6312 "constexpr auto\n" 6313 "operator+() const -> reference {}\n" 6314 "constexpr auto\n" 6315 "operator*() const -> reference {}\n" 6316 "constexpr auto\n" 6317 "operator->() const -> reference {}\n" 6318 "constexpr auto\n" 6319 "operator++() const -> reference {}\n" 6320 "constexpr auto\n" 6321 "operator void *() const -> reference {}\n" 6322 "constexpr auto\n" 6323 "operator void **() const -> reference {}\n" 6324 "constexpr auto\n" 6325 "operator void *() const -> reference {}\n" 6326 "constexpr auto\n" 6327 "operator void &() const -> reference {}\n" 6328 "constexpr auto\n" 6329 "operator void &&() const -> reference {}\n" 6330 "constexpr auto\n" 6331 "operator char *() const -> reference {}\n" 6332 "constexpr auto\n" 6333 "operator!() const -> reference {}\n" 6334 "constexpr auto\n" 6335 "operator[]() const -> reference {}\n", 6336 Style); 6337 verifyFormat("void *operator new(std::size_t s);", // No break here. 6338 Style); 6339 verifyFormat("void *\n" 6340 "operator new(std::size_t s) {}", 6341 Style); 6342 verifyFormat("void *\n" 6343 "operator delete[](void *ptr) {}", 6344 Style); 6345 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 6346 verifyFormat("const char *\n" 6347 "f(void)\n" // Break here. 6348 "{\n" 6349 " return \"\";\n" 6350 "}\n" 6351 "const char *bar(void);\n", // No break here. 6352 Style); 6353 verifyFormat("template <class T>\n" 6354 "T *\n" // Problem here: no line break 6355 "f(T &c)\n" // Break here. 6356 "{\n" 6357 " return NULL;\n" 6358 "}\n" 6359 "template <class T> T *f(T &c);\n", // No break here. 6360 Style); 6361 verifyFormat("int\n" 6362 "foo(A<bool> a)\n" 6363 "{\n" 6364 " return a;\n" 6365 "}\n", 6366 Style); 6367 verifyFormat("int\n" 6368 "foo(A<8> a)\n" 6369 "{\n" 6370 " return a;\n" 6371 "}\n", 6372 Style); 6373 verifyFormat("int\n" 6374 "foo(A<B<bool>, 8> a)\n" 6375 "{\n" 6376 " return a;\n" 6377 "}\n", 6378 Style); 6379 verifyFormat("int\n" 6380 "foo(A<B<8>, bool> a)\n" 6381 "{\n" 6382 " return a;\n" 6383 "}\n", 6384 Style); 6385 verifyFormat("int\n" 6386 "foo(A<B<bool>, bool> a)\n" 6387 "{\n" 6388 " return a;\n" 6389 "}\n", 6390 Style); 6391 verifyFormat("int\n" 6392 "foo(A<B<8>, 8> a)\n" 6393 "{\n" 6394 " return a;\n" 6395 "}\n", 6396 Style); 6397 6398 Style = getGNUStyle(); 6399 6400 // Test for comments at the end of function declarations. 6401 verifyFormat("void\n" 6402 "foo (int a, /*abc*/ int b) // def\n" 6403 "{\n" 6404 "}\n", 6405 Style); 6406 6407 verifyFormat("void\n" 6408 "foo (int a, /* abc */ int b) /* def */\n" 6409 "{\n" 6410 "}\n", 6411 Style); 6412 6413 // Definitions that should not break after return type 6414 verifyFormat("void foo (int a, int b); // def\n", Style); 6415 verifyFormat("void foo (int a, int b); /* def */\n", Style); 6416 verifyFormat("void foo (int a, int b);\n", Style); 6417 } 6418 6419 TEST_F(FormatTest, AlwaysBreakBeforeMultilineStrings) { 6420 FormatStyle NoBreak = getLLVMStyle(); 6421 NoBreak.AlwaysBreakBeforeMultilineStrings = false; 6422 FormatStyle Break = getLLVMStyle(); 6423 Break.AlwaysBreakBeforeMultilineStrings = true; 6424 verifyFormat("aaaa = \"bbbb\"\n" 6425 " \"cccc\";", 6426 NoBreak); 6427 verifyFormat("aaaa =\n" 6428 " \"bbbb\"\n" 6429 " \"cccc\";", 6430 Break); 6431 verifyFormat("aaaa(\"bbbb\"\n" 6432 " \"cccc\");", 6433 NoBreak); 6434 verifyFormat("aaaa(\n" 6435 " \"bbbb\"\n" 6436 " \"cccc\");", 6437 Break); 6438 verifyFormat("aaaa(qqq, \"bbbb\"\n" 6439 " \"cccc\");", 6440 NoBreak); 6441 verifyFormat("aaaa(qqq,\n" 6442 " \"bbbb\"\n" 6443 " \"cccc\");", 6444 Break); 6445 verifyFormat("aaaa(qqq,\n" 6446 " L\"bbbb\"\n" 6447 " L\"cccc\");", 6448 Break); 6449 verifyFormat("aaaaa(aaaaaa, aaaaaaa(\"aaaa\"\n" 6450 " \"bbbb\"));", 6451 Break); 6452 verifyFormat("string s = someFunction(\n" 6453 " \"abc\"\n" 6454 " \"abc\");", 6455 Break); 6456 6457 // As we break before unary operators, breaking right after them is bad. 6458 verifyFormat("string foo = abc ? \"x\"\n" 6459 " \"blah blah blah blah blah blah\"\n" 6460 " : \"y\";", 6461 Break); 6462 6463 // Don't break if there is no column gain. 6464 verifyFormat("f(\"aaaa\"\n" 6465 " \"bbbb\");", 6466 Break); 6467 6468 // Treat literals with escaped newlines like multi-line string literals. 6469 EXPECT_EQ("x = \"a\\\n" 6470 "b\\\n" 6471 "c\";", 6472 format("x = \"a\\\n" 6473 "b\\\n" 6474 "c\";", 6475 NoBreak)); 6476 EXPECT_EQ("xxxx =\n" 6477 " \"a\\\n" 6478 "b\\\n" 6479 "c\";", 6480 format("xxxx = \"a\\\n" 6481 "b\\\n" 6482 "c\";", 6483 Break)); 6484 6485 EXPECT_EQ("NSString *const kString =\n" 6486 " @\"aaaa\"\n" 6487 " @\"bbbb\";", 6488 format("NSString *const kString = @\"aaaa\"\n" 6489 "@\"bbbb\";", 6490 Break)); 6491 6492 Break.ColumnLimit = 0; 6493 verifyFormat("const char *hello = \"hello llvm\";", Break); 6494 } 6495 6496 TEST_F(FormatTest, AlignsPipes) { 6497 verifyFormat( 6498 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6499 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6500 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6501 verifyFormat( 6502 "aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa\n" 6503 " << aaaaaaaaaaaaaaaaaaaa;"); 6504 verifyFormat( 6505 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6506 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6507 verifyFormat( 6508 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 6509 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6510 verifyFormat( 6511 "llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"\n" 6512 " \"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\"\n" 6513 " << \"ccccccccccccccccccccccccccccccccccccccccccccccccc\";"); 6514 verifyFormat( 6515 "aaaaaaaa << (aaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6516 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6517 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6518 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6519 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6520 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6521 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 6522 verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaaaaaa: \"\n" 6523 " << aaaaaaaaaaaaaaaaa(aaaaaaaa, aaaaaaaaaaa);"); 6524 verifyFormat( 6525 "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6526 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6527 verifyFormat( 6528 "auto Diag = diag() << aaaaaaaaaaaaaaaa(aaaaaaaaaaaa, aaaaaaaaaaaaa,\n" 6529 " aaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6530 6531 verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \"\n" 6532 " << aaaaaaaa.aaaaaaaaaaaa(aaa)->aaaaaaaaaaaaaa();"); 6533 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6534 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6535 " aaaaaaaaaaaaaaaaaaaaa)\n" 6536 " << aaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6537 verifyFormat("LOG_IF(aaa == //\n" 6538 " bbb)\n" 6539 " << a << b;"); 6540 6541 // But sometimes, breaking before the first "<<" is desirable. 6542 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n" 6543 " << aaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaa);"); 6544 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbb)\n" 6545 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6546 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6547 verifyFormat("SemaRef.Diag(Loc, diag::note_for_range_begin_end)\n" 6548 " << BEF << IsTemplate << Description << E->getType();"); 6549 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n" 6550 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6551 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6552 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n" 6553 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6554 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6555 " << aaa;"); 6556 6557 verifyFormat( 6558 "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6559 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6560 6561 // Incomplete string literal. 6562 EXPECT_EQ("llvm::errs() << \"\n" 6563 " << a;", 6564 format("llvm::errs() << \"\n<<a;")); 6565 6566 verifyFormat("void f() {\n" 6567 " CHECK_EQ(aaaa, (*bbbbbbbbb)->cccccc)\n" 6568 " << \"qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\";\n" 6569 "}"); 6570 6571 // Handle 'endl'. 6572 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << endl\n" 6573 " << bbbbbbbbbbbbbbbbbbbbbb << endl;"); 6574 verifyFormat("llvm::errs() << endl << bbbbbbbbbbbbbbbbbbbbbb << endl;"); 6575 6576 // Handle '\n'. 6577 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \"\\n\"\n" 6578 " << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";"); 6579 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \'\\n\'\n" 6580 " << bbbbbbbbbbbbbbbbbbbbbb << \'\\n\';"); 6581 verifyFormat("llvm::errs() << aaaa << \"aaaaaaaaaaaaaaaaaa\\n\"\n" 6582 " << bbbb << \"bbbbbbbbbbbbbbbbbb\\n\";"); 6583 verifyFormat("llvm::errs() << \"\\n\" << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";"); 6584 } 6585 6586 TEST_F(FormatTest, KeepStringLabelValuePairsOnALine) { 6587 verifyFormat("return out << \"somepacket = {\\n\"\n" 6588 " << \" aaaaaa = \" << pkt.aaaaaa << \"\\n\"\n" 6589 " << \" bbbb = \" << pkt.bbbb << \"\\n\"\n" 6590 " << \" cccccc = \" << pkt.cccccc << \"\\n\"\n" 6591 " << \" ddd = [\" << pkt.ddd << \"]\\n\"\n" 6592 " << \"}\";"); 6593 6594 verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n" 6595 " << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n" 6596 " << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa;"); 6597 verifyFormat( 6598 "llvm::outs() << \"aaaaaaaaaaaaaaaaa = \" << aaaaaaaaaaaaaaaaa\n" 6599 " << \"bbbbbbbbbbbbbbbbb = \" << bbbbbbbbbbbbbbbbb\n" 6600 " << \"ccccccccccccccccc = \" << ccccccccccccccccc\n" 6601 " << \"ddddddddddddddddd = \" << ddddddddddddddddd\n" 6602 " << \"eeeeeeeeeeeeeeeee = \" << eeeeeeeeeeeeeeeee;"); 6603 verifyFormat("llvm::outs() << aaaaaaaaaaaaaaaaaaaaaaaa << \"=\"\n" 6604 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 6605 verifyFormat( 6606 "void f() {\n" 6607 " llvm::outs() << \"aaaaaaaaaaaaaaaaaaaa: \"\n" 6608 " << aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 6609 "}"); 6610 6611 // Breaking before the first "<<" is generally not desirable. 6612 verifyFormat( 6613 "llvm::errs()\n" 6614 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6615 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6616 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6617 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 6618 getLLVMStyleWithColumns(70)); 6619 verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaa: \"\n" 6620 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6621 " << \"aaaaaaaaaaaaaaaaaaa: \"\n" 6622 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6623 " << \"aaaaaaaaaaaaaaaaaaa: \"\n" 6624 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 6625 getLLVMStyleWithColumns(70)); 6626 6627 verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n" 6628 " \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n" 6629 " \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa;"); 6630 verifyFormat("string v = StrCat(\"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n" 6631 " \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n" 6632 " \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa);"); 6633 verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" +\n" 6634 " (aaaa + aaaa);", 6635 getLLVMStyleWithColumns(40)); 6636 verifyFormat("string v = StrCat(\"aaaaaaaaaaaa: \" +\n" 6637 " (aaaaaaa + aaaaa));", 6638 getLLVMStyleWithColumns(40)); 6639 verifyFormat( 6640 "string v = StrCat(\"aaaaaaaaaaaaaaaaaaaaaaaaaaa: \",\n" 6641 " SomeFunction(aaaaaaaaaaaa, aaaaaaaa.aaaaaaa),\n" 6642 " bbbbbbbbbbbbbbbbbbbbbbb);"); 6643 } 6644 6645 TEST_F(FormatTest, UnderstandsEquals) { 6646 verifyFormat( 6647 "aaaaaaaaaaaaaaaaa =\n" 6648 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6649 verifyFormat( 6650 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 6651 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 6652 verifyFormat( 6653 "if (a) {\n" 6654 " f();\n" 6655 "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 6656 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 6657 "}"); 6658 6659 verifyFormat("if (int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 6660 " 100000000 + 10000000) {\n}"); 6661 } 6662 6663 TEST_F(FormatTest, WrapsAtFunctionCallsIfNecessary) { 6664 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n" 6665 " .looooooooooooooooooooooooooooooooooooooongFunction();"); 6666 6667 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n" 6668 " ->looooooooooooooooooooooooooooooooooooooongFunction();"); 6669 6670 verifyFormat( 6671 "LooooooooooooooooooooooooooooooooongObject->shortFunction(Parameter1,\n" 6672 " Parameter2);"); 6673 6674 verifyFormat( 6675 "ShortObject->shortFunction(\n" 6676 " LooooooooooooooooooooooooooooooooooooooooooooooongParameter1,\n" 6677 " LooooooooooooooooooooooooooooooooooooooooooooooongParameter2);"); 6678 6679 verifyFormat("loooooooooooooongFunction(\n" 6680 " LoooooooooooooongObject->looooooooooooooooongFunction());"); 6681 6682 verifyFormat( 6683 "function(LoooooooooooooooooooooooooooooooooooongObject\n" 6684 " ->loooooooooooooooooooooooooooooooooooooooongFunction());"); 6685 6686 verifyFormat("EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n" 6687 " .WillRepeatedly(Return(SomeValue));"); 6688 verifyFormat("void f() {\n" 6689 " EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n" 6690 " .Times(2)\n" 6691 " .WillRepeatedly(Return(SomeValue));\n" 6692 "}"); 6693 verifyFormat("SomeMap[std::pair(aaaaaaaaaaaa, bbbbbbbbbbbbbbb)].insert(\n" 6694 " ccccccccccccccccccccccc);"); 6695 verifyFormat("aaaaa(aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6696 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6697 " .aaaaa(aaaaa),\n" 6698 " aaaaaaaaaaaaaaaaaaaaa);"); 6699 verifyFormat("void f() {\n" 6700 " aaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6701 " aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa)->aaaaaaaaa());\n" 6702 "}"); 6703 verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6704 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6705 " .aaaaaaaaaaaaaaa(aa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6706 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6707 " aaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 6708 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6709 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6710 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6711 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()) {\n" 6712 "}"); 6713 6714 // Here, it is not necessary to wrap at "." or "->". 6715 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaa) ||\n" 6716 " aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 6717 verifyFormat( 6718 "aaaaaaaaaaa->aaaaaaaaa(\n" 6719 " aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6720 " aaaaaaaaaaaaaaaaaa->aaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa));\n"); 6721 6722 verifyFormat( 6723 "aaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6724 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa().aaaaaaaaaaaaaaaaa());"); 6725 verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() *\n" 6726 " aaaaaaaaa()->aaaaaa()->aaaaa());"); 6727 verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() ||\n" 6728 " aaaaaaaaa()->aaaaaa()->aaaaa());"); 6729 6730 verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6731 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6732 " .a();"); 6733 6734 FormatStyle NoBinPacking = getLLVMStyle(); 6735 NoBinPacking.BinPackParameters = false; 6736 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n" 6737 " .aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n" 6738 " .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa,\n" 6739 " aaaaaaaaaaaaaaaaaaa,\n" 6740 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 6741 NoBinPacking); 6742 6743 // If there is a subsequent call, change to hanging indentation. 6744 verifyFormat( 6745 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6746 " aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa))\n" 6747 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6748 verifyFormat( 6749 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6750 " aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa));"); 6751 verifyFormat("aaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6752 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6753 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6754 verifyFormat("aaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6755 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6756 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());"); 6757 } 6758 6759 TEST_F(FormatTest, WrapsTemplateDeclarations) { 6760 verifyFormat("template <typename T>\n" 6761 "virtual void loooooooooooongFunction(int Param1, int Param2);"); 6762 verifyFormat("template <typename T>\n" 6763 "// T should be one of {A, B}.\n" 6764 "virtual void loooooooooooongFunction(int Param1, int Param2);"); 6765 verifyFormat( 6766 "template <typename T>\n" 6767 "using comment_to_xml_conversion = comment_to_xml_conversion<T, int>;"); 6768 verifyFormat("template <typename T>\n" 6769 "void f(int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram1,\n" 6770 " int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram2);"); 6771 verifyFormat( 6772 "template <typename T>\n" 6773 "void looooooooooooooooooooongFunction(int Paaaaaaaaaaaaaaaaaaaaram1,\n" 6774 " int Paaaaaaaaaaaaaaaaaaaaram2);"); 6775 verifyFormat( 6776 "template <typename T>\n" 6777 "aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaa,\n" 6778 " aaaaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaa,\n" 6779 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6780 verifyFormat("template <typename T>\n" 6781 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6782 " int aaaaaaaaaaaaaaaaaaaaaa);"); 6783 verifyFormat( 6784 "template <typename T1, typename T2 = char, typename T3 = char,\n" 6785 " typename T4 = char>\n" 6786 "void f();"); 6787 verifyFormat("template <typename aaaaaaaaaaa, typename bbbbbbbbbbbbb,\n" 6788 " template <typename> class cccccccccccccccccccccc,\n" 6789 " typename ddddddddddddd>\n" 6790 "class C {};"); 6791 verifyFormat( 6792 "aaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>(\n" 6793 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6794 6795 verifyFormat("void f() {\n" 6796 " a<aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaa>(\n" 6797 " a(aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));\n" 6798 "}"); 6799 6800 verifyFormat("template <typename T> class C {};"); 6801 verifyFormat("template <typename T> void f();"); 6802 verifyFormat("template <typename T> void f() {}"); 6803 verifyFormat( 6804 "aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n" 6805 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6806 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> *aaaa =\n" 6807 " new aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n" 6808 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6809 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>(\n" 6810 " bbbbbbbbbbbbbbbbbbbbbbbb);", 6811 getLLVMStyleWithColumns(72)); 6812 EXPECT_EQ("static_cast<A< //\n" 6813 " B> *>(\n" 6814 "\n" 6815 ");", 6816 format("static_cast<A<//\n" 6817 " B>*>(\n" 6818 "\n" 6819 " );")); 6820 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6821 " const typename aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaa);"); 6822 6823 FormatStyle AlwaysBreak = getLLVMStyle(); 6824 AlwaysBreak.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes; 6825 verifyFormat("template <typename T>\nclass C {};", AlwaysBreak); 6826 verifyFormat("template <typename T>\nvoid f();", AlwaysBreak); 6827 verifyFormat("template <typename T>\nvoid f() {}", AlwaysBreak); 6828 verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6829 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n" 6830 " ccccccccccccccccccccccccccccccccccccccccccccccc);"); 6831 verifyFormat("template <template <typename> class Fooooooo,\n" 6832 " template <typename> class Baaaaaaar>\n" 6833 "struct C {};", 6834 AlwaysBreak); 6835 verifyFormat("template <typename T> // T can be A, B or C.\n" 6836 "struct C {};", 6837 AlwaysBreak); 6838 verifyFormat("template <enum E> class A {\n" 6839 "public:\n" 6840 " E *f();\n" 6841 "};"); 6842 6843 FormatStyle NeverBreak = getLLVMStyle(); 6844 NeverBreak.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_No; 6845 verifyFormat("template <typename T> class C {};", NeverBreak); 6846 verifyFormat("template <typename T> void f();", NeverBreak); 6847 verifyFormat("template <typename T> void f() {}", NeverBreak); 6848 verifyFormat("template <typename T>\nvoid foo(aaaaaaaaaaaaaaaaaaaaaaaaaa " 6849 "bbbbbbbbbbbbbbbbbbbb) {}", 6850 NeverBreak); 6851 verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6852 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n" 6853 " ccccccccccccccccccccccccccccccccccccccccccccccc);", 6854 NeverBreak); 6855 verifyFormat("template <template <typename> class Fooooooo,\n" 6856 " template <typename> class Baaaaaaar>\n" 6857 "struct C {};", 6858 NeverBreak); 6859 verifyFormat("template <typename T> // T can be A, B or C.\n" 6860 "struct C {};", 6861 NeverBreak); 6862 verifyFormat("template <enum E> class A {\n" 6863 "public:\n" 6864 " E *f();\n" 6865 "};", 6866 NeverBreak); 6867 NeverBreak.PenaltyBreakTemplateDeclaration = 100; 6868 verifyFormat("template <typename T> void\nfoo(aaaaaaaaaaaaaaaaaaaaaaaaaa " 6869 "bbbbbbbbbbbbbbbbbbbb) {}", 6870 NeverBreak); 6871 } 6872 6873 TEST_F(FormatTest, WrapsTemplateDeclarationsWithComments) { 6874 FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp); 6875 Style.ColumnLimit = 60; 6876 EXPECT_EQ("// Baseline - no comments.\n" 6877 "template <\n" 6878 " typename aaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbbb>::value>\n" 6879 "void f() {}", 6880 format("// Baseline - no comments.\n" 6881 "template <\n" 6882 " typename aaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbbb>::value>\n" 6883 "void f() {}", 6884 Style)); 6885 6886 EXPECT_EQ("template <\n" 6887 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 6888 "void f() {}", 6889 format("template <\n" 6890 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 6891 "void f() {}", 6892 Style)); 6893 6894 EXPECT_EQ( 6895 "template <\n" 6896 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> /* line */\n" 6897 "void f() {}", 6898 format("template <typename aaaaaaaaaa<bbbbbbbbbbbb>::value> /* line */\n" 6899 "void f() {}", 6900 Style)); 6901 6902 EXPECT_EQ( 6903 "template <\n" 6904 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 6905 " // multiline\n" 6906 "void f() {}", 6907 format("template <\n" 6908 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 6909 " // multiline\n" 6910 "void f() {}", 6911 Style)); 6912 6913 EXPECT_EQ( 6914 "template <typename aaaaaaaaaa<\n" 6915 " bbbbbbbbbbbb>::value> // trailing loooong\n" 6916 "void f() {}", 6917 format( 6918 "template <\n" 6919 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing loooong\n" 6920 "void f() {}", 6921 Style)); 6922 } 6923 6924 TEST_F(FormatTest, WrapsTemplateParameters) { 6925 FormatStyle Style = getLLVMStyle(); 6926 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 6927 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 6928 verifyFormat( 6929 "template <typename... a> struct q {};\n" 6930 "extern q<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n" 6931 " aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n" 6932 " y;", 6933 Style); 6934 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 6935 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 6936 verifyFormat( 6937 "template <typename... a> struct r {};\n" 6938 "extern r<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n" 6939 " aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n" 6940 " y;", 6941 Style); 6942 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 6943 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 6944 verifyFormat("template <typename... a> struct s {};\n" 6945 "extern s<\n" 6946 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, " 6947 "aaaaaaaaaaaaaaaaaaaaaa,\n" 6948 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, " 6949 "aaaaaaaaaaaaaaaaaaaaaa>\n" 6950 " y;", 6951 Style); 6952 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 6953 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 6954 verifyFormat("template <typename... a> struct t {};\n" 6955 "extern t<\n" 6956 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, " 6957 "aaaaaaaaaaaaaaaaaaaaaa,\n" 6958 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, " 6959 "aaaaaaaaaaaaaaaaaaaaaa>\n" 6960 " y;", 6961 Style); 6962 } 6963 6964 TEST_F(FormatTest, WrapsAtNestedNameSpecifiers) { 6965 verifyFormat( 6966 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6967 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6968 verifyFormat( 6969 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6970 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6971 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());"); 6972 6973 // FIXME: Should we have the extra indent after the second break? 6974 verifyFormat( 6975 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6976 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6977 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6978 6979 verifyFormat( 6980 "aaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb::\n" 6981 " cccccccccccccccccccccccccccccccccccccccccccccc());"); 6982 6983 // Breaking at nested name specifiers is generally not desirable. 6984 verifyFormat( 6985 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6986 " aaaaaaaaaaaaaaaaaaaaaaa);"); 6987 6988 verifyFormat("aaaaaaaaaaaaaaaaaa(aaaaaaaa,\n" 6989 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6990 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6991 " aaaaaaaaaaaaaaaaaaaaa);", 6992 getLLVMStyleWithColumns(74)); 6993 6994 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6995 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6996 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6997 } 6998 6999 TEST_F(FormatTest, UnderstandsTemplateParameters) { 7000 verifyFormat("A<int> a;"); 7001 verifyFormat("A<A<A<int>>> a;"); 7002 verifyFormat("A<A<A<int, 2>, 3>, 4> a;"); 7003 verifyFormat("bool x = a < 1 || 2 > a;"); 7004 verifyFormat("bool x = 5 < f<int>();"); 7005 verifyFormat("bool x = f<int>() > 5;"); 7006 verifyFormat("bool x = 5 < a<int>::x;"); 7007 verifyFormat("bool x = a < 4 ? a > 2 : false;"); 7008 verifyFormat("bool x = f() ? a < 2 : a > 2;"); 7009 7010 verifyGoogleFormat("A<A<int>> a;"); 7011 verifyGoogleFormat("A<A<A<int>>> a;"); 7012 verifyGoogleFormat("A<A<A<A<int>>>> a;"); 7013 verifyGoogleFormat("A<A<int> > a;"); 7014 verifyGoogleFormat("A<A<A<int> > > a;"); 7015 verifyGoogleFormat("A<A<A<A<int> > > > a;"); 7016 verifyGoogleFormat("A<::A<int>> a;"); 7017 verifyGoogleFormat("A<::A> a;"); 7018 verifyGoogleFormat("A< ::A> a;"); 7019 verifyGoogleFormat("A< ::A<int> > a;"); 7020 EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A> >> a;", getGoogleStyle())); 7021 EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A>> > a;", getGoogleStyle())); 7022 EXPECT_EQ("A<::A<int>> a;", format("A< ::A<int>> a;", getGoogleStyle())); 7023 EXPECT_EQ("A<::A<int>> a;", format("A<::A<int> > a;", getGoogleStyle())); 7024 EXPECT_EQ("auto x = [] { A<A<A<A>>> a; };", 7025 format("auto x=[]{A<A<A<A> >> a;};", getGoogleStyle())); 7026 7027 verifyFormat("A<A<int>> a;", getChromiumStyle(FormatStyle::LK_Cpp)); 7028 7029 // template closer followed by a token that starts with > or = 7030 verifyFormat("bool b = a<1> > 1;"); 7031 verifyFormat("bool b = a<1> >= 1;"); 7032 verifyFormat("int i = a<1> >> 1;"); 7033 FormatStyle Style = getLLVMStyle(); 7034 Style.SpaceBeforeAssignmentOperators = false; 7035 verifyFormat("bool b= a<1> == 1;", Style); 7036 verifyFormat("a<int> = 1;", Style); 7037 verifyFormat("a<int> >>= 1;", Style); 7038 7039 verifyFormat("test >> a >> b;"); 7040 verifyFormat("test << a >> b;"); 7041 7042 verifyFormat("f<int>();"); 7043 verifyFormat("template <typename T> void f() {}"); 7044 verifyFormat("struct A<std::enable_if<sizeof(T2) < sizeof(int32)>::type>;"); 7045 verifyFormat("struct A<std::enable_if<sizeof(T2) ? sizeof(int32) : " 7046 "sizeof(char)>::type>;"); 7047 verifyFormat("template <class T> struct S<std::is_arithmetic<T>{}> {};"); 7048 verifyFormat("f(a.operator()<A>());"); 7049 verifyFormat("f(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7050 " .template operator()<A>());", 7051 getLLVMStyleWithColumns(35)); 7052 7053 // Not template parameters. 7054 verifyFormat("return a < b && c > d;"); 7055 verifyFormat("void f() {\n" 7056 " while (a < b && c > d) {\n" 7057 " }\n" 7058 "}"); 7059 verifyFormat("template <typename... Types>\n" 7060 "typename enable_if<0 < sizeof...(Types)>::type Foo() {}"); 7061 7062 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7063 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa >> aaaaa);", 7064 getLLVMStyleWithColumns(60)); 7065 verifyFormat("static_assert(is_convertible<A &&, B>::value, \"AAA\");"); 7066 verifyFormat("Constructor(A... a) : a_(X<A>{std::forward<A>(a)}...) {}"); 7067 verifyFormat("< < < < < < < < < < < < < < < < < < < < < < < < < < < < < <"); 7068 } 7069 7070 TEST_F(FormatTest, BitshiftOperatorWidth) { 7071 EXPECT_EQ("int a = 1 << 2; /* foo\n" 7072 " bar */", 7073 format("int a=1<<2; /* foo\n" 7074 " bar */")); 7075 7076 EXPECT_EQ("int b = 256 >> 1; /* foo\n" 7077 " bar */", 7078 format("int b =256>>1 ; /* foo\n" 7079 " bar */")); 7080 } 7081 7082 TEST_F(FormatTest, UnderstandsBinaryOperators) { 7083 verifyFormat("COMPARE(a, ==, b);"); 7084 verifyFormat("auto s = sizeof...(Ts) - 1;"); 7085 } 7086 7087 TEST_F(FormatTest, UnderstandsPointersToMembers) { 7088 verifyFormat("int A::*x;"); 7089 verifyFormat("int (S::*func)(void *);"); 7090 verifyFormat("void f() { int (S::*func)(void *); }"); 7091 verifyFormat("typedef bool *(Class::*Member)() const;"); 7092 verifyFormat("void f() {\n" 7093 " (a->*f)();\n" 7094 " a->*x;\n" 7095 " (a.*f)();\n" 7096 " ((*a).*f)();\n" 7097 " a.*x;\n" 7098 "}"); 7099 verifyFormat("void f() {\n" 7100 " (a->*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n" 7101 " aaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);\n" 7102 "}"); 7103 verifyFormat( 7104 "(aaaaaaaaaa->*bbbbbbb)(\n" 7105 " aaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 7106 FormatStyle Style = getLLVMStyle(); 7107 Style.PointerAlignment = FormatStyle::PAS_Left; 7108 verifyFormat("typedef bool* (Class::*Member)() const;", Style); 7109 } 7110 7111 TEST_F(FormatTest, UnderstandsUnaryOperators) { 7112 verifyFormat("int a = -2;"); 7113 verifyFormat("f(-1, -2, -3);"); 7114 verifyFormat("a[-1] = 5;"); 7115 verifyFormat("int a = 5 + -2;"); 7116 verifyFormat("if (i == -1) {\n}"); 7117 verifyFormat("if (i != -1) {\n}"); 7118 verifyFormat("if (i > -1) {\n}"); 7119 verifyFormat("if (i < -1) {\n}"); 7120 verifyFormat("++(a->f());"); 7121 verifyFormat("--(a->f());"); 7122 verifyFormat("(a->f())++;"); 7123 verifyFormat("a[42]++;"); 7124 verifyFormat("if (!(a->f())) {\n}"); 7125 verifyFormat("if (!+i) {\n}"); 7126 verifyFormat("~&a;"); 7127 7128 verifyFormat("a-- > b;"); 7129 verifyFormat("b ? -a : c;"); 7130 verifyFormat("n * sizeof char16;"); 7131 verifyFormat("n * alignof char16;", getGoogleStyle()); 7132 verifyFormat("sizeof(char);"); 7133 verifyFormat("alignof(char);", getGoogleStyle()); 7134 7135 verifyFormat("return -1;"); 7136 verifyFormat("throw -1;"); 7137 verifyFormat("switch (a) {\n" 7138 "case -1:\n" 7139 " break;\n" 7140 "}"); 7141 verifyFormat("#define X -1"); 7142 verifyFormat("#define X -kConstant"); 7143 7144 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {-5, +3};"); 7145 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {+5, -3};"); 7146 7147 verifyFormat("int a = /* confusing comment */ -1;"); 7148 // FIXME: The space after 'i' is wrong, but hopefully, this is a rare case. 7149 verifyFormat("int a = i /* confusing comment */++;"); 7150 7151 verifyFormat("co_yield -1;"); 7152 verifyFormat("co_return -1;"); 7153 } 7154 7155 TEST_F(FormatTest, DoesNotIndentRelativeToUnaryOperators) { 7156 verifyFormat("if (!aaaaaaaaaa( // break\n" 7157 " aaaaa)) {\n" 7158 "}"); 7159 verifyFormat("aaaaaaaaaa(!aaaaaaaaaa( // break\n" 7160 " aaaaa));"); 7161 verifyFormat("*aaa = aaaaaaa( // break\n" 7162 " bbbbbb);"); 7163 } 7164 7165 TEST_F(FormatTest, UnderstandsOverloadedOperators) { 7166 verifyFormat("bool operator<();"); 7167 verifyFormat("bool operator>();"); 7168 verifyFormat("bool operator=();"); 7169 verifyFormat("bool operator==();"); 7170 verifyFormat("bool operator!=();"); 7171 verifyFormat("int operator+();"); 7172 verifyFormat("int operator++();"); 7173 verifyFormat("int operator++(int) volatile noexcept;"); 7174 verifyFormat("bool operator,();"); 7175 verifyFormat("bool operator();"); 7176 verifyFormat("bool operator()();"); 7177 verifyFormat("bool operator[]();"); 7178 verifyFormat("operator bool();"); 7179 verifyFormat("operator int();"); 7180 verifyFormat("operator void *();"); 7181 verifyFormat("operator SomeType<int>();"); 7182 verifyFormat("operator SomeType<int, int>();"); 7183 verifyFormat("operator SomeType<SomeType<int>>();"); 7184 verifyFormat("void *operator new(std::size_t size);"); 7185 verifyFormat("void *operator new[](std::size_t size);"); 7186 verifyFormat("void operator delete(void *ptr);"); 7187 verifyFormat("void operator delete[](void *ptr);"); 7188 verifyFormat("template <typename AAAAAAA, typename BBBBBBB>\n" 7189 "AAAAAAA operator/(const AAAAAAA &a, BBBBBBB &b);"); 7190 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa operator,(\n" 7191 " aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaaaaaaaaaaaaaaaaaaa) const;"); 7192 7193 verifyFormat( 7194 "ostream &operator<<(ostream &OutputStream,\n" 7195 " SomeReallyLongType WithSomeReallyLongValue);"); 7196 verifyFormat("bool operator<(const aaaaaaaaaaaaaaaaaaaaa &left,\n" 7197 " const aaaaaaaaaaaaaaaaaaaaa &right) {\n" 7198 " return left.group < right.group;\n" 7199 "}"); 7200 verifyFormat("SomeType &operator=(const SomeType &S);"); 7201 verifyFormat("f.template operator()<int>();"); 7202 7203 verifyGoogleFormat("operator void*();"); 7204 verifyGoogleFormat("operator SomeType<SomeType<int>>();"); 7205 verifyGoogleFormat("operator ::A();"); 7206 7207 verifyFormat("using A::operator+;"); 7208 verifyFormat("inline A operator^(const A &lhs, const A &rhs) {}\n" 7209 "int i;"); 7210 } 7211 7212 TEST_F(FormatTest, UnderstandsFunctionRefQualification) { 7213 verifyFormat("Deleted &operator=(const Deleted &) & = default;"); 7214 verifyFormat("Deleted &operator=(const Deleted &) && = delete;"); 7215 verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;"); 7216 verifyFormat("SomeType MemberFunction(const Deleted &) && = delete;"); 7217 verifyFormat("Deleted &operator=(const Deleted &) &;"); 7218 verifyFormat("Deleted &operator=(const Deleted &) &&;"); 7219 verifyFormat("SomeType MemberFunction(const Deleted &) &;"); 7220 verifyFormat("SomeType MemberFunction(const Deleted &) &&;"); 7221 verifyFormat("SomeType MemberFunction(const Deleted &) && {}"); 7222 verifyFormat("SomeType MemberFunction(const Deleted &) && final {}"); 7223 verifyFormat("SomeType MemberFunction(const Deleted &) && override {}"); 7224 verifyFormat("void Fn(T const &) const &;"); 7225 verifyFormat("void Fn(T const volatile &&) const volatile &&;"); 7226 verifyFormat("template <typename T>\n" 7227 "void F(T) && = delete;", 7228 getGoogleStyle()); 7229 7230 FormatStyle AlignLeft = getLLVMStyle(); 7231 AlignLeft.PointerAlignment = FormatStyle::PAS_Left; 7232 verifyFormat("void A::b() && {}", AlignLeft); 7233 verifyFormat("Deleted& operator=(const Deleted&) & = default;", AlignLeft); 7234 verifyFormat("SomeType MemberFunction(const Deleted&) & = delete;", 7235 AlignLeft); 7236 verifyFormat("Deleted& operator=(const Deleted&) &;", AlignLeft); 7237 verifyFormat("SomeType MemberFunction(const Deleted&) &;", AlignLeft); 7238 verifyFormat("auto Function(T t) & -> void {}", AlignLeft); 7239 verifyFormat("auto Function(T... t) & -> void {}", AlignLeft); 7240 verifyFormat("auto Function(T) & -> void {}", AlignLeft); 7241 verifyFormat("auto Function(T) & -> void;", AlignLeft); 7242 verifyFormat("void Fn(T const&) const&;", AlignLeft); 7243 verifyFormat("void Fn(T const volatile&&) const volatile&&;", AlignLeft); 7244 7245 FormatStyle Spaces = getLLVMStyle(); 7246 Spaces.SpacesInCStyleCastParentheses = true; 7247 verifyFormat("Deleted &operator=(const Deleted &) & = default;", Spaces); 7248 verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;", Spaces); 7249 verifyFormat("Deleted &operator=(const Deleted &) &;", Spaces); 7250 verifyFormat("SomeType MemberFunction(const Deleted &) &;", Spaces); 7251 7252 Spaces.SpacesInCStyleCastParentheses = false; 7253 Spaces.SpacesInParentheses = true; 7254 verifyFormat("Deleted &operator=( const Deleted & ) & = default;", Spaces); 7255 verifyFormat("SomeType MemberFunction( const Deleted & ) & = delete;", 7256 Spaces); 7257 verifyFormat("Deleted &operator=( const Deleted & ) &;", Spaces); 7258 verifyFormat("SomeType MemberFunction( const Deleted & ) &;", Spaces); 7259 7260 FormatStyle BreakTemplate = getLLVMStyle(); 7261 BreakTemplate.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes; 7262 7263 verifyFormat("struct f {\n" 7264 " template <class T>\n" 7265 " int &foo(const std::string &str) &noexcept {}\n" 7266 "};", 7267 BreakTemplate); 7268 7269 verifyFormat("struct f {\n" 7270 " template <class T>\n" 7271 " int &foo(const std::string &str) &&noexcept {}\n" 7272 "};", 7273 BreakTemplate); 7274 7275 verifyFormat("struct f {\n" 7276 " template <class T>\n" 7277 " int &foo(const std::string &str) const &noexcept {}\n" 7278 "};", 7279 BreakTemplate); 7280 7281 verifyFormat("struct f {\n" 7282 " template <class T>\n" 7283 " int &foo(const std::string &str) const &noexcept {}\n" 7284 "};", 7285 BreakTemplate); 7286 7287 verifyFormat("struct f {\n" 7288 " template <class T>\n" 7289 " auto foo(const std::string &str) &&noexcept -> int & {}\n" 7290 "};", 7291 BreakTemplate); 7292 7293 FormatStyle AlignLeftBreakTemplate = getLLVMStyle(); 7294 AlignLeftBreakTemplate.AlwaysBreakTemplateDeclarations = 7295 FormatStyle::BTDS_Yes; 7296 AlignLeftBreakTemplate.PointerAlignment = FormatStyle::PAS_Left; 7297 7298 verifyFormat("struct f {\n" 7299 " template <class T>\n" 7300 " int& foo(const std::string& str) & noexcept {}\n" 7301 "};", 7302 AlignLeftBreakTemplate); 7303 7304 verifyFormat("struct f {\n" 7305 " template <class T>\n" 7306 " int& foo(const std::string& str) && noexcept {}\n" 7307 "};", 7308 AlignLeftBreakTemplate); 7309 7310 verifyFormat("struct f {\n" 7311 " template <class T>\n" 7312 " int& foo(const std::string& str) const& noexcept {}\n" 7313 "};", 7314 AlignLeftBreakTemplate); 7315 7316 verifyFormat("struct f {\n" 7317 " template <class T>\n" 7318 " int& foo(const std::string& str) const&& noexcept {}\n" 7319 "};", 7320 AlignLeftBreakTemplate); 7321 7322 verifyFormat("struct f {\n" 7323 " template <class T>\n" 7324 " auto foo(const std::string& str) && noexcept -> int& {}\n" 7325 "};", 7326 AlignLeftBreakTemplate); 7327 7328 // The `&` in `Type&` should not be confused with a trailing `&` of 7329 // DEPRECATED(reason) member function. 7330 verifyFormat("struct f {\n" 7331 " template <class T>\n" 7332 " DEPRECATED(reason)\n" 7333 " Type &foo(arguments) {}\n" 7334 "};", 7335 BreakTemplate); 7336 7337 verifyFormat("struct f {\n" 7338 " template <class T>\n" 7339 " DEPRECATED(reason)\n" 7340 " Type& foo(arguments) {}\n" 7341 "};", 7342 AlignLeftBreakTemplate); 7343 7344 verifyFormat("void (*foopt)(int) = &func;"); 7345 } 7346 7347 TEST_F(FormatTest, UnderstandsNewAndDelete) { 7348 verifyFormat("void f() {\n" 7349 " A *a = new A;\n" 7350 " A *a = new (placement) A;\n" 7351 " delete a;\n" 7352 " delete (A *)a;\n" 7353 "}"); 7354 verifyFormat("new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n" 7355 " typename aaaaaaaaaaaaaaaaaaaaaaaa();"); 7356 verifyFormat("auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 7357 " new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n" 7358 " typename aaaaaaaaaaaaaaaaaaaaaaaa();"); 7359 verifyFormat("delete[] h->p;"); 7360 } 7361 7362 TEST_F(FormatTest, UnderstandsUsesOfStarAndAmp) { 7363 verifyFormat("int *f(int *a) {}"); 7364 verifyFormat("int main(int argc, char **argv) {}"); 7365 verifyFormat("Test::Test(int b) : a(b * b) {}"); 7366 verifyIndependentOfContext("f(a, *a);"); 7367 verifyFormat("void g() { f(*a); }"); 7368 verifyIndependentOfContext("int a = b * 10;"); 7369 verifyIndependentOfContext("int a = 10 * b;"); 7370 verifyIndependentOfContext("int a = b * c;"); 7371 verifyIndependentOfContext("int a += b * c;"); 7372 verifyIndependentOfContext("int a -= b * c;"); 7373 verifyIndependentOfContext("int a *= b * c;"); 7374 verifyIndependentOfContext("int a /= b * c;"); 7375 verifyIndependentOfContext("int a = *b;"); 7376 verifyIndependentOfContext("int a = *b * c;"); 7377 verifyIndependentOfContext("int a = b * *c;"); 7378 verifyIndependentOfContext("int a = b * (10);"); 7379 verifyIndependentOfContext("S << b * (10);"); 7380 verifyIndependentOfContext("return 10 * b;"); 7381 verifyIndependentOfContext("return *b * *c;"); 7382 verifyIndependentOfContext("return a & ~b;"); 7383 verifyIndependentOfContext("f(b ? *c : *d);"); 7384 verifyIndependentOfContext("int a = b ? *c : *d;"); 7385 verifyIndependentOfContext("*b = a;"); 7386 verifyIndependentOfContext("a * ~b;"); 7387 verifyIndependentOfContext("a * !b;"); 7388 verifyIndependentOfContext("a * +b;"); 7389 verifyIndependentOfContext("a * -b;"); 7390 verifyIndependentOfContext("a * ++b;"); 7391 verifyIndependentOfContext("a * --b;"); 7392 verifyIndependentOfContext("a[4] * b;"); 7393 verifyIndependentOfContext("a[a * a] = 1;"); 7394 verifyIndependentOfContext("f() * b;"); 7395 verifyIndependentOfContext("a * [self dostuff];"); 7396 verifyIndependentOfContext("int x = a * (a + b);"); 7397 verifyIndependentOfContext("(a *)(a + b);"); 7398 verifyIndependentOfContext("*(int *)(p & ~3UL) = 0;"); 7399 verifyIndependentOfContext("int *pa = (int *)&a;"); 7400 verifyIndependentOfContext("return sizeof(int **);"); 7401 verifyIndependentOfContext("return sizeof(int ******);"); 7402 verifyIndependentOfContext("return (int **&)a;"); 7403 verifyIndependentOfContext("f((*PointerToArray)[10]);"); 7404 verifyFormat("void f(Type (*parameter)[10]) {}"); 7405 verifyFormat("void f(Type (¶meter)[10]) {}"); 7406 verifyGoogleFormat("return sizeof(int**);"); 7407 verifyIndependentOfContext("Type **A = static_cast<Type **>(P);"); 7408 verifyGoogleFormat("Type** A = static_cast<Type**>(P);"); 7409 verifyFormat("auto a = [](int **&, int ***) {};"); 7410 verifyFormat("auto PointerBinding = [](const char *S) {};"); 7411 verifyFormat("typedef typeof(int(int, int)) *MyFunc;"); 7412 verifyFormat("[](const decltype(*a) &value) {}"); 7413 verifyFormat("decltype(a * b) F();"); 7414 verifyFormat("#define MACRO() [](A *a) { return 1; }"); 7415 verifyFormat("Constructor() : member([](A *a, B *b) {}) {}"); 7416 verifyIndependentOfContext("typedef void (*f)(int *a);"); 7417 verifyIndependentOfContext("int i{a * b};"); 7418 verifyIndependentOfContext("aaa && aaa->f();"); 7419 verifyIndependentOfContext("int x = ~*p;"); 7420 verifyFormat("Constructor() : a(a), area(width * height) {}"); 7421 verifyFormat("Constructor() : a(a), area(a, width * height) {}"); 7422 verifyGoogleFormat("MACRO Constructor(const int& i) : a(a), b(b) {}"); 7423 verifyFormat("void f() { f(a, c * d); }"); 7424 verifyFormat("void f() { f(new a(), c * d); }"); 7425 verifyFormat("void f(const MyOverride &override);"); 7426 verifyFormat("void f(const MyFinal &final);"); 7427 verifyIndependentOfContext("bool a = f() && override.f();"); 7428 verifyIndependentOfContext("bool a = f() && final.f();"); 7429 7430 verifyIndependentOfContext("InvalidRegions[*R] = 0;"); 7431 7432 verifyIndependentOfContext("A<int *> a;"); 7433 verifyIndependentOfContext("A<int **> a;"); 7434 verifyIndependentOfContext("A<int *, int *> a;"); 7435 verifyIndependentOfContext("A<int *[]> a;"); 7436 verifyIndependentOfContext( 7437 "const char *const p = reinterpret_cast<const char *const>(q);"); 7438 verifyIndependentOfContext("A<int **, int **> a;"); 7439 verifyIndependentOfContext("void f(int *a = d * e, int *b = c * d);"); 7440 verifyFormat("for (char **a = b; *a; ++a) {\n}"); 7441 verifyFormat("for (; a && b;) {\n}"); 7442 verifyFormat("bool foo = true && [] { return false; }();"); 7443 7444 verifyFormat( 7445 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7446 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa, *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 7447 7448 verifyGoogleFormat("int const* a = &b;"); 7449 verifyGoogleFormat("**outparam = 1;"); 7450 verifyGoogleFormat("*outparam = a * b;"); 7451 verifyGoogleFormat("int main(int argc, char** argv) {}"); 7452 verifyGoogleFormat("A<int*> a;"); 7453 verifyGoogleFormat("A<int**> a;"); 7454 verifyGoogleFormat("A<int*, int*> a;"); 7455 verifyGoogleFormat("A<int**, int**> a;"); 7456 verifyGoogleFormat("f(b ? *c : *d);"); 7457 verifyGoogleFormat("int a = b ? *c : *d;"); 7458 verifyGoogleFormat("Type* t = **x;"); 7459 verifyGoogleFormat("Type* t = *++*x;"); 7460 verifyGoogleFormat("*++*x;"); 7461 verifyGoogleFormat("Type* t = const_cast<T*>(&*x);"); 7462 verifyGoogleFormat("Type* t = x++ * y;"); 7463 verifyGoogleFormat( 7464 "const char* const p = reinterpret_cast<const char* const>(q);"); 7465 verifyGoogleFormat("void f(int i = 0, SomeType** temps = NULL);"); 7466 verifyGoogleFormat("void f(Bar* a = nullptr, Bar* b);"); 7467 verifyGoogleFormat("template <typename T>\n" 7468 "void f(int i = 0, SomeType** temps = NULL);"); 7469 7470 FormatStyle Left = getLLVMStyle(); 7471 Left.PointerAlignment = FormatStyle::PAS_Left; 7472 verifyFormat("x = *a(x) = *a(y);", Left); 7473 verifyFormat("for (;; *a = b) {\n}", Left); 7474 verifyFormat("return *this += 1;", Left); 7475 verifyFormat("throw *x;", Left); 7476 verifyFormat("delete *x;", Left); 7477 verifyFormat("typedef typeof(int(int, int))* MyFuncPtr;", Left); 7478 verifyFormat("[](const decltype(*a)* ptr) {}", Left); 7479 verifyFormat("typedef typeof /*comment*/ (int(int, int))* MyFuncPtr;", Left); 7480 verifyFormat("auto x(A&&, B&&, C&&) -> D;", Left); 7481 verifyFormat("auto x = [](A&&, B&&, C&&) -> D {};", Left); 7482 verifyFormat("template <class T> X(T&&, T&&, T&&) -> X<T>;", Left); 7483 7484 verifyIndependentOfContext("a = *(x + y);"); 7485 verifyIndependentOfContext("a = &(x + y);"); 7486 verifyIndependentOfContext("*(x + y).call();"); 7487 verifyIndependentOfContext("&(x + y)->call();"); 7488 verifyFormat("void f() { &(*I).first; }"); 7489 7490 verifyIndependentOfContext("f(b * /* confusing comment */ ++c);"); 7491 verifyFormat( 7492 "int *MyValues = {\n" 7493 " *A, // Operator detection might be confused by the '{'\n" 7494 " *BB // Operator detection might be confused by previous comment\n" 7495 "};"); 7496 7497 verifyIndependentOfContext("if (int *a = &b)"); 7498 verifyIndependentOfContext("if (int &a = *b)"); 7499 verifyIndependentOfContext("if (a & b[i])"); 7500 verifyIndependentOfContext("if constexpr (a & b[i])"); 7501 verifyIndependentOfContext("if CONSTEXPR (a & b[i])"); 7502 verifyIndependentOfContext("if (a * (b * c))"); 7503 verifyIndependentOfContext("if constexpr (a * (b * c))"); 7504 verifyIndependentOfContext("if CONSTEXPR (a * (b * c))"); 7505 verifyIndependentOfContext("if (a::b::c::d & b[i])"); 7506 verifyIndependentOfContext("if (*b[i])"); 7507 verifyIndependentOfContext("if (int *a = (&b))"); 7508 verifyIndependentOfContext("while (int *a = &b)"); 7509 verifyIndependentOfContext("while (a * (b * c))"); 7510 verifyIndependentOfContext("size = sizeof *a;"); 7511 verifyIndependentOfContext("if (a && (b = c))"); 7512 verifyFormat("void f() {\n" 7513 " for (const int &v : Values) {\n" 7514 " }\n" 7515 "}"); 7516 verifyFormat("for (int i = a * a; i < 10; ++i) {\n}"); 7517 verifyFormat("for (int i = 0; i < a * a; ++i) {\n}"); 7518 verifyGoogleFormat("for (int i = 0; i * 2 < z; i *= 2) {\n}"); 7519 7520 verifyFormat("#define A (!a * b)"); 7521 verifyFormat("#define MACRO \\\n" 7522 " int *i = a * b; \\\n" 7523 " void f(a *b);", 7524 getLLVMStyleWithColumns(19)); 7525 7526 verifyIndependentOfContext("A = new SomeType *[Length];"); 7527 verifyIndependentOfContext("A = new SomeType *[Length]();"); 7528 verifyIndependentOfContext("T **t = new T *;"); 7529 verifyIndependentOfContext("T **t = new T *();"); 7530 verifyGoogleFormat("A = new SomeType*[Length]();"); 7531 verifyGoogleFormat("A = new SomeType*[Length];"); 7532 verifyGoogleFormat("T** t = new T*;"); 7533 verifyGoogleFormat("T** t = new T*();"); 7534 7535 verifyFormat("STATIC_ASSERT((a & b) == 0);"); 7536 verifyFormat("STATIC_ASSERT(0 == (a & b));"); 7537 verifyFormat("template <bool a, bool b> " 7538 "typename t::if<x && y>::type f() {}"); 7539 verifyFormat("template <int *y> f() {}"); 7540 verifyFormat("vector<int *> v;"); 7541 verifyFormat("vector<int *const> v;"); 7542 verifyFormat("vector<int *const **const *> v;"); 7543 verifyFormat("vector<int *volatile> v;"); 7544 verifyFormat("vector<a * b> v;"); 7545 verifyFormat("foo<b && false>();"); 7546 verifyFormat("foo<b & 1>();"); 7547 verifyFormat("decltype(*::std::declval<const T &>()) void F();"); 7548 verifyFormat( 7549 "template <class T, class = typename std::enable_if<\n" 7550 " std::is_integral<T>::value &&\n" 7551 " (sizeof(T) > 1 || sizeof(T) < 8)>::type>\n" 7552 "void F();", 7553 getLLVMStyleWithColumns(70)); 7554 verifyFormat("template <class T,\n" 7555 " class = typename std::enable_if<\n" 7556 " std::is_integral<T>::value &&\n" 7557 " (sizeof(T) > 1 || sizeof(T) < 8)>::type,\n" 7558 " class U>\n" 7559 "void F();", 7560 getLLVMStyleWithColumns(70)); 7561 verifyFormat( 7562 "template <class T,\n" 7563 " class = typename ::std::enable_if<\n" 7564 " ::std::is_array<T>{} && ::std::is_array<T>{}>::type>\n" 7565 "void F();", 7566 getGoogleStyleWithColumns(68)); 7567 7568 verifyIndependentOfContext("MACRO(int *i);"); 7569 verifyIndependentOfContext("MACRO(auto *a);"); 7570 verifyIndependentOfContext("MACRO(const A *a);"); 7571 verifyIndependentOfContext("MACRO(A *const a);"); 7572 verifyIndependentOfContext("MACRO('0' <= c && c <= '9');"); 7573 verifyFormat("void f() { f(float{1}, a * a); }"); 7574 // FIXME: Is there a way to make this work? 7575 // verifyIndependentOfContext("MACRO(A *a);"); 7576 7577 verifyFormat("DatumHandle const *operator->() const { return input_; }"); 7578 verifyFormat("return options != nullptr && operator==(*options);"); 7579 7580 EXPECT_EQ("#define OP(x) \\\n" 7581 " ostream &operator<<(ostream &s, const A &a) { \\\n" 7582 " return s << a.DebugString(); \\\n" 7583 " }", 7584 format("#define OP(x) \\\n" 7585 " ostream &operator<<(ostream &s, const A &a) { \\\n" 7586 " return s << a.DebugString(); \\\n" 7587 " }", 7588 getLLVMStyleWithColumns(50))); 7589 7590 // FIXME: We cannot handle this case yet; we might be able to figure out that 7591 // foo<x> d > v; doesn't make sense. 7592 verifyFormat("foo<a<b && c> d> v;"); 7593 7594 FormatStyle PointerMiddle = getLLVMStyle(); 7595 PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle; 7596 verifyFormat("delete *x;", PointerMiddle); 7597 verifyFormat("int * x;", PointerMiddle); 7598 verifyFormat("int *[] x;", PointerMiddle); 7599 verifyFormat("template <int * y> f() {}", PointerMiddle); 7600 verifyFormat("int * f(int * a) {}", PointerMiddle); 7601 verifyFormat("int main(int argc, char ** argv) {}", PointerMiddle); 7602 verifyFormat("Test::Test(int b) : a(b * b) {}", PointerMiddle); 7603 verifyFormat("A<int *> a;", PointerMiddle); 7604 verifyFormat("A<int **> a;", PointerMiddle); 7605 verifyFormat("A<int *, int *> a;", PointerMiddle); 7606 verifyFormat("A<int *[]> a;", PointerMiddle); 7607 verifyFormat("A = new SomeType *[Length]();", PointerMiddle); 7608 verifyFormat("A = new SomeType *[Length];", PointerMiddle); 7609 verifyFormat("T ** t = new T *;", PointerMiddle); 7610 7611 // Member function reference qualifiers aren't binary operators. 7612 verifyFormat("string // break\n" 7613 "operator()() & {}"); 7614 verifyFormat("string // break\n" 7615 "operator()() && {}"); 7616 verifyGoogleFormat("template <typename T>\n" 7617 "auto x() & -> int {}"); 7618 } 7619 7620 TEST_F(FormatTest, UnderstandsAttributes) { 7621 verifyFormat("SomeType s __attribute__((unused)) (InitValue);"); 7622 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa __attribute__((unused))\n" 7623 "aaaaaaaaaaaaaaaaaaaaaaa(int i);"); 7624 FormatStyle AfterType = getLLVMStyle(); 7625 AfterType.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions; 7626 verifyFormat("__attribute__((nodebug)) void\n" 7627 "foo() {}\n", 7628 AfterType); 7629 } 7630 7631 TEST_F(FormatTest, UnderstandsSquareAttributes) { 7632 verifyFormat("SomeType s [[unused]] (InitValue);"); 7633 verifyFormat("SomeType s [[gnu::unused]] (InitValue);"); 7634 verifyFormat("SomeType s [[using gnu: unused]] (InitValue);"); 7635 verifyFormat("[[gsl::suppress(\"clang-tidy-check-name\")]] void f() {}"); 7636 verifyFormat("void f() [[deprecated(\"so sorry\")]];"); 7637 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7638 " [[unused]] aaaaaaaaaaaaaaaaaaaaaaa(int i);"); 7639 7640 // Make sure we do not mistake attributes for array subscripts. 7641 verifyFormat("int a() {}\n" 7642 "[[unused]] int b() {}\n"); 7643 verifyFormat("NSArray *arr;\n" 7644 "arr[[Foo() bar]];"); 7645 7646 // On the other hand, we still need to correctly find array subscripts. 7647 verifyFormat("int a = std::vector<int>{1, 2, 3}[0];"); 7648 7649 // Make sure that we do not mistake Objective-C method inside array literals 7650 // as attributes, even if those method names are also keywords. 7651 verifyFormat("@[ [foo bar] ];"); 7652 verifyFormat("@[ [NSArray class] ];"); 7653 verifyFormat("@[ [foo enum] ];"); 7654 7655 // Make sure we do not parse attributes as lambda introducers. 7656 FormatStyle MultiLineFunctions = getLLVMStyle(); 7657 MultiLineFunctions.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 7658 verifyFormat("[[unused]] int b() {\n" 7659 " return 42;\n" 7660 "}\n", 7661 MultiLineFunctions); 7662 } 7663 7664 TEST_F(FormatTest, UnderstandsEllipsis) { 7665 verifyFormat("int printf(const char *fmt, ...);"); 7666 verifyFormat("template <class... Ts> void Foo(Ts... ts) { Foo(ts...); }"); 7667 verifyFormat("template <class... Ts> void Foo(Ts *... ts) {}"); 7668 7669 FormatStyle PointersLeft = getLLVMStyle(); 7670 PointersLeft.PointerAlignment = FormatStyle::PAS_Left; 7671 verifyFormat("template <class... Ts> void Foo(Ts*... ts) {}", PointersLeft); 7672 } 7673 7674 TEST_F(FormatTest, AdaptivelyFormatsPointersAndReferences) { 7675 EXPECT_EQ("int *a;\n" 7676 "int *a;\n" 7677 "int *a;", 7678 format("int *a;\n" 7679 "int* a;\n" 7680 "int *a;", 7681 getGoogleStyle())); 7682 EXPECT_EQ("int* a;\n" 7683 "int* a;\n" 7684 "int* a;", 7685 format("int* a;\n" 7686 "int* a;\n" 7687 "int *a;", 7688 getGoogleStyle())); 7689 EXPECT_EQ("int *a;\n" 7690 "int *a;\n" 7691 "int *a;", 7692 format("int *a;\n" 7693 "int * a;\n" 7694 "int * a;", 7695 getGoogleStyle())); 7696 EXPECT_EQ("auto x = [] {\n" 7697 " int *a;\n" 7698 " int *a;\n" 7699 " int *a;\n" 7700 "};", 7701 format("auto x=[]{int *a;\n" 7702 "int * a;\n" 7703 "int * a;};", 7704 getGoogleStyle())); 7705 } 7706 7707 TEST_F(FormatTest, UnderstandsRvalueReferences) { 7708 verifyFormat("int f(int &&a) {}"); 7709 verifyFormat("int f(int a, char &&b) {}"); 7710 verifyFormat("void f() { int &&a = b; }"); 7711 verifyGoogleFormat("int f(int a, char&& b) {}"); 7712 verifyGoogleFormat("void f() { int&& a = b; }"); 7713 7714 verifyIndependentOfContext("A<int &&> a;"); 7715 verifyIndependentOfContext("A<int &&, int &&> a;"); 7716 verifyGoogleFormat("A<int&&> a;"); 7717 verifyGoogleFormat("A<int&&, int&&> a;"); 7718 7719 // Not rvalue references: 7720 verifyFormat("template <bool B, bool C> class A {\n" 7721 " static_assert(B && C, \"Something is wrong\");\n" 7722 "};"); 7723 verifyGoogleFormat("#define IF(a, b, c) if (a && (b == c))"); 7724 verifyGoogleFormat("#define WHILE(a, b, c) while (a && (b == c))"); 7725 verifyFormat("#define A(a, b) (a && b)"); 7726 } 7727 7728 TEST_F(FormatTest, FormatsBinaryOperatorsPrecedingEquals) { 7729 verifyFormat("void f() {\n" 7730 " x[aaaaaaaaa -\n" 7731 " b] = 23;\n" 7732 "}", 7733 getLLVMStyleWithColumns(15)); 7734 } 7735 7736 TEST_F(FormatTest, FormatsCasts) { 7737 verifyFormat("Type *A = static_cast<Type *>(P);"); 7738 verifyFormat("Type *A = (Type *)P;"); 7739 verifyFormat("Type *A = (vector<Type *, int *>)P;"); 7740 verifyFormat("int a = (int)(2.0f);"); 7741 verifyFormat("int a = (int)2.0f;"); 7742 verifyFormat("x[(int32)y];"); 7743 verifyFormat("x = (int32)y;"); 7744 verifyFormat("#define AA(X) sizeof(((X *)NULL)->a)"); 7745 verifyFormat("int a = (int)*b;"); 7746 verifyFormat("int a = (int)2.0f;"); 7747 verifyFormat("int a = (int)~0;"); 7748 verifyFormat("int a = (int)++a;"); 7749 verifyFormat("int a = (int)sizeof(int);"); 7750 verifyFormat("int a = (int)+2;"); 7751 verifyFormat("my_int a = (my_int)2.0f;"); 7752 verifyFormat("my_int a = (my_int)sizeof(int);"); 7753 verifyFormat("return (my_int)aaa;"); 7754 verifyFormat("#define x ((int)-1)"); 7755 verifyFormat("#define LENGTH(x, y) (x) - (y) + 1"); 7756 verifyFormat("#define p(q) ((int *)&q)"); 7757 verifyFormat("fn(a)(b) + 1;"); 7758 7759 verifyFormat("void f() { my_int a = (my_int)*b; }"); 7760 verifyFormat("void f() { return P ? (my_int)*P : (my_int)0; }"); 7761 verifyFormat("my_int a = (my_int)~0;"); 7762 verifyFormat("my_int a = (my_int)++a;"); 7763 verifyFormat("my_int a = (my_int)-2;"); 7764 verifyFormat("my_int a = (my_int)1;"); 7765 verifyFormat("my_int a = (my_int *)1;"); 7766 verifyFormat("my_int a = (const my_int)-1;"); 7767 verifyFormat("my_int a = (const my_int *)-1;"); 7768 verifyFormat("my_int a = (my_int)(my_int)-1;"); 7769 verifyFormat("my_int a = (ns::my_int)-2;"); 7770 verifyFormat("case (my_int)ONE:"); 7771 verifyFormat("auto x = (X)this;"); 7772 // Casts in Obj-C style calls used to not be recognized as such. 7773 verifyFormat("int a = [(type*)[((type*)val) arg] arg];", getGoogleStyle()); 7774 7775 // FIXME: single value wrapped with paren will be treated as cast. 7776 verifyFormat("void f(int i = (kValue)*kMask) {}"); 7777 7778 verifyFormat("{ (void)F; }"); 7779 7780 // Don't break after a cast's 7781 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 7782 " (aaaaaaaaaaaaaaaaaaaaaaaaaa *)(aaaaaaaaaaaaaaaaaaaaaa +\n" 7783 " bbbbbbbbbbbbbbbbbbbbbb);"); 7784 7785 // These are not casts. 7786 verifyFormat("void f(int *) {}"); 7787 verifyFormat("f(foo)->b;"); 7788 verifyFormat("f(foo).b;"); 7789 verifyFormat("f(foo)(b);"); 7790 verifyFormat("f(foo)[b];"); 7791 verifyFormat("[](foo) { return 4; }(bar);"); 7792 verifyFormat("(*funptr)(foo)[4];"); 7793 verifyFormat("funptrs[4](foo)[4];"); 7794 verifyFormat("void f(int *);"); 7795 verifyFormat("void f(int *) = 0;"); 7796 verifyFormat("void f(SmallVector<int>) {}"); 7797 verifyFormat("void f(SmallVector<int>);"); 7798 verifyFormat("void f(SmallVector<int>) = 0;"); 7799 verifyFormat("void f(int i = (kA * kB) & kMask) {}"); 7800 verifyFormat("int a = sizeof(int) * b;"); 7801 verifyFormat("int a = alignof(int) * b;", getGoogleStyle()); 7802 verifyFormat("template <> void f<int>(int i) SOME_ANNOTATION;"); 7803 verifyFormat("f(\"%\" SOME_MACRO(ll) \"d\");"); 7804 verifyFormat("aaaaa &operator=(const aaaaa &) LLVM_DELETED_FUNCTION;"); 7805 7806 // These are not casts, but at some point were confused with casts. 7807 verifyFormat("virtual void foo(int *) override;"); 7808 verifyFormat("virtual void foo(char &) const;"); 7809 verifyFormat("virtual void foo(int *a, char *) const;"); 7810 verifyFormat("int a = sizeof(int *) + b;"); 7811 verifyFormat("int a = alignof(int *) + b;", getGoogleStyle()); 7812 verifyFormat("bool b = f(g<int>) && c;"); 7813 verifyFormat("typedef void (*f)(int i) func;"); 7814 verifyFormat("void operator++(int) noexcept;"); 7815 verifyFormat("void operator++(int &) noexcept;"); 7816 verifyFormat("void operator delete(void *, std::size_t, const std::nothrow_t " 7817 "&) noexcept;"); 7818 verifyFormat( 7819 "void operator delete(std::size_t, const std::nothrow_t &) noexcept;"); 7820 verifyFormat("void operator delete(const std::nothrow_t &) noexcept;"); 7821 verifyFormat("void operator delete(std::nothrow_t &) noexcept;"); 7822 verifyFormat("void operator delete(nothrow_t &) noexcept;"); 7823 verifyFormat("void operator delete(foo &) noexcept;"); 7824 verifyFormat("void operator delete(foo) noexcept;"); 7825 verifyFormat("void operator delete(int) noexcept;"); 7826 verifyFormat("void operator delete(int &) noexcept;"); 7827 verifyFormat("void operator delete(int &) volatile noexcept;"); 7828 verifyFormat("void operator delete(int &) const"); 7829 verifyFormat("void operator delete(int &) = default"); 7830 verifyFormat("void operator delete(int &) = delete"); 7831 verifyFormat("void operator delete(int &) [[noreturn]]"); 7832 verifyFormat("void operator delete(int &) throw();"); 7833 verifyFormat("void operator delete(int &) throw(int);"); 7834 verifyFormat("auto operator delete(int &) -> int;"); 7835 verifyFormat("auto operator delete(int &) override"); 7836 verifyFormat("auto operator delete(int &) final"); 7837 7838 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *foo = (aaaaaaaaaaaaaaaaa *)\n" 7839 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 7840 // FIXME: The indentation here is not ideal. 7841 verifyFormat( 7842 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7843 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = (*cccccccccccccccc)\n" 7844 " [dddddddddddddddddddddddddddddddddddddddddddddddddddddddd];"); 7845 } 7846 7847 TEST_F(FormatTest, FormatsFunctionTypes) { 7848 verifyFormat("A<bool()> a;"); 7849 verifyFormat("A<SomeType()> a;"); 7850 verifyFormat("A<void (*)(int, std::string)> a;"); 7851 verifyFormat("A<void *(int)>;"); 7852 verifyFormat("void *(*a)(int *, SomeType *);"); 7853 verifyFormat("int (*func)(void *);"); 7854 verifyFormat("void f() { int (*func)(void *); }"); 7855 verifyFormat("template <class CallbackClass>\n" 7856 "using MyCallback = void (CallbackClass::*)(SomeObject *Data);"); 7857 7858 verifyGoogleFormat("A<void*(int*, SomeType*)>;"); 7859 verifyGoogleFormat("void* (*a)(int);"); 7860 verifyGoogleFormat( 7861 "template <class CallbackClass>\n" 7862 "using MyCallback = void (CallbackClass::*)(SomeObject* Data);"); 7863 7864 // Other constructs can look somewhat like function types: 7865 verifyFormat("A<sizeof(*x)> a;"); 7866 verifyFormat("#define DEREF_AND_CALL_F(x) f(*x)"); 7867 verifyFormat("some_var = function(*some_pointer_var)[0];"); 7868 verifyFormat("void f() { function(*some_pointer_var)[0] = 10; }"); 7869 verifyFormat("int x = f(&h)();"); 7870 verifyFormat("returnsFunction(¶m1, ¶m2)(param);"); 7871 verifyFormat("std::function<\n" 7872 " LooooooooooongTemplatedType<\n" 7873 " SomeType>*(\n" 7874 " LooooooooooooooooongType type)>\n" 7875 " function;", 7876 getGoogleStyleWithColumns(40)); 7877 } 7878 7879 TEST_F(FormatTest, FormatsPointersToArrayTypes) { 7880 verifyFormat("A (*foo_)[6];"); 7881 verifyFormat("vector<int> (*foo_)[6];"); 7882 } 7883 7884 TEST_F(FormatTest, BreaksLongVariableDeclarations) { 7885 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7886 " LoooooooooooooooooooooooooooooooooooooooongVariable;"); 7887 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType const\n" 7888 " LoooooooooooooooooooooooooooooooooooooooongVariable;"); 7889 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7890 " *LoooooooooooooooooooooooooooooooooooooooongVariable;"); 7891 7892 // Different ways of ()-initializiation. 7893 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7894 " LoooooooooooooooooooooooooooooooooooooooongVariable(1);"); 7895 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7896 " LoooooooooooooooooooooooooooooooooooooooongVariable(a);"); 7897 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7898 " LoooooooooooooooooooooooooooooooooooooooongVariable({});"); 7899 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7900 " LoooooooooooooooooooooooooooooooooooooongVariable([A a]);"); 7901 7902 // Lambdas should not confuse the variable declaration heuristic. 7903 verifyFormat("LooooooooooooooooongType\n" 7904 " variable(nullptr, [](A *a) {});", 7905 getLLVMStyleWithColumns(40)); 7906 } 7907 7908 TEST_F(FormatTest, BreaksLongDeclarations) { 7909 verifyFormat("typedef LoooooooooooooooooooooooooooooooooooooooongType\n" 7910 " AnotherNameForTheLongType;"); 7911 verifyFormat("typedef LongTemplateType<aaaaaaaaaaaaaaaaaaa()>\n" 7912 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 7913 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7914 "LoooooooooooooooooooooooooooooooongFunctionDeclaration();"); 7915 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType *\n" 7916 "LoooooooooooooooooooooooooooooooongFunctionDeclaration();"); 7917 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7918 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7919 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType MACRO\n" 7920 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7921 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType const\n" 7922 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7923 verifyFormat("decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n" 7924 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7925 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7926 "LooooooooooooooooooooooooooongFunctionDeclaration(T... t);"); 7927 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7928 "LooooooooooooooooooooooooooongFunctionDeclaration(T /*t*/) {}"); 7929 FormatStyle Indented = getLLVMStyle(); 7930 Indented.IndentWrappedFunctionNames = true; 7931 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7932 " LoooooooooooooooooooooooooooooooongFunctionDeclaration();", 7933 Indented); 7934 verifyFormat( 7935 "LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7936 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}", 7937 Indented); 7938 verifyFormat( 7939 "LoooooooooooooooooooooooooooooooooooooooongReturnType const\n" 7940 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}", 7941 Indented); 7942 verifyFormat( 7943 "decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n" 7944 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}", 7945 Indented); 7946 7947 // FIXME: Without the comment, this breaks after "(". 7948 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType // break\n" 7949 " (*LoooooooooooooooooooooooooooongFunctionTypeVarialbe)();", 7950 getGoogleStyle()); 7951 7952 verifyFormat("int *someFunction(int LoooooooooooooooooooongParam1,\n" 7953 " int LoooooooooooooooooooongParam2) {}"); 7954 verifyFormat( 7955 "TypeSpecDecl *TypeSpecDecl::Create(ASTContext &C, DeclContext *DC,\n" 7956 " SourceLocation L, IdentifierIn *II,\n" 7957 " Type *T) {}"); 7958 verifyFormat("ReallyLongReturnType<TemplateParam1, TemplateParam2>\n" 7959 "ReallyReaaallyLongFunctionName(\n" 7960 " const std::string &SomeParameter,\n" 7961 " const SomeType<string, SomeOtherTemplateParameter>\n" 7962 " &ReallyReallyLongParameterName,\n" 7963 " const SomeType<string, SomeOtherTemplateParameter>\n" 7964 " &AnotherLongParameterName) {}"); 7965 verifyFormat("template <typename A>\n" 7966 "SomeLoooooooooooooooooooooongType<\n" 7967 " typename some_namespace::SomeOtherType<A>::Type>\n" 7968 "Function() {}"); 7969 7970 verifyGoogleFormat( 7971 "aaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaa<aaaaaaaaaaaaa, aaaaaaaaaaaa>\n" 7972 " aaaaaaaaaaaaaaaaaaaaaaa;"); 7973 verifyGoogleFormat( 7974 "TypeSpecDecl* TypeSpecDecl::Create(ASTContext& C, DeclContext* DC,\n" 7975 " SourceLocation L) {}"); 7976 verifyGoogleFormat( 7977 "some_namespace::LongReturnType\n" 7978 "long_namespace::SomeVeryLongClass::SomeVeryLongFunction(\n" 7979 " int first_long_parameter, int second_parameter) {}"); 7980 7981 verifyGoogleFormat("template <typename T>\n" 7982 "aaaaaaaa::aaaaa::aaaaaa<T, aaaaaaaaaaaaaaaaaaaaaaaaa>\n" 7983 "aaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaa() {}"); 7984 verifyGoogleFormat("A<A<A>> aaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 7985 " int aaaaaaaaaaaaaaaaaaaaaaa);"); 7986 7987 verifyFormat("typedef size_t (*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n" 7988 " const aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7989 " *aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 7990 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7991 " vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n" 7992 " aaaaaaaaaaaaaaaaaaaaaaaa);"); 7993 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7994 " vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n" 7995 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>>\n" 7996 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 7997 7998 verifyFormat("template <typename T> // Templates on own line.\n" 7999 "static int // Some comment.\n" 8000 "MyFunction(int a);", 8001 getLLVMStyle()); 8002 } 8003 8004 TEST_F(FormatTest, FormatsArrays) { 8005 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaaaaaaaaaa]\n" 8006 " [bbbbbbbbbbbbbbbbbbbbbbbbb] = c;"); 8007 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaa(aaaaaaaaaaaa)]\n" 8008 " [bbbbbbbbbbb(bbbbbbbbbbbb)] = c;"); 8009 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaa &&\n" 8010 " aaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaa][aaaaaaaaaaaaa]) {\n}"); 8011 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 8012 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;"); 8013 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 8014 " [a][bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = cccccccc;"); 8015 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 8016 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n" 8017 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;"); 8018 verifyFormat( 8019 "llvm::outs() << \"aaaaaaaaaaaa: \"\n" 8020 " << (*aaaaaaaiaaaaaaa)[aaaaaaaaaaaaaaaaaaaaaaaaa]\n" 8021 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa];"); 8022 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaa][a]\n" 8023 " .aaaaaaaaaaaaaaaaaaaaaa();"); 8024 8025 verifyGoogleFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<int>\n" 8026 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaa];"); 8027 verifyFormat( 8028 "aaaaaaaaaaa aaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaa->aaaaaaaaa[0]\n" 8029 " .aaaaaaa[0]\n" 8030 " .aaaaaaaaaaaaaaaaaaaaaa();"); 8031 verifyFormat("a[::b::c];"); 8032 8033 verifyNoCrash("a[,Y?)]", getLLVMStyleWithColumns(10)); 8034 8035 FormatStyle NoColumnLimit = getLLVMStyleWithColumns(0); 8036 verifyFormat("aaaaa[bbbbbb].cccccc()", NoColumnLimit); 8037 } 8038 8039 TEST_F(FormatTest, LineStartsWithSpecialCharacter) { 8040 verifyFormat("(a)->b();"); 8041 verifyFormat("--a;"); 8042 } 8043 8044 TEST_F(FormatTest, HandlesIncludeDirectives) { 8045 verifyFormat("#include <string>\n" 8046 "#include <a/b/c.h>\n" 8047 "#include \"a/b/string\"\n" 8048 "#include \"string.h\"\n" 8049 "#include \"string.h\"\n" 8050 "#include <a-a>\n" 8051 "#include < path with space >\n" 8052 "#include_next <test.h>" 8053 "#include \"abc.h\" // this is included for ABC\n" 8054 "#include \"some long include\" // with a comment\n" 8055 "#include \"some very long include path\"\n" 8056 "#include <some/very/long/include/path>\n", 8057 getLLVMStyleWithColumns(35)); 8058 EXPECT_EQ("#include \"a.h\"", format("#include \"a.h\"")); 8059 EXPECT_EQ("#include <a>", format("#include<a>")); 8060 8061 verifyFormat("#import <string>"); 8062 verifyFormat("#import <a/b/c.h>"); 8063 verifyFormat("#import \"a/b/string\""); 8064 verifyFormat("#import \"string.h\""); 8065 verifyFormat("#import \"string.h\""); 8066 verifyFormat("#if __has_include(<strstream>)\n" 8067 "#include <strstream>\n" 8068 "#endif"); 8069 8070 verifyFormat("#define MY_IMPORT <a/b>"); 8071 8072 verifyFormat("#if __has_include(<a/b>)"); 8073 verifyFormat("#if __has_include_next(<a/b>)"); 8074 verifyFormat("#define F __has_include(<a/b>)"); 8075 verifyFormat("#define F __has_include_next(<a/b>)"); 8076 8077 // Protocol buffer definition or missing "#". 8078 verifyFormat("import \"aaaaaaaaaaaaaaaaa/aaaaaaaaaaaaaaa\";", 8079 getLLVMStyleWithColumns(30)); 8080 8081 FormatStyle Style = getLLVMStyle(); 8082 Style.AlwaysBreakBeforeMultilineStrings = true; 8083 Style.ColumnLimit = 0; 8084 verifyFormat("#import \"abc.h\"", Style); 8085 8086 // But 'import' might also be a regular C++ namespace. 8087 verifyFormat("import::SomeFunction(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 8088 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 8089 } 8090 8091 //===----------------------------------------------------------------------===// 8092 // Error recovery tests. 8093 //===----------------------------------------------------------------------===// 8094 8095 TEST_F(FormatTest, IncompleteParameterLists) { 8096 FormatStyle NoBinPacking = getLLVMStyle(); 8097 NoBinPacking.BinPackParameters = false; 8098 verifyFormat("void aaaaaaaaaaaaaaaaaa(int level,\n" 8099 " double *min_x,\n" 8100 " double *max_x,\n" 8101 " double *min_y,\n" 8102 " double *max_y,\n" 8103 " double *min_z,\n" 8104 " double *max_z, ) {}", 8105 NoBinPacking); 8106 } 8107 8108 TEST_F(FormatTest, IncorrectCodeTrailingStuff) { 8109 verifyFormat("void f() { return; }\n42"); 8110 verifyFormat("void f() {\n" 8111 " if (0)\n" 8112 " return;\n" 8113 "}\n" 8114 "42"); 8115 verifyFormat("void f() { return }\n42"); 8116 verifyFormat("void f() {\n" 8117 " if (0)\n" 8118 " return\n" 8119 "}\n" 8120 "42"); 8121 } 8122 8123 TEST_F(FormatTest, IncorrectCodeMissingSemicolon) { 8124 EXPECT_EQ("void f() { return }", format("void f ( ) { return }")); 8125 EXPECT_EQ("void f() {\n" 8126 " if (a)\n" 8127 " return\n" 8128 "}", 8129 format("void f ( ) { if ( a ) return }")); 8130 EXPECT_EQ("namespace N {\n" 8131 "void f()\n" 8132 "}", 8133 format("namespace N { void f() }")); 8134 EXPECT_EQ("namespace N {\n" 8135 "void f() {}\n" 8136 "void g()\n" 8137 "} // namespace N", 8138 format("namespace N { void f( ) { } void g( ) }")); 8139 } 8140 8141 TEST_F(FormatTest, IndentationWithinColumnLimitNotPossible) { 8142 verifyFormat("int aaaaaaaa =\n" 8143 " // Overlylongcomment\n" 8144 " b;", 8145 getLLVMStyleWithColumns(20)); 8146 verifyFormat("function(\n" 8147 " ShortArgument,\n" 8148 " LoooooooooooongArgument);\n", 8149 getLLVMStyleWithColumns(20)); 8150 } 8151 8152 TEST_F(FormatTest, IncorrectAccessSpecifier) { 8153 verifyFormat("public:"); 8154 verifyFormat("class A {\n" 8155 "public\n" 8156 " void f() {}\n" 8157 "};"); 8158 verifyFormat("public\n" 8159 "int qwerty;"); 8160 verifyFormat("public\n" 8161 "B {}"); 8162 verifyFormat("public\n" 8163 "{}"); 8164 verifyFormat("public\n" 8165 "B { int x; }"); 8166 } 8167 8168 TEST_F(FormatTest, IncorrectCodeUnbalancedBraces) { 8169 verifyFormat("{"); 8170 verifyFormat("#})"); 8171 verifyNoCrash("(/**/[:!] ?[)."); 8172 } 8173 8174 TEST_F(FormatTest, IncorrectUnbalancedBracesInMacrosWithUnicode) { 8175 // Found by oss-fuzz: 8176 // https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=8212 8177 FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp); 8178 Style.ColumnLimit = 60; 8179 verifyNoCrash( 8180 "\x23\x47\xff\x20\x28\xff\x3c\xff\x3f\xff\x20\x2f\x7b\x7a\xff\x20" 8181 "\xff\xff\xff\xca\xb5\xff\xff\xff\xff\x3a\x7b\x7d\xff\x20\xff\x20" 8182 "\xff\x74\xff\x20\x7d\x7d\xff\x7b\x3a\xff\x20\x71\xff\x20\xff\x0a", 8183 Style); 8184 } 8185 8186 TEST_F(FormatTest, IncorrectCodeDoNoWhile) { 8187 verifyFormat("do {\n}"); 8188 verifyFormat("do {\n}\n" 8189 "f();"); 8190 verifyFormat("do {\n}\n" 8191 "wheeee(fun);"); 8192 verifyFormat("do {\n" 8193 " f();\n" 8194 "}"); 8195 } 8196 8197 TEST_F(FormatTest, IncorrectCodeMissingParens) { 8198 verifyFormat("if {\n foo;\n foo();\n}"); 8199 verifyFormat("switch {\n foo;\n foo();\n}"); 8200 verifyIncompleteFormat("for {\n foo;\n foo();\n}"); 8201 verifyFormat("while {\n foo;\n foo();\n}"); 8202 verifyFormat("do {\n foo;\n foo();\n} while;"); 8203 } 8204 8205 TEST_F(FormatTest, DoesNotTouchUnwrappedLinesWithErrors) { 8206 verifyIncompleteFormat("namespace {\n" 8207 "class Foo { Foo (\n" 8208 "};\n" 8209 "} // namespace"); 8210 } 8211 8212 TEST_F(FormatTest, IncorrectCodeErrorDetection) { 8213 EXPECT_EQ("{\n {}\n", format("{\n{\n}\n")); 8214 EXPECT_EQ("{\n {}\n", format("{\n {\n}\n")); 8215 EXPECT_EQ("{\n {}\n", format("{\n {\n }\n")); 8216 EXPECT_EQ("{\n {}\n}\n}\n", format("{\n {\n }\n }\n}\n")); 8217 8218 EXPECT_EQ("{\n" 8219 " {\n" 8220 " breakme(\n" 8221 " qwe);\n" 8222 " }\n", 8223 format("{\n" 8224 " {\n" 8225 " breakme(qwe);\n" 8226 "}\n", 8227 getLLVMStyleWithColumns(10))); 8228 } 8229 8230 TEST_F(FormatTest, LayoutCallsInsideBraceInitializers) { 8231 verifyFormat("int x = {\n" 8232 " avariable,\n" 8233 " b(alongervariable)};", 8234 getLLVMStyleWithColumns(25)); 8235 } 8236 8237 TEST_F(FormatTest, LayoutBraceInitializersInReturnStatement) { 8238 verifyFormat("return (a)(b){1, 2, 3};"); 8239 } 8240 8241 TEST_F(FormatTest, LayoutCxx11BraceInitializers) { 8242 verifyFormat("vector<int> x{1, 2, 3, 4};"); 8243 verifyFormat("vector<int> x{\n" 8244 " 1,\n" 8245 " 2,\n" 8246 " 3,\n" 8247 " 4,\n" 8248 "};"); 8249 verifyFormat("vector<T> x{{}, {}, {}, {}};"); 8250 verifyFormat("f({1, 2});"); 8251 verifyFormat("auto v = Foo{-1};"); 8252 verifyFormat("f({1, 2}, {{2, 3}, {4, 5}}, c, {d});"); 8253 verifyFormat("Class::Class : member{1, 2, 3} {}"); 8254 verifyFormat("new vector<int>{1, 2, 3};"); 8255 verifyFormat("new int[3]{1, 2, 3};"); 8256 verifyFormat("new int{1};"); 8257 verifyFormat("return {arg1, arg2};"); 8258 verifyFormat("return {arg1, SomeType{parameter}};"); 8259 verifyFormat("int count = set<int>{f(), g(), h()}.size();"); 8260 verifyFormat("new T{arg1, arg2};"); 8261 verifyFormat("f(MyMap[{composite, key}]);"); 8262 verifyFormat("class Class {\n" 8263 " T member = {arg1, arg2};\n" 8264 "};"); 8265 verifyFormat("vector<int> foo = {::SomeGlobalFunction()};"); 8266 verifyFormat("const struct A a = {.a = 1, .b = 2};"); 8267 verifyFormat("const struct A a = {[0] = 1, [1] = 2};"); 8268 verifyFormat("static_assert(std::is_integral<int>{} + 0, \"\");"); 8269 verifyFormat("int a = std::is_integral<int>{} + 0;"); 8270 8271 verifyFormat("int foo(int i) { return fo1{}(i); }"); 8272 verifyFormat("int foo(int i) { return fo1{}(i); }"); 8273 verifyFormat("auto i = decltype(x){};"); 8274 verifyFormat("std::vector<int> v = {1, 0 /* comment */};"); 8275 verifyFormat("Node n{1, Node{1000}, //\n" 8276 " 2};"); 8277 verifyFormat("Aaaa aaaaaaa{\n" 8278 " {\n" 8279 " aaaa,\n" 8280 " },\n" 8281 "};"); 8282 verifyFormat("class C : public D {\n" 8283 " SomeClass SC{2};\n" 8284 "};"); 8285 verifyFormat("class C : public A {\n" 8286 " class D : public B {\n" 8287 " void f() { int i{2}; }\n" 8288 " };\n" 8289 "};"); 8290 verifyFormat("#define A {a, a},"); 8291 8292 // Avoid breaking between equal sign and opening brace 8293 FormatStyle AvoidBreakingFirstArgument = getLLVMStyle(); 8294 AvoidBreakingFirstArgument.PenaltyBreakBeforeFirstCallParameter = 200; 8295 verifyFormat("const std::unordered_map<std::string, int> MyHashTable =\n" 8296 " {{\"aaaaaaaaaaaaaaaaaaaaa\", 0},\n" 8297 " {\"bbbbbbbbbbbbbbbbbbbbb\", 1},\n" 8298 " {\"ccccccccccccccccccccc\", 2}};", 8299 AvoidBreakingFirstArgument); 8300 8301 // Binpacking only if there is no trailing comma 8302 verifyFormat("const Aaaaaa aaaaa = {aaaaaaaaaa, bbbbbbbbbb,\n" 8303 " cccccccccc, dddddddddd};", 8304 getLLVMStyleWithColumns(50)); 8305 verifyFormat("const Aaaaaa aaaaa = {\n" 8306 " aaaaaaaaaaa,\n" 8307 " bbbbbbbbbbb,\n" 8308 " ccccccccccc,\n" 8309 " ddddddddddd,\n" 8310 "};", 8311 getLLVMStyleWithColumns(50)); 8312 8313 // Cases where distinguising braced lists and blocks is hard. 8314 verifyFormat("vector<int> v{12} GUARDED_BY(mutex);"); 8315 verifyFormat("void f() {\n" 8316 " return; // comment\n" 8317 "}\n" 8318 "SomeType t;"); 8319 verifyFormat("void f() {\n" 8320 " if (a) {\n" 8321 " f();\n" 8322 " }\n" 8323 "}\n" 8324 "SomeType t;"); 8325 8326 // In combination with BinPackArguments = false. 8327 FormatStyle NoBinPacking = getLLVMStyle(); 8328 NoBinPacking.BinPackArguments = false; 8329 verifyFormat("const Aaaaaa aaaaa = {aaaaa,\n" 8330 " bbbbb,\n" 8331 " ccccc,\n" 8332 " ddddd,\n" 8333 " eeeee,\n" 8334 " ffffff,\n" 8335 " ggggg,\n" 8336 " hhhhhh,\n" 8337 " iiiiii,\n" 8338 " jjjjjj,\n" 8339 " kkkkkk};", 8340 NoBinPacking); 8341 verifyFormat("const Aaaaaa aaaaa = {\n" 8342 " aaaaa,\n" 8343 " bbbbb,\n" 8344 " ccccc,\n" 8345 " ddddd,\n" 8346 " eeeee,\n" 8347 " ffffff,\n" 8348 " ggggg,\n" 8349 " hhhhhh,\n" 8350 " iiiiii,\n" 8351 " jjjjjj,\n" 8352 " kkkkkk,\n" 8353 "};", 8354 NoBinPacking); 8355 verifyFormat( 8356 "const Aaaaaa aaaaa = {\n" 8357 " aaaaa, bbbbb, ccccc, ddddd, eeeee, ffffff, ggggg, hhhhhh,\n" 8358 " iiiiii, jjjjjj, kkkkkk, aaaaa, bbbbb, ccccc, ddddd, eeeee,\n" 8359 " ffffff, ggggg, hhhhhh, iiiiii, jjjjjj, kkkkkk,\n" 8360 "};", 8361 NoBinPacking); 8362 8363 NoBinPacking.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 8364 EXPECT_EQ("static uint8 CddDp83848Reg[] = {\n" 8365 " CDDDP83848_BMCR_REGISTER,\n" 8366 " CDDDP83848_BMSR_REGISTER,\n" 8367 " CDDDP83848_RBR_REGISTER};", 8368 format("static uint8 CddDp83848Reg[] = {CDDDP83848_BMCR_REGISTER,\n" 8369 " CDDDP83848_BMSR_REGISTER,\n" 8370 " CDDDP83848_RBR_REGISTER};", 8371 NoBinPacking)); 8372 8373 // FIXME: The alignment of these trailing comments might be bad. Then again, 8374 // this might be utterly useless in real code. 8375 verifyFormat("Constructor::Constructor()\n" 8376 " : some_value{ //\n" 8377 " aaaaaaa, //\n" 8378 " bbbbbbb} {}"); 8379 8380 // In braced lists, the first comment is always assumed to belong to the 8381 // first element. Thus, it can be moved to the next or previous line as 8382 // appropriate. 8383 EXPECT_EQ("function({// First element:\n" 8384 " 1,\n" 8385 " // Second element:\n" 8386 " 2});", 8387 format("function({\n" 8388 " // First element:\n" 8389 " 1,\n" 8390 " // Second element:\n" 8391 " 2});")); 8392 EXPECT_EQ("std::vector<int> MyNumbers{\n" 8393 " // First element:\n" 8394 " 1,\n" 8395 " // Second element:\n" 8396 " 2};", 8397 format("std::vector<int> MyNumbers{// First element:\n" 8398 " 1,\n" 8399 " // Second element:\n" 8400 " 2};", 8401 getLLVMStyleWithColumns(30))); 8402 // A trailing comma should still lead to an enforced line break and no 8403 // binpacking. 8404 EXPECT_EQ("vector<int> SomeVector = {\n" 8405 " // aaa\n" 8406 " 1,\n" 8407 " 2,\n" 8408 "};", 8409 format("vector<int> SomeVector = { // aaa\n" 8410 " 1, 2, };")); 8411 8412 // C++11 brace initializer list l-braces should not be treated any differently 8413 // when breaking before lambda bodies is enabled 8414 FormatStyle BreakBeforeLambdaBody = getLLVMStyle(); 8415 BreakBeforeLambdaBody.BreakBeforeBraces = FormatStyle::BS_Custom; 8416 BreakBeforeLambdaBody.BraceWrapping.BeforeLambdaBody = true; 8417 BreakBeforeLambdaBody.AlwaysBreakBeforeMultilineStrings = true; 8418 verifyFormat( 8419 "std::runtime_error{\n" 8420 " \"Long string which will force a break onto the next line...\"};", 8421 BreakBeforeLambdaBody); 8422 8423 FormatStyle ExtraSpaces = getLLVMStyle(); 8424 ExtraSpaces.Cpp11BracedListStyle = false; 8425 ExtraSpaces.ColumnLimit = 75; 8426 verifyFormat("vector<int> x{ 1, 2, 3, 4 };", ExtraSpaces); 8427 verifyFormat("vector<T> x{ {}, {}, {}, {} };", ExtraSpaces); 8428 verifyFormat("f({ 1, 2 });", ExtraSpaces); 8429 verifyFormat("auto v = Foo{ 1 };", ExtraSpaces); 8430 verifyFormat("f({ 1, 2 }, { { 2, 3 }, { 4, 5 } }, c, { d });", ExtraSpaces); 8431 verifyFormat("Class::Class : member{ 1, 2, 3 } {}", ExtraSpaces); 8432 verifyFormat("new vector<int>{ 1, 2, 3 };", ExtraSpaces); 8433 verifyFormat("new int[3]{ 1, 2, 3 };", ExtraSpaces); 8434 verifyFormat("return { arg1, arg2 };", ExtraSpaces); 8435 verifyFormat("return { arg1, SomeType{ parameter } };", ExtraSpaces); 8436 verifyFormat("int count = set<int>{ f(), g(), h() }.size();", ExtraSpaces); 8437 verifyFormat("new T{ arg1, arg2 };", ExtraSpaces); 8438 verifyFormat("f(MyMap[{ composite, key }]);", ExtraSpaces); 8439 verifyFormat("class Class {\n" 8440 " T member = { arg1, arg2 };\n" 8441 "};", 8442 ExtraSpaces); 8443 verifyFormat( 8444 "foo = aaaaaaaaaaa ? vector<int>{ aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 8445 " aaaaaaaaaaaaaaaaaaaa, aaaaa }\n" 8446 " : vector<int>{ bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" 8447 " bbbbbbbbbbbbbbbbbbbb, bbbbb };", 8448 ExtraSpaces); 8449 verifyFormat("DoSomethingWithVector({} /* No data */);", ExtraSpaces); 8450 verifyFormat("DoSomethingWithVector({ {} /* No data */ }, { { 1, 2 } });", 8451 ExtraSpaces); 8452 verifyFormat( 8453 "someFunction(OtherParam,\n" 8454 " BracedList{ // comment 1 (Forcing interesting break)\n" 8455 " param1, param2,\n" 8456 " // comment 2\n" 8457 " param3, param4 });", 8458 ExtraSpaces); 8459 verifyFormat( 8460 "std::this_thread::sleep_for(\n" 8461 " std::chrono::nanoseconds{ std::chrono::seconds{ 1 } } / 5);", 8462 ExtraSpaces); 8463 verifyFormat("std::vector<MyValues> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa{\n" 8464 " aaaaaaa,\n" 8465 " aaaaaaaaaa,\n" 8466 " aaaaa,\n" 8467 " aaaaaaaaaaaaaaa,\n" 8468 " aaa,\n" 8469 " aaaaaaaaaa,\n" 8470 " a,\n" 8471 " aaaaaaaaaaaaaaaaaaaaa,\n" 8472 " aaaaaaaaaaaa,\n" 8473 " aaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaa,\n" 8474 " aaaaaaa,\n" 8475 " a};"); 8476 verifyFormat("vector<int> foo = { ::SomeGlobalFunction() };", ExtraSpaces); 8477 verifyFormat("const struct A a = { .a = 1, .b = 2 };", ExtraSpaces); 8478 verifyFormat("const struct A a = { [0] = 1, [1] = 2 };", ExtraSpaces); 8479 8480 // Avoid breaking between initializer/equal sign and opening brace 8481 ExtraSpaces.PenaltyBreakBeforeFirstCallParameter = 200; 8482 verifyFormat("const std::unordered_map<std::string, int> MyHashTable = {\n" 8483 " { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n" 8484 " { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n" 8485 " { \"ccccccccccccccccccccc\", 2 }\n" 8486 "};", 8487 ExtraSpaces); 8488 verifyFormat("const std::unordered_map<std::string, int> MyHashTable{\n" 8489 " { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n" 8490 " { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n" 8491 " { \"ccccccccccccccccccccc\", 2 }\n" 8492 "};", 8493 ExtraSpaces); 8494 8495 FormatStyle SpaceBeforeBrace = getLLVMStyle(); 8496 SpaceBeforeBrace.SpaceBeforeCpp11BracedList = true; 8497 verifyFormat("vector<int> x {1, 2, 3, 4};", SpaceBeforeBrace); 8498 verifyFormat("f({}, {{}, {}}, MyMap[{k, v}]);", SpaceBeforeBrace); 8499 8500 FormatStyle SpaceBetweenBraces = getLLVMStyle(); 8501 SpaceBetweenBraces.SpacesInAngles = true; 8502 SpaceBetweenBraces.SpacesInParentheses = true; 8503 SpaceBetweenBraces.SpacesInSquareBrackets = true; 8504 verifyFormat("vector< int > x{ 1, 2, 3, 4 };", SpaceBetweenBraces); 8505 verifyFormat("f( {}, { {}, {} }, MyMap[ { k, v } ] );", SpaceBetweenBraces); 8506 verifyFormat("vector< int > x{ // comment 1\n" 8507 " 1, 2, 3, 4 };", 8508 SpaceBetweenBraces); 8509 SpaceBetweenBraces.ColumnLimit = 20; 8510 EXPECT_EQ("vector< int > x{\n" 8511 " 1, 2, 3, 4 };", 8512 format("vector<int>x{1,2,3,4};", SpaceBetweenBraces)); 8513 SpaceBetweenBraces.ColumnLimit = 24; 8514 EXPECT_EQ("vector< int > x{ 1, 2,\n" 8515 " 3, 4 };", 8516 format("vector<int>x{1,2,3,4};", SpaceBetweenBraces)); 8517 EXPECT_EQ("vector< int > x{\n" 8518 " 1,\n" 8519 " 2,\n" 8520 " 3,\n" 8521 " 4,\n" 8522 "};", 8523 format("vector<int>x{1,2,3,4,};", SpaceBetweenBraces)); 8524 verifyFormat("vector< int > x{};", SpaceBetweenBraces); 8525 SpaceBetweenBraces.SpaceInEmptyParentheses = true; 8526 verifyFormat("vector< int > x{ };", SpaceBetweenBraces); 8527 } 8528 8529 TEST_F(FormatTest, FormatSpacesInAngles) { 8530 FormatStyle SpaceInAngles = getLLVMStyle(); 8531 SpaceInAngles.SpacesInAngles = true; 8532 verifyFormat("vector< ::std::string > x1;", SpaceInAngles); 8533 verifyFormat("Foo< int, Bar > x2;", SpaceInAngles); 8534 verifyFormat("Foo< ::int, ::Bar > x3;", SpaceInAngles); 8535 8536 SpaceInAngles.SpacesInAngles = false; 8537 verifyFormat("vector<::std::string> x4;", SpaceInAngles); 8538 verifyFormat("vector<int> x5;", SpaceInAngles); 8539 verifyFormat("Foo<int, Bar> x6;", SpaceInAngles); 8540 verifyFormat("Foo<::int, ::Bar> x7;", SpaceInAngles); 8541 } 8542 8543 TEST_F(FormatTest, FormatsBracedListsInColumnLayout) { 8544 verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8545 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8546 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8547 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8548 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8549 " 1, 22, 333, 4444, 55555, 666666, 7777777};"); 8550 verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777, //\n" 8551 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8552 " 1, 22, 333, 4444, 55555, //\n" 8553 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8554 " 1, 22, 333, 4444, 55555, 666666, 7777777};"); 8555 verifyFormat( 8556 "vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8557 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8558 " 1, 22, 333, 4444, 55555, 666666, // comment\n" 8559 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 8560 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 8561 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 8562 " 7777777};"); 8563 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n" 8564 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n" 8565 " X86::R8, X86::R9, X86::R10, X86::R11, 0};"); 8566 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n" 8567 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n" 8568 " // Separating comment.\n" 8569 " X86::R8, X86::R9, X86::R10, X86::R11, 0};"); 8570 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n" 8571 " // Leading comment\n" 8572 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n" 8573 " X86::R8, X86::R9, X86::R10, X86::R11, 0};"); 8574 verifyFormat("vector<int> x = {1, 1, 1, 1,\n" 8575 " 1, 1, 1, 1};", 8576 getLLVMStyleWithColumns(39)); 8577 verifyFormat("vector<int> x = {1, 1, 1, 1,\n" 8578 " 1, 1, 1, 1};", 8579 getLLVMStyleWithColumns(38)); 8580 verifyFormat("vector<int> aaaaaaaaaaaaaaaaaaaaaa = {\n" 8581 " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};", 8582 getLLVMStyleWithColumns(43)); 8583 verifyFormat( 8584 "static unsigned SomeValues[10][3] = {\n" 8585 " {1, 4, 0}, {4, 9, 0}, {4, 5, 9}, {8, 5, 4}, {1, 8, 4},\n" 8586 " {10, 1, 6}, {11, 0, 9}, {2, 11, 9}, {5, 2, 9}, {11, 2, 7}};"); 8587 verifyFormat("static auto fields = new vector<string>{\n" 8588 " \"aaaaaaaaaaaaa\",\n" 8589 " \"aaaaaaaaaaaaa\",\n" 8590 " \"aaaaaaaaaaaa\",\n" 8591 " \"aaaaaaaaaaaaaa\",\n" 8592 " \"aaaaaaaaaaaaaaaaaaaaaaaaa\",\n" 8593 " \"aaaaaaaaaaaa\",\n" 8594 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",\n" 8595 "};"); 8596 verifyFormat("vector<int> x = {1, 2, 3, 4, aaaaaaaaaaaaaaaaa, 6};"); 8597 verifyFormat("vector<int> x = {1, aaaaaaaaaaaaaaaaaaaaaa,\n" 8598 " 2, bbbbbbbbbbbbbbbbbbbbbb,\n" 8599 " 3, cccccccccccccccccccccc};", 8600 getLLVMStyleWithColumns(60)); 8601 8602 // Trailing commas. 8603 verifyFormat("vector<int> x = {\n" 8604 " 1, 1, 1, 1, 1, 1, 1, 1,\n" 8605 "};", 8606 getLLVMStyleWithColumns(39)); 8607 verifyFormat("vector<int> x = {\n" 8608 " 1, 1, 1, 1, 1, 1, 1, 1, //\n" 8609 "};", 8610 getLLVMStyleWithColumns(39)); 8611 verifyFormat("vector<int> x = {1, 1, 1, 1,\n" 8612 " 1, 1, 1, 1,\n" 8613 " /**/ /**/};", 8614 getLLVMStyleWithColumns(39)); 8615 8616 // Trailing comment in the first line. 8617 verifyFormat("vector<int> iiiiiiiiiiiiiii = { //\n" 8618 " 1111111111, 2222222222, 33333333333, 4444444444, //\n" 8619 " 111111111, 222222222, 3333333333, 444444444, //\n" 8620 " 11111111, 22222222, 333333333, 44444444};"); 8621 // Trailing comment in the last line. 8622 verifyFormat("int aaaaa[] = {\n" 8623 " 1, 2, 3, // comment\n" 8624 " 4, 5, 6 // comment\n" 8625 "};"); 8626 8627 // With nested lists, we should either format one item per line or all nested 8628 // lists one on line. 8629 // FIXME: For some nested lists, we can do better. 8630 verifyFormat("return {{aaaaaaaaaaaaaaaaaaaaa},\n" 8631 " {aaaaaaaaaaaaaaaaaaa},\n" 8632 " {aaaaaaaaaaaaaaaaaaaaa},\n" 8633 " {aaaaaaaaaaaaaaaaa}};", 8634 getLLVMStyleWithColumns(60)); 8635 verifyFormat( 8636 "SomeStruct my_struct_array = {\n" 8637 " {aaaaaa, aaaaaaaa, aaaaaaaaaa, aaaaaaaaa, aaaaaaaaa, aaaaaaaaaa,\n" 8638 " aaaaaaaaaaaaa, aaaaaaa, aaa},\n" 8639 " {aaa, aaa},\n" 8640 " {aaa, aaa},\n" 8641 " {aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaa},\n" 8642 " {aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaa,\n" 8643 " aaaaaaaaaaaa, a, aaaaaaaaaa, aaaaaaaaa, aaa}};"); 8644 8645 // No column layout should be used here. 8646 verifyFormat("aaaaaaaaaaaaaaa = {aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0, 0,\n" 8647 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb};"); 8648 8649 verifyNoCrash("a<,"); 8650 8651 // No braced initializer here. 8652 verifyFormat("void f() {\n" 8653 " struct Dummy {};\n" 8654 " f(v);\n" 8655 "}"); 8656 8657 // Long lists should be formatted in columns even if they are nested. 8658 verifyFormat( 8659 "vector<int> x = function({1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8660 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8661 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8662 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8663 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8664 " 1, 22, 333, 4444, 55555, 666666, 7777777});"); 8665 8666 // Allow "single-column" layout even if that violates the column limit. There 8667 // isn't going to be a better way. 8668 verifyFormat("std::vector<int> a = {\n" 8669 " aaaaaaaa,\n" 8670 " aaaaaaaa,\n" 8671 " aaaaaaaa,\n" 8672 " aaaaaaaa,\n" 8673 " aaaaaaaaaa,\n" 8674 " aaaaaaaa,\n" 8675 " aaaaaaaaaaaaaaaaaaaaaaaaaaa};", 8676 getLLVMStyleWithColumns(30)); 8677 verifyFormat("vector<int> aaaa = {\n" 8678 " aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 8679 " aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 8680 " aaaaaa.aaaaaaa,\n" 8681 " aaaaaa.aaaaaaa,\n" 8682 " aaaaaa.aaaaaaa,\n" 8683 " aaaaaa.aaaaaaa,\n" 8684 "};"); 8685 8686 // Don't create hanging lists. 8687 verifyFormat("someFunction(Param, {List1, List2,\n" 8688 " List3});", 8689 getLLVMStyleWithColumns(35)); 8690 verifyFormat("someFunction(Param, Param,\n" 8691 " {List1, List2,\n" 8692 " List3});", 8693 getLLVMStyleWithColumns(35)); 8694 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa, {},\n" 8695 " aaaaaaaaaaaaaaaaaaaaaaa);"); 8696 } 8697 8698 TEST_F(FormatTest, PullTrivialFunctionDefinitionsIntoSingleLine) { 8699 FormatStyle DoNotMerge = getLLVMStyle(); 8700 DoNotMerge.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 8701 8702 verifyFormat("void f() { return 42; }"); 8703 verifyFormat("void f() {\n" 8704 " return 42;\n" 8705 "}", 8706 DoNotMerge); 8707 verifyFormat("void f() {\n" 8708 " // Comment\n" 8709 "}"); 8710 verifyFormat("{\n" 8711 "#error {\n" 8712 " int a;\n" 8713 "}"); 8714 verifyFormat("{\n" 8715 " int a;\n" 8716 "#error {\n" 8717 "}"); 8718 verifyFormat("void f() {} // comment"); 8719 verifyFormat("void f() { int a; } // comment"); 8720 verifyFormat("void f() {\n" 8721 "} // comment", 8722 DoNotMerge); 8723 verifyFormat("void f() {\n" 8724 " int a;\n" 8725 "} // comment", 8726 DoNotMerge); 8727 verifyFormat("void f() {\n" 8728 "} // comment", 8729 getLLVMStyleWithColumns(15)); 8730 8731 verifyFormat("void f() { return 42; }", getLLVMStyleWithColumns(23)); 8732 verifyFormat("void f() {\n return 42;\n}", getLLVMStyleWithColumns(22)); 8733 8734 verifyFormat("void f() {}", getLLVMStyleWithColumns(11)); 8735 verifyFormat("void f() {\n}", getLLVMStyleWithColumns(10)); 8736 verifyFormat("class C {\n" 8737 " C()\n" 8738 " : iiiiiiii(nullptr),\n" 8739 " kkkkkkk(nullptr),\n" 8740 " mmmmmmm(nullptr),\n" 8741 " nnnnnnn(nullptr) {}\n" 8742 "};", 8743 getGoogleStyle()); 8744 8745 FormatStyle NoColumnLimit = getLLVMStyle(); 8746 NoColumnLimit.ColumnLimit = 0; 8747 EXPECT_EQ("A() : b(0) {}", format("A():b(0){}", NoColumnLimit)); 8748 EXPECT_EQ("class C {\n" 8749 " A() : b(0) {}\n" 8750 "};", 8751 format("class C{A():b(0){}};", NoColumnLimit)); 8752 EXPECT_EQ("A()\n" 8753 " : b(0) {\n" 8754 "}", 8755 format("A()\n:b(0)\n{\n}", NoColumnLimit)); 8756 8757 FormatStyle DoNotMergeNoColumnLimit = NoColumnLimit; 8758 DoNotMergeNoColumnLimit.AllowShortFunctionsOnASingleLine = 8759 FormatStyle::SFS_None; 8760 EXPECT_EQ("A()\n" 8761 " : b(0) {\n" 8762 "}", 8763 format("A():b(0){}", DoNotMergeNoColumnLimit)); 8764 EXPECT_EQ("A()\n" 8765 " : b(0) {\n" 8766 "}", 8767 format("A()\n:b(0)\n{\n}", DoNotMergeNoColumnLimit)); 8768 8769 verifyFormat("#define A \\\n" 8770 " void f() { \\\n" 8771 " int i; \\\n" 8772 " }", 8773 getLLVMStyleWithColumns(20)); 8774 verifyFormat("#define A \\\n" 8775 " void f() { int i; }", 8776 getLLVMStyleWithColumns(21)); 8777 verifyFormat("#define A \\\n" 8778 " void f() { \\\n" 8779 " int i; \\\n" 8780 " } \\\n" 8781 " int j;", 8782 getLLVMStyleWithColumns(22)); 8783 verifyFormat("#define A \\\n" 8784 " void f() { int i; } \\\n" 8785 " int j;", 8786 getLLVMStyleWithColumns(23)); 8787 } 8788 8789 TEST_F(FormatTest, PullEmptyFunctionDefinitionsIntoSingleLine) { 8790 FormatStyle MergeEmptyOnly = getLLVMStyle(); 8791 MergeEmptyOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty; 8792 verifyFormat("class C {\n" 8793 " int f() {}\n" 8794 "};", 8795 MergeEmptyOnly); 8796 verifyFormat("class C {\n" 8797 " int f() {\n" 8798 " return 42;\n" 8799 " }\n" 8800 "};", 8801 MergeEmptyOnly); 8802 verifyFormat("int f() {}", MergeEmptyOnly); 8803 verifyFormat("int f() {\n" 8804 " return 42;\n" 8805 "}", 8806 MergeEmptyOnly); 8807 8808 // Also verify behavior when BraceWrapping.AfterFunction = true 8809 MergeEmptyOnly.BreakBeforeBraces = FormatStyle::BS_Custom; 8810 MergeEmptyOnly.BraceWrapping.AfterFunction = true; 8811 verifyFormat("int f() {}", MergeEmptyOnly); 8812 verifyFormat("class C {\n" 8813 " int f() {}\n" 8814 "};", 8815 MergeEmptyOnly); 8816 } 8817 8818 TEST_F(FormatTest, PullInlineFunctionDefinitionsIntoSingleLine) { 8819 FormatStyle MergeInlineOnly = getLLVMStyle(); 8820 MergeInlineOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; 8821 verifyFormat("class C {\n" 8822 " int f() { return 42; }\n" 8823 "};", 8824 MergeInlineOnly); 8825 verifyFormat("int f() {\n" 8826 " return 42;\n" 8827 "}", 8828 MergeInlineOnly); 8829 8830 // SFS_Inline implies SFS_Empty 8831 verifyFormat("class C {\n" 8832 " int f() {}\n" 8833 "};", 8834 MergeInlineOnly); 8835 verifyFormat("int f() {}", MergeInlineOnly); 8836 8837 // Also verify behavior when BraceWrapping.AfterFunction = true 8838 MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom; 8839 MergeInlineOnly.BraceWrapping.AfterFunction = true; 8840 verifyFormat("class C {\n" 8841 " int f() { return 42; }\n" 8842 "};", 8843 MergeInlineOnly); 8844 verifyFormat("int f()\n" 8845 "{\n" 8846 " return 42;\n" 8847 "}", 8848 MergeInlineOnly); 8849 8850 // SFS_Inline implies SFS_Empty 8851 verifyFormat("int f() {}", MergeInlineOnly); 8852 verifyFormat("class C {\n" 8853 " int f() {}\n" 8854 "};", 8855 MergeInlineOnly); 8856 } 8857 8858 TEST_F(FormatTest, PullInlineOnlyFunctionDefinitionsIntoSingleLine) { 8859 FormatStyle MergeInlineOnly = getLLVMStyle(); 8860 MergeInlineOnly.AllowShortFunctionsOnASingleLine = 8861 FormatStyle::SFS_InlineOnly; 8862 verifyFormat("class C {\n" 8863 " int f() { return 42; }\n" 8864 "};", 8865 MergeInlineOnly); 8866 verifyFormat("int f() {\n" 8867 " return 42;\n" 8868 "}", 8869 MergeInlineOnly); 8870 8871 // SFS_InlineOnly does not imply SFS_Empty 8872 verifyFormat("class C {\n" 8873 " int f() {}\n" 8874 "};", 8875 MergeInlineOnly); 8876 verifyFormat("int f() {\n" 8877 "}", 8878 MergeInlineOnly); 8879 8880 // Also verify behavior when BraceWrapping.AfterFunction = true 8881 MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom; 8882 MergeInlineOnly.BraceWrapping.AfterFunction = true; 8883 verifyFormat("class C {\n" 8884 " int f() { return 42; }\n" 8885 "};", 8886 MergeInlineOnly); 8887 verifyFormat("int f()\n" 8888 "{\n" 8889 " return 42;\n" 8890 "}", 8891 MergeInlineOnly); 8892 8893 // SFS_InlineOnly does not imply SFS_Empty 8894 verifyFormat("int f()\n" 8895 "{\n" 8896 "}", 8897 MergeInlineOnly); 8898 verifyFormat("class C {\n" 8899 " int f() {}\n" 8900 "};", 8901 MergeInlineOnly); 8902 } 8903 8904 TEST_F(FormatTest, SplitEmptyFunction) { 8905 FormatStyle Style = getLLVMStyle(); 8906 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 8907 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8908 Style.BraceWrapping.AfterFunction = true; 8909 Style.BraceWrapping.SplitEmptyFunction = false; 8910 Style.ColumnLimit = 40; 8911 8912 verifyFormat("int f()\n" 8913 "{}", 8914 Style); 8915 verifyFormat("int f()\n" 8916 "{\n" 8917 " return 42;\n" 8918 "}", 8919 Style); 8920 verifyFormat("int f()\n" 8921 "{\n" 8922 " // some comment\n" 8923 "}", 8924 Style); 8925 8926 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty; 8927 verifyFormat("int f() {}", Style); 8928 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8929 "{}", 8930 Style); 8931 verifyFormat("int f()\n" 8932 "{\n" 8933 " return 0;\n" 8934 "}", 8935 Style); 8936 8937 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; 8938 verifyFormat("class Foo {\n" 8939 " int f() {}\n" 8940 "};\n", 8941 Style); 8942 verifyFormat("class Foo {\n" 8943 " int f() { return 0; }\n" 8944 "};\n", 8945 Style); 8946 verifyFormat("class Foo {\n" 8947 " int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8948 " {}\n" 8949 "};\n", 8950 Style); 8951 verifyFormat("class Foo {\n" 8952 " int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8953 " {\n" 8954 " return 0;\n" 8955 " }\n" 8956 "};\n", 8957 Style); 8958 8959 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 8960 verifyFormat("int f() {}", Style); 8961 verifyFormat("int f() { return 0; }", Style); 8962 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8963 "{}", 8964 Style); 8965 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8966 "{\n" 8967 " return 0;\n" 8968 "}", 8969 Style); 8970 } 8971 TEST_F(FormatTest, KeepShortFunctionAfterPPElse) { 8972 FormatStyle Style = getLLVMStyle(); 8973 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 8974 verifyFormat("#ifdef A\n" 8975 "int f() {}\n" 8976 "#else\n" 8977 "int g() {}\n" 8978 "#endif", 8979 Style); 8980 } 8981 8982 TEST_F(FormatTest, SplitEmptyClass) { 8983 FormatStyle Style = getLLVMStyle(); 8984 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8985 Style.BraceWrapping.AfterClass = true; 8986 Style.BraceWrapping.SplitEmptyRecord = false; 8987 8988 verifyFormat("class Foo\n" 8989 "{};", 8990 Style); 8991 verifyFormat("/* something */ class Foo\n" 8992 "{};", 8993 Style); 8994 verifyFormat("template <typename X> class Foo\n" 8995 "{};", 8996 Style); 8997 verifyFormat("class Foo\n" 8998 "{\n" 8999 " Foo();\n" 9000 "};", 9001 Style); 9002 verifyFormat("typedef class Foo\n" 9003 "{\n" 9004 "} Foo_t;", 9005 Style); 9006 } 9007 9008 TEST_F(FormatTest, SplitEmptyStruct) { 9009 FormatStyle Style = getLLVMStyle(); 9010 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 9011 Style.BraceWrapping.AfterStruct = true; 9012 Style.BraceWrapping.SplitEmptyRecord = false; 9013 9014 verifyFormat("struct Foo\n" 9015 "{};", 9016 Style); 9017 verifyFormat("/* something */ struct Foo\n" 9018 "{};", 9019 Style); 9020 verifyFormat("template <typename X> struct Foo\n" 9021 "{};", 9022 Style); 9023 verifyFormat("struct Foo\n" 9024 "{\n" 9025 " Foo();\n" 9026 "};", 9027 Style); 9028 verifyFormat("typedef struct Foo\n" 9029 "{\n" 9030 "} Foo_t;", 9031 Style); 9032 // typedef struct Bar {} Bar_t; 9033 } 9034 9035 TEST_F(FormatTest, SplitEmptyUnion) { 9036 FormatStyle Style = getLLVMStyle(); 9037 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 9038 Style.BraceWrapping.AfterUnion = true; 9039 Style.BraceWrapping.SplitEmptyRecord = false; 9040 9041 verifyFormat("union Foo\n" 9042 "{};", 9043 Style); 9044 verifyFormat("/* something */ union Foo\n" 9045 "{};", 9046 Style); 9047 verifyFormat("union Foo\n" 9048 "{\n" 9049 " A,\n" 9050 "};", 9051 Style); 9052 verifyFormat("typedef union Foo\n" 9053 "{\n" 9054 "} Foo_t;", 9055 Style); 9056 } 9057 9058 TEST_F(FormatTest, SplitEmptyNamespace) { 9059 FormatStyle Style = getLLVMStyle(); 9060 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 9061 Style.BraceWrapping.AfterNamespace = true; 9062 Style.BraceWrapping.SplitEmptyNamespace = false; 9063 9064 verifyFormat("namespace Foo\n" 9065 "{};", 9066 Style); 9067 verifyFormat("/* something */ namespace Foo\n" 9068 "{};", 9069 Style); 9070 verifyFormat("inline namespace Foo\n" 9071 "{};", 9072 Style); 9073 verifyFormat("/* something */ inline namespace Foo\n" 9074 "{};", 9075 Style); 9076 verifyFormat("export namespace Foo\n" 9077 "{};", 9078 Style); 9079 verifyFormat("namespace Foo\n" 9080 "{\n" 9081 "void Bar();\n" 9082 "};", 9083 Style); 9084 } 9085 9086 TEST_F(FormatTest, NeverMergeShortRecords) { 9087 FormatStyle Style = getLLVMStyle(); 9088 9089 verifyFormat("class Foo {\n" 9090 " Foo();\n" 9091 "};", 9092 Style); 9093 verifyFormat("typedef class Foo {\n" 9094 " Foo();\n" 9095 "} Foo_t;", 9096 Style); 9097 verifyFormat("struct Foo {\n" 9098 " Foo();\n" 9099 "};", 9100 Style); 9101 verifyFormat("typedef struct Foo {\n" 9102 " Foo();\n" 9103 "} Foo_t;", 9104 Style); 9105 verifyFormat("union Foo {\n" 9106 " A,\n" 9107 "};", 9108 Style); 9109 verifyFormat("typedef union Foo {\n" 9110 " A,\n" 9111 "} Foo_t;", 9112 Style); 9113 verifyFormat("namespace Foo {\n" 9114 "void Bar();\n" 9115 "};", 9116 Style); 9117 9118 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 9119 Style.BraceWrapping.AfterClass = true; 9120 Style.BraceWrapping.AfterStruct = true; 9121 Style.BraceWrapping.AfterUnion = true; 9122 Style.BraceWrapping.AfterNamespace = true; 9123 verifyFormat("class Foo\n" 9124 "{\n" 9125 " Foo();\n" 9126 "};", 9127 Style); 9128 verifyFormat("typedef class Foo\n" 9129 "{\n" 9130 " Foo();\n" 9131 "} Foo_t;", 9132 Style); 9133 verifyFormat("struct Foo\n" 9134 "{\n" 9135 " Foo();\n" 9136 "};", 9137 Style); 9138 verifyFormat("typedef struct Foo\n" 9139 "{\n" 9140 " Foo();\n" 9141 "} Foo_t;", 9142 Style); 9143 verifyFormat("union Foo\n" 9144 "{\n" 9145 " A,\n" 9146 "};", 9147 Style); 9148 verifyFormat("typedef union Foo\n" 9149 "{\n" 9150 " A,\n" 9151 "} Foo_t;", 9152 Style); 9153 verifyFormat("namespace Foo\n" 9154 "{\n" 9155 "void Bar();\n" 9156 "};", 9157 Style); 9158 } 9159 9160 TEST_F(FormatTest, UnderstandContextOfRecordTypeKeywords) { 9161 // Elaborate type variable declarations. 9162 verifyFormat("struct foo a = {bar};\nint n;"); 9163 verifyFormat("class foo a = {bar};\nint n;"); 9164 verifyFormat("union foo a = {bar};\nint n;"); 9165 9166 // Elaborate types inside function definitions. 9167 verifyFormat("struct foo f() {}\nint n;"); 9168 verifyFormat("class foo f() {}\nint n;"); 9169 verifyFormat("union foo f() {}\nint n;"); 9170 9171 // Templates. 9172 verifyFormat("template <class X> void f() {}\nint n;"); 9173 verifyFormat("template <struct X> void f() {}\nint n;"); 9174 verifyFormat("template <union X> void f() {}\nint n;"); 9175 9176 // Actual definitions... 9177 verifyFormat("struct {\n} n;"); 9178 verifyFormat( 9179 "template <template <class T, class Y>, class Z> class X {\n} n;"); 9180 verifyFormat("union Z {\n int n;\n} x;"); 9181 verifyFormat("class MACRO Z {\n} n;"); 9182 verifyFormat("class MACRO(X) Z {\n} n;"); 9183 verifyFormat("class __attribute__(X) Z {\n} n;"); 9184 verifyFormat("class __declspec(X) Z {\n} n;"); 9185 verifyFormat("class A##B##C {\n} n;"); 9186 verifyFormat("class alignas(16) Z {\n} n;"); 9187 verifyFormat("class MACRO(X) alignas(16) Z {\n} n;"); 9188 verifyFormat("class MACROA MACRO(X) Z {\n} n;"); 9189 9190 // Redefinition from nested context: 9191 verifyFormat("class A::B::C {\n} n;"); 9192 9193 // Template definitions. 9194 verifyFormat( 9195 "template <typename F>\n" 9196 "Matcher(const Matcher<F> &Other,\n" 9197 " typename enable_if_c<is_base_of<F, T>::value &&\n" 9198 " !is_same<F, T>::value>::type * = 0)\n" 9199 " : Implementation(new ImplicitCastMatcher<F>(Other)) {}"); 9200 9201 // FIXME: This is still incorrectly handled at the formatter side. 9202 verifyFormat("template <> struct X < 15, i<3 && 42 < 50 && 33 < 28> {};"); 9203 verifyFormat("int i = SomeFunction(a<b, a> b);"); 9204 9205 // FIXME: 9206 // This now gets parsed incorrectly as class definition. 9207 // verifyFormat("class A<int> f() {\n}\nint n;"); 9208 9209 // Elaborate types where incorrectly parsing the structural element would 9210 // break the indent. 9211 verifyFormat("if (true)\n" 9212 " class X x;\n" 9213 "else\n" 9214 " f();\n"); 9215 9216 // This is simply incomplete. Formatting is not important, but must not crash. 9217 verifyFormat("class A:"); 9218 } 9219 9220 TEST_F(FormatTest, DoNotInterfereWithErrorAndWarning) { 9221 EXPECT_EQ("#error Leave all white!!!!! space* alone!\n", 9222 format("#error Leave all white!!!!! space* alone!\n")); 9223 EXPECT_EQ( 9224 "#warning Leave all white!!!!! space* alone!\n", 9225 format("#warning Leave all white!!!!! space* alone!\n")); 9226 EXPECT_EQ("#error 1", format(" # error 1")); 9227 EXPECT_EQ("#warning 1", format(" # warning 1")); 9228 } 9229 9230 TEST_F(FormatTest, FormatHashIfExpressions) { 9231 verifyFormat("#if AAAA && BBBB"); 9232 verifyFormat("#if (AAAA && BBBB)"); 9233 verifyFormat("#elif (AAAA && BBBB)"); 9234 // FIXME: Come up with a better indentation for #elif. 9235 verifyFormat( 9236 "#if !defined(AAAAAAA) && (defined CCCCCC || defined DDDDDD) && \\\n" 9237 " defined(BBBBBBBB)\n" 9238 "#elif !defined(AAAAAA) && (defined CCCCC || defined DDDDDD) && \\\n" 9239 " defined(BBBBBBBB)\n" 9240 "#endif", 9241 getLLVMStyleWithColumns(65)); 9242 } 9243 9244 TEST_F(FormatTest, MergeHandlingInTheFaceOfPreprocessorDirectives) { 9245 FormatStyle AllowsMergedIf = getGoogleStyle(); 9246 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = 9247 FormatStyle::SIS_WithoutElse; 9248 verifyFormat("void f() { f(); }\n#error E", AllowsMergedIf); 9249 verifyFormat("if (true) return 42;\n#error E", AllowsMergedIf); 9250 verifyFormat("if (true)\n#error E\n return 42;", AllowsMergedIf); 9251 EXPECT_EQ("if (true) return 42;", 9252 format("if (true)\nreturn 42;", AllowsMergedIf)); 9253 FormatStyle ShortMergedIf = AllowsMergedIf; 9254 ShortMergedIf.ColumnLimit = 25; 9255 verifyFormat("#define A \\\n" 9256 " if (true) return 42;", 9257 ShortMergedIf); 9258 verifyFormat("#define A \\\n" 9259 " f(); \\\n" 9260 " if (true)\n" 9261 "#define B", 9262 ShortMergedIf); 9263 verifyFormat("#define A \\\n" 9264 " f(); \\\n" 9265 " if (true)\n" 9266 "g();", 9267 ShortMergedIf); 9268 verifyFormat("{\n" 9269 "#ifdef A\n" 9270 " // Comment\n" 9271 " if (true) continue;\n" 9272 "#endif\n" 9273 " // Comment\n" 9274 " if (true) continue;\n" 9275 "}", 9276 ShortMergedIf); 9277 ShortMergedIf.ColumnLimit = 33; 9278 verifyFormat("#define A \\\n" 9279 " if constexpr (true) return 42;", 9280 ShortMergedIf); 9281 verifyFormat("#define A \\\n" 9282 " if CONSTEXPR (true) return 42;", 9283 ShortMergedIf); 9284 ShortMergedIf.ColumnLimit = 29; 9285 verifyFormat("#define A \\\n" 9286 " if (aaaaaaaaaa) return 1; \\\n" 9287 " return 2;", 9288 ShortMergedIf); 9289 ShortMergedIf.ColumnLimit = 28; 9290 verifyFormat("#define A \\\n" 9291 " if (aaaaaaaaaa) \\\n" 9292 " return 1; \\\n" 9293 " return 2;", 9294 ShortMergedIf); 9295 verifyFormat("#define A \\\n" 9296 " if constexpr (aaaaaaa) \\\n" 9297 " return 1; \\\n" 9298 " return 2;", 9299 ShortMergedIf); 9300 verifyFormat("#define A \\\n" 9301 " if CONSTEXPR (aaaaaaa) \\\n" 9302 " return 1; \\\n" 9303 " return 2;", 9304 ShortMergedIf); 9305 } 9306 9307 TEST_F(FormatTest, FormatStarDependingOnContext) { 9308 verifyFormat("void f(int *a);"); 9309 verifyFormat("void f() { f(fint * b); }"); 9310 verifyFormat("class A {\n void f(int *a);\n};"); 9311 verifyFormat("class A {\n int *a;\n};"); 9312 verifyFormat("namespace a {\n" 9313 "namespace b {\n" 9314 "class A {\n" 9315 " void f() {}\n" 9316 " int *a;\n" 9317 "};\n" 9318 "} // namespace b\n" 9319 "} // namespace a"); 9320 } 9321 9322 TEST_F(FormatTest, SpecialTokensAtEndOfLine) { 9323 verifyFormat("while"); 9324 verifyFormat("operator"); 9325 } 9326 9327 TEST_F(FormatTest, SkipsDeeplyNestedLines) { 9328 // This code would be painfully slow to format if we didn't skip it. 9329 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 9330 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 9331 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 9332 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 9333 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 9334 "A(1, 1)\n" 9335 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" // 10x 9336 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9337 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9338 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9339 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9340 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9341 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9342 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9343 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9344 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1);\n"); 9345 // Deeply nested part is untouched, rest is formatted. 9346 EXPECT_EQ(std::string("int i;\n") + Code + "int j;\n", 9347 format(std::string("int i;\n") + Code + "int j;\n", 9348 getLLVMStyle(), SC_ExpectIncomplete)); 9349 } 9350 9351 //===----------------------------------------------------------------------===// 9352 // Objective-C tests. 9353 //===----------------------------------------------------------------------===// 9354 9355 TEST_F(FormatTest, FormatForObjectiveCMethodDecls) { 9356 verifyFormat("- (void)sendAction:(SEL)aSelector to:(BOOL)anObject;"); 9357 EXPECT_EQ("- (NSUInteger)indexOfObject:(id)anObject;", 9358 format("-(NSUInteger)indexOfObject:(id)anObject;")); 9359 EXPECT_EQ("- (NSInteger)Mthod1;", format("-(NSInteger)Mthod1;")); 9360 EXPECT_EQ("+ (id)Mthod2;", format("+(id)Mthod2;")); 9361 EXPECT_EQ("- (NSInteger)Method3:(id)anObject;", 9362 format("-(NSInteger)Method3:(id)anObject;")); 9363 EXPECT_EQ("- (NSInteger)Method4:(id)anObject;", 9364 format("-(NSInteger)Method4:(id)anObject;")); 9365 EXPECT_EQ("- (NSInteger)Method5:(id)anObject:(id)AnotherObject;", 9366 format("-(NSInteger)Method5:(id)anObject:(id)AnotherObject;")); 9367 EXPECT_EQ("- (id)Method6:(id)A:(id)B:(id)C:(id)D;", 9368 format("- (id)Method6:(id)A:(id)B:(id)C:(id)D;")); 9369 EXPECT_EQ("- (void)sendAction:(SEL)aSelector to:(id)anObject " 9370 "forAllCells:(BOOL)flag;", 9371 format("- (void)sendAction:(SEL)aSelector to:(id)anObject " 9372 "forAllCells:(BOOL)flag;")); 9373 9374 // Very long objectiveC method declaration. 9375 verifyFormat("- (void)aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n" 9376 " (SoooooooooooooooooooooomeType *)bbbbbbbbbb;"); 9377 verifyFormat("- (NSUInteger)indexOfObject:(id)anObject\n" 9378 " inRange:(NSRange)range\n" 9379 " outRange:(NSRange)out_range\n" 9380 " outRange1:(NSRange)out_range1\n" 9381 " outRange2:(NSRange)out_range2\n" 9382 " outRange3:(NSRange)out_range3\n" 9383 " outRange4:(NSRange)out_range4\n" 9384 " outRange5:(NSRange)out_range5\n" 9385 " outRange6:(NSRange)out_range6\n" 9386 " outRange7:(NSRange)out_range7\n" 9387 " outRange8:(NSRange)out_range8\n" 9388 " outRange9:(NSRange)out_range9;"); 9389 9390 // When the function name has to be wrapped. 9391 FormatStyle Style = getLLVMStyle(); 9392 // ObjC ignores IndentWrappedFunctionNames when wrapping methods 9393 // and always indents instead. 9394 Style.IndentWrappedFunctionNames = false; 9395 verifyFormat("- (SomeLooooooooooooooooooooongType *)\n" 9396 " veryLooooooooooongName:(NSString)aaaaaaaaaaaaaa\n" 9397 " anotherName:(NSString)bbbbbbbbbbbbbb {\n" 9398 "}", 9399 Style); 9400 Style.IndentWrappedFunctionNames = true; 9401 verifyFormat("- (SomeLooooooooooooooooooooongType *)\n" 9402 " veryLooooooooooongName:(NSString)cccccccccccccc\n" 9403 " anotherName:(NSString)dddddddddddddd {\n" 9404 "}", 9405 Style); 9406 9407 verifyFormat("- (int)sum:(vector<int>)numbers;"); 9408 verifyGoogleFormat("- (void)setDelegate:(id<Protocol>)delegate;"); 9409 // FIXME: In LLVM style, there should be a space in front of a '<' for ObjC 9410 // protocol lists (but not for template classes): 9411 // verifyFormat("- (void)setDelegate:(id <Protocol>)delegate;"); 9412 9413 verifyFormat("- (int (*)())foo:(int (*)())f;"); 9414 verifyGoogleFormat("- (int (*)())foo:(int (*)())foo;"); 9415 9416 // If there's no return type (very rare in practice!), LLVM and Google style 9417 // agree. 9418 verifyFormat("- foo;"); 9419 verifyFormat("- foo:(int)f;"); 9420 verifyGoogleFormat("- foo:(int)foo;"); 9421 } 9422 9423 TEST_F(FormatTest, BreaksStringLiterals) { 9424 EXPECT_EQ("\"some text \"\n" 9425 "\"other\";", 9426 format("\"some text other\";", getLLVMStyleWithColumns(12))); 9427 EXPECT_EQ("\"some text \"\n" 9428 "\"other\";", 9429 format("\\\n\"some text other\";", getLLVMStyleWithColumns(12))); 9430 EXPECT_EQ( 9431 "#define A \\\n" 9432 " \"some \" \\\n" 9433 " \"text \" \\\n" 9434 " \"other\";", 9435 format("#define A \"some text other\";", getLLVMStyleWithColumns(12))); 9436 EXPECT_EQ( 9437 "#define A \\\n" 9438 " \"so \" \\\n" 9439 " \"text \" \\\n" 9440 " \"other\";", 9441 format("#define A \"so text other\";", getLLVMStyleWithColumns(12))); 9442 9443 EXPECT_EQ("\"some text\"", 9444 format("\"some text\"", getLLVMStyleWithColumns(1))); 9445 EXPECT_EQ("\"some text\"", 9446 format("\"some text\"", getLLVMStyleWithColumns(11))); 9447 EXPECT_EQ("\"some \"\n" 9448 "\"text\"", 9449 format("\"some text\"", getLLVMStyleWithColumns(10))); 9450 EXPECT_EQ("\"some \"\n" 9451 "\"text\"", 9452 format("\"some text\"", getLLVMStyleWithColumns(7))); 9453 EXPECT_EQ("\"some\"\n" 9454 "\" tex\"\n" 9455 "\"t\"", 9456 format("\"some text\"", getLLVMStyleWithColumns(6))); 9457 EXPECT_EQ("\"some\"\n" 9458 "\" tex\"\n" 9459 "\" and\"", 9460 format("\"some tex and\"", getLLVMStyleWithColumns(6))); 9461 EXPECT_EQ("\"some\"\n" 9462 "\"/tex\"\n" 9463 "\"/and\"", 9464 format("\"some/tex/and\"", getLLVMStyleWithColumns(6))); 9465 9466 EXPECT_EQ("variable =\n" 9467 " \"long string \"\n" 9468 " \"literal\";", 9469 format("variable = \"long string literal\";", 9470 getLLVMStyleWithColumns(20))); 9471 9472 EXPECT_EQ("variable = f(\n" 9473 " \"long string \"\n" 9474 " \"literal\",\n" 9475 " short,\n" 9476 " loooooooooooooooooooong);", 9477 format("variable = f(\"long string literal\", short, " 9478 "loooooooooooooooooooong);", 9479 getLLVMStyleWithColumns(20))); 9480 9481 EXPECT_EQ( 9482 "f(g(\"long string \"\n" 9483 " \"literal\"),\n" 9484 " b);", 9485 format("f(g(\"long string literal\"), b);", getLLVMStyleWithColumns(20))); 9486 EXPECT_EQ("f(g(\"long string \"\n" 9487 " \"literal\",\n" 9488 " a),\n" 9489 " b);", 9490 format("f(g(\"long string literal\", a), b);", 9491 getLLVMStyleWithColumns(20))); 9492 EXPECT_EQ( 9493 "f(\"one two\".split(\n" 9494 " variable));", 9495 format("f(\"one two\".split(variable));", getLLVMStyleWithColumns(20))); 9496 EXPECT_EQ("f(\"one two three four five six \"\n" 9497 " \"seven\".split(\n" 9498 " really_looooong_variable));", 9499 format("f(\"one two three four five six seven\"." 9500 "split(really_looooong_variable));", 9501 getLLVMStyleWithColumns(33))); 9502 9503 EXPECT_EQ("f(\"some \"\n" 9504 " \"text\",\n" 9505 " other);", 9506 format("f(\"some text\", other);", getLLVMStyleWithColumns(10))); 9507 9508 // Only break as a last resort. 9509 verifyFormat( 9510 "aaaaaaaaaaaaaaaaaaaa(\n" 9511 " aaaaaaaaaaaaaaaaaaaa,\n" 9512 " aaaaaa(\"aaa aaaaa aaa aaa aaaaa aaa aaaaa aaa aaa aaaaaa\"));"); 9513 9514 EXPECT_EQ("\"splitmea\"\n" 9515 "\"trandomp\"\n" 9516 "\"oint\"", 9517 format("\"splitmeatrandompoint\"", getLLVMStyleWithColumns(10))); 9518 9519 EXPECT_EQ("\"split/\"\n" 9520 "\"pathat/\"\n" 9521 "\"slashes\"", 9522 format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10))); 9523 9524 EXPECT_EQ("\"split/\"\n" 9525 "\"pathat/\"\n" 9526 "\"slashes\"", 9527 format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10))); 9528 EXPECT_EQ("\"split at \"\n" 9529 "\"spaces/at/\"\n" 9530 "\"slashes.at.any$\"\n" 9531 "\"non-alphanumeric%\"\n" 9532 "\"1111111111characte\"\n" 9533 "\"rs\"", 9534 format("\"split at " 9535 "spaces/at/" 9536 "slashes.at." 9537 "any$non-" 9538 "alphanumeric%" 9539 "1111111111characte" 9540 "rs\"", 9541 getLLVMStyleWithColumns(20))); 9542 9543 // Verify that splitting the strings understands 9544 // Style::AlwaysBreakBeforeMultilineStrings. 9545 EXPECT_EQ("aaaaaaaaaaaa(\n" 9546 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa \"\n" 9547 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\");", 9548 format("aaaaaaaaaaaa(\"aaaaaaaaaaaaaaaaaaaaaaaaaa " 9549 "aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa " 9550 "aaaaaaaaaaaaaaaaaaaaaa\");", 9551 getGoogleStyle())); 9552 EXPECT_EQ("return \"aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 9553 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\";", 9554 format("return \"aaaaaaaaaaaaaaaaaaaaaa " 9555 "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa " 9556 "aaaaaaaaaaaaaaaaaaaaaa\";", 9557 getGoogleStyle())); 9558 EXPECT_EQ("llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 9559 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";", 9560 format("llvm::outs() << " 9561 "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa" 9562 "aaaaaaaaaaaaaaaaaaa\";")); 9563 EXPECT_EQ("ffff(\n" 9564 " {\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 9565 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});", 9566 format("ffff({\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa " 9567 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});", 9568 getGoogleStyle())); 9569 9570 FormatStyle Style = getLLVMStyleWithColumns(12); 9571 Style.BreakStringLiterals = false; 9572 EXPECT_EQ("\"some text other\";", format("\"some text other\";", Style)); 9573 9574 FormatStyle AlignLeft = getLLVMStyleWithColumns(12); 9575 AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left; 9576 EXPECT_EQ("#define A \\\n" 9577 " \"some \" \\\n" 9578 " \"text \" \\\n" 9579 " \"other\";", 9580 format("#define A \"some text other\";", AlignLeft)); 9581 } 9582 9583 TEST_F(FormatTest, BreaksStringLiteralsAtColumnLimit) { 9584 EXPECT_EQ("C a = \"some more \"\n" 9585 " \"text\";", 9586 format("C a = \"some more text\";", getLLVMStyleWithColumns(18))); 9587 } 9588 9589 TEST_F(FormatTest, FullyRemoveEmptyLines) { 9590 FormatStyle NoEmptyLines = getLLVMStyleWithColumns(80); 9591 NoEmptyLines.MaxEmptyLinesToKeep = 0; 9592 EXPECT_EQ("int i = a(b());", 9593 format("int i=a(\n\n b(\n\n\n )\n\n);", NoEmptyLines)); 9594 } 9595 9596 TEST_F(FormatTest, BreaksStringLiteralsWithTabs) { 9597 EXPECT_EQ( 9598 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 9599 "(\n" 9600 " \"x\t\");", 9601 format("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 9602 "aaaaaaa(" 9603 "\"x\t\");")); 9604 } 9605 9606 TEST_F(FormatTest, BreaksWideAndNSStringLiterals) { 9607 EXPECT_EQ( 9608 "u8\"utf8 string \"\n" 9609 "u8\"literal\";", 9610 format("u8\"utf8 string literal\";", getGoogleStyleWithColumns(16))); 9611 EXPECT_EQ( 9612 "u\"utf16 string \"\n" 9613 "u\"literal\";", 9614 format("u\"utf16 string literal\";", getGoogleStyleWithColumns(16))); 9615 EXPECT_EQ( 9616 "U\"utf32 string \"\n" 9617 "U\"literal\";", 9618 format("U\"utf32 string literal\";", getGoogleStyleWithColumns(16))); 9619 EXPECT_EQ("L\"wide string \"\n" 9620 "L\"literal\";", 9621 format("L\"wide string literal\";", getGoogleStyleWithColumns(16))); 9622 EXPECT_EQ("@\"NSString \"\n" 9623 "@\"literal\";", 9624 format("@\"NSString literal\";", getGoogleStyleWithColumns(19))); 9625 verifyFormat(R"(NSString *s = @"那那那那";)", getLLVMStyleWithColumns(26)); 9626 9627 // This input makes clang-format try to split the incomplete unicode escape 9628 // sequence, which used to lead to a crasher. 9629 verifyNoCrash( 9630 "aaaaaaaaaaaaaaaaaaaa = L\"\\udff\"'; // aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 9631 getLLVMStyleWithColumns(60)); 9632 } 9633 9634 TEST_F(FormatTest, DoesNotBreakRawStringLiterals) { 9635 FormatStyle Style = getGoogleStyleWithColumns(15); 9636 EXPECT_EQ("R\"x(raw literal)x\";", format("R\"x(raw literal)x\";", Style)); 9637 EXPECT_EQ("uR\"x(raw literal)x\";", format("uR\"x(raw literal)x\";", Style)); 9638 EXPECT_EQ("LR\"x(raw literal)x\";", format("LR\"x(raw literal)x\";", Style)); 9639 EXPECT_EQ("UR\"x(raw literal)x\";", format("UR\"x(raw literal)x\";", Style)); 9640 EXPECT_EQ("u8R\"x(raw literal)x\";", 9641 format("u8R\"x(raw literal)x\";", Style)); 9642 } 9643 9644 TEST_F(FormatTest, BreaksStringLiteralsWithin_TMacro) { 9645 FormatStyle Style = getLLVMStyleWithColumns(20); 9646 EXPECT_EQ( 9647 "_T(\"aaaaaaaaaaaaaa\")\n" 9648 "_T(\"aaaaaaaaaaaaaa\")\n" 9649 "_T(\"aaaaaaaaaaaa\")", 9650 format(" _T(\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\")", Style)); 9651 EXPECT_EQ("f(x,\n" 9652 " _T(\"aaaaaaaaaaaa\")\n" 9653 " _T(\"aaa\"),\n" 9654 " z);", 9655 format("f(x, _T(\"aaaaaaaaaaaaaaa\"), z);", Style)); 9656 9657 // FIXME: Handle embedded spaces in one iteration. 9658 // EXPECT_EQ("_T(\"aaaaaaaaaaaaa\")\n" 9659 // "_T(\"aaaaaaaaaaaaa\")\n" 9660 // "_T(\"aaaaaaaaaaaaa\")\n" 9661 // "_T(\"a\")", 9662 // format(" _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", 9663 // getLLVMStyleWithColumns(20))); 9664 EXPECT_EQ( 9665 "_T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", 9666 format(" _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", Style)); 9667 EXPECT_EQ("f(\n" 9668 "#if !TEST\n" 9669 " _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n" 9670 "#endif\n" 9671 ");", 9672 format("f(\n" 9673 "#if !TEST\n" 9674 "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n" 9675 "#endif\n" 9676 ");")); 9677 EXPECT_EQ("f(\n" 9678 "\n" 9679 " _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));", 9680 format("f(\n" 9681 "\n" 9682 "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));")); 9683 } 9684 9685 TEST_F(FormatTest, BreaksStringLiteralOperands) { 9686 // In a function call with two operands, the second can be broken with no line 9687 // break before it. 9688 EXPECT_EQ( 9689 "func(a, \"long long \"\n" 9690 " \"long long\");", 9691 format("func(a, \"long long long long\");", getLLVMStyleWithColumns(24))); 9692 // In a function call with three operands, the second must be broken with a 9693 // line break before it. 9694 EXPECT_EQ("func(a,\n" 9695 " \"long long long \"\n" 9696 " \"long\",\n" 9697 " c);", 9698 format("func(a, \"long long long long\", c);", 9699 getLLVMStyleWithColumns(24))); 9700 // In a function call with three operands, the third must be broken with a 9701 // line break before it. 9702 EXPECT_EQ("func(a, b,\n" 9703 " \"long long long \"\n" 9704 " \"long\");", 9705 format("func(a, b, \"long long long long\");", 9706 getLLVMStyleWithColumns(24))); 9707 // In a function call with three operands, both the second and the third must 9708 // be broken with a line break before them. 9709 EXPECT_EQ("func(a,\n" 9710 " \"long long long \"\n" 9711 " \"long\",\n" 9712 " \"long long long \"\n" 9713 " \"long\");", 9714 format("func(a, \"long long long long\", \"long long long long\");", 9715 getLLVMStyleWithColumns(24))); 9716 // In a chain of << with two operands, the second can be broken with no line 9717 // break before it. 9718 EXPECT_EQ("a << \"line line \"\n" 9719 " \"line\";", 9720 format("a << \"line line line\";", getLLVMStyleWithColumns(20))); 9721 // In a chain of << with three operands, the second can be broken with no line 9722 // break before it. 9723 EXPECT_EQ( 9724 "abcde << \"line \"\n" 9725 " \"line line\"\n" 9726 " << c;", 9727 format("abcde << \"line line line\" << c;", getLLVMStyleWithColumns(20))); 9728 // In a chain of << with three operands, the third must be broken with a line 9729 // break before it. 9730 EXPECT_EQ( 9731 "a << b\n" 9732 " << \"line line \"\n" 9733 " \"line\";", 9734 format("a << b << \"line line line\";", getLLVMStyleWithColumns(20))); 9735 // In a chain of << with three operands, the second can be broken with no line 9736 // break before it and the third must be broken with a line break before it. 9737 EXPECT_EQ("abcd << \"line line \"\n" 9738 " \"line\"\n" 9739 " << \"line line \"\n" 9740 " \"line\";", 9741 format("abcd << \"line line line\" << \"line line line\";", 9742 getLLVMStyleWithColumns(20))); 9743 // In a chain of binary operators with two operands, the second can be broken 9744 // with no line break before it. 9745 EXPECT_EQ( 9746 "abcd + \"line line \"\n" 9747 " \"line line\";", 9748 format("abcd + \"line line line line\";", getLLVMStyleWithColumns(20))); 9749 // In a chain of binary operators with three operands, the second must be 9750 // broken with a line break before it. 9751 EXPECT_EQ("abcd +\n" 9752 " \"line line \"\n" 9753 " \"line line\" +\n" 9754 " e;", 9755 format("abcd + \"line line line line\" + e;", 9756 getLLVMStyleWithColumns(20))); 9757 // In a function call with two operands, with AlignAfterOpenBracket enabled, 9758 // the first must be broken with a line break before it. 9759 FormatStyle Style = getLLVMStyleWithColumns(25); 9760 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 9761 EXPECT_EQ("someFunction(\n" 9762 " \"long long long \"\n" 9763 " \"long\",\n" 9764 " a);", 9765 format("someFunction(\"long long long long\", a);", Style)); 9766 } 9767 9768 TEST_F(FormatTest, DontSplitStringLiteralsWithEscapedNewlines) { 9769 EXPECT_EQ( 9770 "aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 9771 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 9772 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";", 9773 format("aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 9774 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 9775 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";")); 9776 } 9777 9778 TEST_F(FormatTest, CountsCharactersInMultilineRawStringLiterals) { 9779 EXPECT_EQ("f(g(R\"x(raw literal)x\", a), b);", 9780 format("f(g(R\"x(raw literal)x\", a), b);", getGoogleStyle())); 9781 EXPECT_EQ("fffffffffff(g(R\"x(\n" 9782 "multiline raw string literal xxxxxxxxxxxxxx\n" 9783 ")x\",\n" 9784 " a),\n" 9785 " b);", 9786 format("fffffffffff(g(R\"x(\n" 9787 "multiline raw string literal xxxxxxxxxxxxxx\n" 9788 ")x\", a), b);", 9789 getGoogleStyleWithColumns(20))); 9790 EXPECT_EQ("fffffffffff(\n" 9791 " g(R\"x(qqq\n" 9792 "multiline raw string literal xxxxxxxxxxxxxx\n" 9793 ")x\",\n" 9794 " a),\n" 9795 " b);", 9796 format("fffffffffff(g(R\"x(qqq\n" 9797 "multiline raw string literal xxxxxxxxxxxxxx\n" 9798 ")x\", a), b);", 9799 getGoogleStyleWithColumns(20))); 9800 9801 EXPECT_EQ("fffffffffff(R\"x(\n" 9802 "multiline raw string literal xxxxxxxxxxxxxx\n" 9803 ")x\");", 9804 format("fffffffffff(R\"x(\n" 9805 "multiline raw string literal xxxxxxxxxxxxxx\n" 9806 ")x\");", 9807 getGoogleStyleWithColumns(20))); 9808 EXPECT_EQ("fffffffffff(R\"x(\n" 9809 "multiline raw string literal xxxxxxxxxxxxxx\n" 9810 ")x\" + bbbbbb);", 9811 format("fffffffffff(R\"x(\n" 9812 "multiline raw string literal xxxxxxxxxxxxxx\n" 9813 ")x\" + bbbbbb);", 9814 getGoogleStyleWithColumns(20))); 9815 EXPECT_EQ("fffffffffff(\n" 9816 " R\"x(\n" 9817 "multiline raw string literal xxxxxxxxxxxxxx\n" 9818 ")x\" +\n" 9819 " bbbbbb);", 9820 format("fffffffffff(\n" 9821 " R\"x(\n" 9822 "multiline raw string literal xxxxxxxxxxxxxx\n" 9823 ")x\" + bbbbbb);", 9824 getGoogleStyleWithColumns(20))); 9825 EXPECT_EQ("fffffffffff(R\"(single line raw string)\" + bbbbbb);", 9826 format("fffffffffff(\n" 9827 " R\"(single line raw string)\" + bbbbbb);")); 9828 } 9829 9830 TEST_F(FormatTest, SkipsUnknownStringLiterals) { 9831 verifyFormat("string a = \"unterminated;"); 9832 EXPECT_EQ("function(\"unterminated,\n" 9833 " OtherParameter);", 9834 format("function( \"unterminated,\n" 9835 " OtherParameter);")); 9836 } 9837 9838 TEST_F(FormatTest, DoesNotTryToParseUDLiteralsInPreCpp11Code) { 9839 FormatStyle Style = getLLVMStyle(); 9840 Style.Standard = FormatStyle::LS_Cpp03; 9841 EXPECT_EQ("#define x(_a) printf(\"foo\" _a);", 9842 format("#define x(_a) printf(\"foo\"_a);", Style)); 9843 } 9844 9845 TEST_F(FormatTest, CppLexVersion) { 9846 FormatStyle Style = getLLVMStyle(); 9847 // Formatting of x * y differs if x is a type. 9848 verifyFormat("void foo() { MACRO(a * b); }", Style); 9849 verifyFormat("void foo() { MACRO(int *b); }", Style); 9850 9851 // LLVM style uses latest lexer. 9852 verifyFormat("void foo() { MACRO(char8_t *b); }", Style); 9853 Style.Standard = FormatStyle::LS_Cpp17; 9854 // But in c++17, char8_t isn't a keyword. 9855 verifyFormat("void foo() { MACRO(char8_t * b); }", Style); 9856 } 9857 9858 TEST_F(FormatTest, UnderstandsCpp1y) { verifyFormat("int bi{1'000'000};"); } 9859 9860 TEST_F(FormatTest, BreakStringLiteralsBeforeUnbreakableTokenSequence) { 9861 EXPECT_EQ("someFunction(\"aaabbbcccd\"\n" 9862 " \"ddeeefff\");", 9863 format("someFunction(\"aaabbbcccdddeeefff\");", 9864 getLLVMStyleWithColumns(25))); 9865 EXPECT_EQ("someFunction1234567890(\n" 9866 " \"aaabbbcccdddeeefff\");", 9867 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 9868 getLLVMStyleWithColumns(26))); 9869 EXPECT_EQ("someFunction1234567890(\n" 9870 " \"aaabbbcccdddeeeff\"\n" 9871 " \"f\");", 9872 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 9873 getLLVMStyleWithColumns(25))); 9874 EXPECT_EQ("someFunction1234567890(\n" 9875 " \"aaabbbcccdddeeeff\"\n" 9876 " \"f\");", 9877 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 9878 getLLVMStyleWithColumns(24))); 9879 EXPECT_EQ("someFunction(\n" 9880 " \"aaabbbcc ddde \"\n" 9881 " \"efff\");", 9882 format("someFunction(\"aaabbbcc ddde efff\");", 9883 getLLVMStyleWithColumns(25))); 9884 EXPECT_EQ("someFunction(\"aaabbbccc \"\n" 9885 " \"ddeeefff\");", 9886 format("someFunction(\"aaabbbccc ddeeefff\");", 9887 getLLVMStyleWithColumns(25))); 9888 EXPECT_EQ("someFunction1234567890(\n" 9889 " \"aaabb \"\n" 9890 " \"cccdddeeefff\");", 9891 format("someFunction1234567890(\"aaabb cccdddeeefff\");", 9892 getLLVMStyleWithColumns(25))); 9893 EXPECT_EQ("#define A \\\n" 9894 " string s = \\\n" 9895 " \"123456789\" \\\n" 9896 " \"0\"; \\\n" 9897 " int i;", 9898 format("#define A string s = \"1234567890\"; int i;", 9899 getLLVMStyleWithColumns(20))); 9900 EXPECT_EQ("someFunction(\n" 9901 " \"aaabbbcc \"\n" 9902 " \"dddeeefff\");", 9903 format("someFunction(\"aaabbbcc dddeeefff\");", 9904 getLLVMStyleWithColumns(25))); 9905 } 9906 9907 TEST_F(FormatTest, DoNotBreakStringLiteralsInEscapeSequence) { 9908 EXPECT_EQ("\"\\a\"", format("\"\\a\"", getLLVMStyleWithColumns(3))); 9909 EXPECT_EQ("\"\\\"", format("\"\\\"", getLLVMStyleWithColumns(2))); 9910 EXPECT_EQ("\"test\"\n" 9911 "\"\\n\"", 9912 format("\"test\\n\"", getLLVMStyleWithColumns(7))); 9913 EXPECT_EQ("\"tes\\\\\"\n" 9914 "\"n\"", 9915 format("\"tes\\\\n\"", getLLVMStyleWithColumns(7))); 9916 EXPECT_EQ("\"\\\\\\\\\"\n" 9917 "\"\\n\"", 9918 format("\"\\\\\\\\\\n\"", getLLVMStyleWithColumns(7))); 9919 EXPECT_EQ("\"\\uff01\"", format("\"\\uff01\"", getLLVMStyleWithColumns(7))); 9920 EXPECT_EQ("\"\\uff01\"\n" 9921 "\"test\"", 9922 format("\"\\uff01test\"", getLLVMStyleWithColumns(8))); 9923 EXPECT_EQ("\"\\Uff01ff02\"", 9924 format("\"\\Uff01ff02\"", getLLVMStyleWithColumns(11))); 9925 EXPECT_EQ("\"\\x000000000001\"\n" 9926 "\"next\"", 9927 format("\"\\x000000000001next\"", getLLVMStyleWithColumns(16))); 9928 EXPECT_EQ("\"\\x000000000001next\"", 9929 format("\"\\x000000000001next\"", getLLVMStyleWithColumns(15))); 9930 EXPECT_EQ("\"\\x000000000001\"", 9931 format("\"\\x000000000001\"", getLLVMStyleWithColumns(7))); 9932 EXPECT_EQ("\"test\"\n" 9933 "\"\\000000\"\n" 9934 "\"000001\"", 9935 format("\"test\\000000000001\"", getLLVMStyleWithColumns(9))); 9936 EXPECT_EQ("\"test\\000\"\n" 9937 "\"00000000\"\n" 9938 "\"1\"", 9939 format("\"test\\000000000001\"", getLLVMStyleWithColumns(10))); 9940 } 9941 9942 TEST_F(FormatTest, DoNotCreateUnreasonableUnwrappedLines) { 9943 verifyFormat("void f() {\n" 9944 " return g() {}\n" 9945 " void h() {}"); 9946 verifyFormat("int a[] = {void forgot_closing_brace(){f();\n" 9947 "g();\n" 9948 "}"); 9949 } 9950 9951 TEST_F(FormatTest, DoNotPrematurelyEndUnwrappedLineForReturnStatements) { 9952 verifyFormat( 9953 "void f() { return C{param1, param2}.SomeCall(param1, param2); }"); 9954 } 9955 9956 TEST_F(FormatTest, FormatsClosingBracesInEmptyNestedBlocks) { 9957 verifyFormat("class X {\n" 9958 " void f() {\n" 9959 " }\n" 9960 "};", 9961 getLLVMStyleWithColumns(12)); 9962 } 9963 9964 TEST_F(FormatTest, ConfigurableIndentWidth) { 9965 FormatStyle EightIndent = getLLVMStyleWithColumns(18); 9966 EightIndent.IndentWidth = 8; 9967 EightIndent.ContinuationIndentWidth = 8; 9968 verifyFormat("void f() {\n" 9969 " someFunction();\n" 9970 " if (true) {\n" 9971 " f();\n" 9972 " }\n" 9973 "}", 9974 EightIndent); 9975 verifyFormat("class X {\n" 9976 " void f() {\n" 9977 " }\n" 9978 "};", 9979 EightIndent); 9980 verifyFormat("int x[] = {\n" 9981 " call(),\n" 9982 " call()};", 9983 EightIndent); 9984 } 9985 9986 TEST_F(FormatTest, ConfigurableFunctionDeclarationIndentAfterType) { 9987 verifyFormat("double\n" 9988 "f();", 9989 getLLVMStyleWithColumns(8)); 9990 } 9991 9992 TEST_F(FormatTest, ConfigurableUseOfTab) { 9993 FormatStyle Tab = getLLVMStyleWithColumns(42); 9994 Tab.IndentWidth = 8; 9995 Tab.UseTab = FormatStyle::UT_Always; 9996 Tab.AlignEscapedNewlines = FormatStyle::ENAS_Left; 9997 9998 EXPECT_EQ("if (aaaaaaaa && // q\n" 9999 " bb)\t\t// w\n" 10000 "\t;", 10001 format("if (aaaaaaaa &&// q\n" 10002 "bb)// w\n" 10003 ";", 10004 Tab)); 10005 EXPECT_EQ("if (aaa && bbb) // w\n" 10006 "\t;", 10007 format("if(aaa&&bbb)// w\n" 10008 ";", 10009 Tab)); 10010 10011 verifyFormat("class X {\n" 10012 "\tvoid f() {\n" 10013 "\t\tsomeFunction(parameter1,\n" 10014 "\t\t\t parameter2);\n" 10015 "\t}\n" 10016 "};", 10017 Tab); 10018 verifyFormat("#define A \\\n" 10019 "\tvoid f() { \\\n" 10020 "\t\tsomeFunction( \\\n" 10021 "\t\t parameter1, \\\n" 10022 "\t\t parameter2); \\\n" 10023 "\t}", 10024 Tab); 10025 verifyFormat("int a;\t // x\n" 10026 "int bbbbbbbb; // x\n", 10027 Tab); 10028 10029 Tab.TabWidth = 4; 10030 Tab.IndentWidth = 8; 10031 verifyFormat("class TabWidth4Indent8 {\n" 10032 "\t\tvoid f() {\n" 10033 "\t\t\t\tsomeFunction(parameter1,\n" 10034 "\t\t\t\t\t\t\t parameter2);\n" 10035 "\t\t}\n" 10036 "};", 10037 Tab); 10038 10039 Tab.TabWidth = 4; 10040 Tab.IndentWidth = 4; 10041 verifyFormat("class TabWidth4Indent4 {\n" 10042 "\tvoid f() {\n" 10043 "\t\tsomeFunction(parameter1,\n" 10044 "\t\t\t\t\t parameter2);\n" 10045 "\t}\n" 10046 "};", 10047 Tab); 10048 10049 Tab.TabWidth = 8; 10050 Tab.IndentWidth = 4; 10051 verifyFormat("class TabWidth8Indent4 {\n" 10052 " void f() {\n" 10053 "\tsomeFunction(parameter1,\n" 10054 "\t\t parameter2);\n" 10055 " }\n" 10056 "};", 10057 Tab); 10058 10059 Tab.TabWidth = 8; 10060 Tab.IndentWidth = 8; 10061 EXPECT_EQ("/*\n" 10062 "\t a\t\tcomment\n" 10063 "\t in multiple lines\n" 10064 " */", 10065 format(" /*\t \t \n" 10066 " \t \t a\t\tcomment\t \t\n" 10067 " \t \t in multiple lines\t\n" 10068 " \t */", 10069 Tab)); 10070 10071 Tab.UseTab = FormatStyle::UT_ForIndentation; 10072 verifyFormat("{\n" 10073 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10074 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10075 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10076 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10077 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10078 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10079 "};", 10080 Tab); 10081 verifyFormat("enum AA {\n" 10082 "\ta1, // Force multiple lines\n" 10083 "\ta2,\n" 10084 "\ta3\n" 10085 "};", 10086 Tab); 10087 EXPECT_EQ("if (aaaaaaaa && // q\n" 10088 " bb) // w\n" 10089 "\t;", 10090 format("if (aaaaaaaa &&// q\n" 10091 "bb)// w\n" 10092 ";", 10093 Tab)); 10094 verifyFormat("class X {\n" 10095 "\tvoid f() {\n" 10096 "\t\tsomeFunction(parameter1,\n" 10097 "\t\t parameter2);\n" 10098 "\t}\n" 10099 "};", 10100 Tab); 10101 verifyFormat("{\n" 10102 "\tQ(\n" 10103 "\t {\n" 10104 "\t\t int a;\n" 10105 "\t\t someFunction(aaaaaaaa,\n" 10106 "\t\t bbbbbbb);\n" 10107 "\t },\n" 10108 "\t p);\n" 10109 "}", 10110 Tab); 10111 EXPECT_EQ("{\n" 10112 "\t/* aaaa\n" 10113 "\t bbbb */\n" 10114 "}", 10115 format("{\n" 10116 "/* aaaa\n" 10117 " bbbb */\n" 10118 "}", 10119 Tab)); 10120 EXPECT_EQ("{\n" 10121 "\t/*\n" 10122 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10123 "\t bbbbbbbbbbbbb\n" 10124 "\t*/\n" 10125 "}", 10126 format("{\n" 10127 "/*\n" 10128 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10129 "*/\n" 10130 "}", 10131 Tab)); 10132 EXPECT_EQ("{\n" 10133 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10134 "\t// bbbbbbbbbbbbb\n" 10135 "}", 10136 format("{\n" 10137 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10138 "}", 10139 Tab)); 10140 EXPECT_EQ("{\n" 10141 "\t/*\n" 10142 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10143 "\t bbbbbbbbbbbbb\n" 10144 "\t*/\n" 10145 "}", 10146 format("{\n" 10147 "\t/*\n" 10148 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10149 "\t*/\n" 10150 "}", 10151 Tab)); 10152 EXPECT_EQ("{\n" 10153 "\t/*\n" 10154 "\n" 10155 "\t*/\n" 10156 "}", 10157 format("{\n" 10158 "\t/*\n" 10159 "\n" 10160 "\t*/\n" 10161 "}", 10162 Tab)); 10163 EXPECT_EQ("{\n" 10164 "\t/*\n" 10165 " asdf\n" 10166 "\t*/\n" 10167 "}", 10168 format("{\n" 10169 "\t/*\n" 10170 " asdf\n" 10171 "\t*/\n" 10172 "}", 10173 Tab)); 10174 10175 Tab.UseTab = FormatStyle::UT_Never; 10176 EXPECT_EQ("/*\n" 10177 " a\t\tcomment\n" 10178 " in multiple lines\n" 10179 " */", 10180 format(" /*\t \t \n" 10181 " \t \t a\t\tcomment\t \t\n" 10182 " \t \t in multiple lines\t\n" 10183 " \t */", 10184 Tab)); 10185 EXPECT_EQ("/* some\n" 10186 " comment */", 10187 format(" \t \t /* some\n" 10188 " \t \t comment */", 10189 Tab)); 10190 EXPECT_EQ("int a; /* some\n" 10191 " comment */", 10192 format(" \t \t int a; /* some\n" 10193 " \t \t comment */", 10194 Tab)); 10195 10196 EXPECT_EQ("int a; /* some\n" 10197 "comment */", 10198 format(" \t \t int\ta; /* some\n" 10199 " \t \t comment */", 10200 Tab)); 10201 EXPECT_EQ("f(\"\t\t\"); /* some\n" 10202 " comment */", 10203 format(" \t \t f(\"\t\t\"); /* some\n" 10204 " \t \t comment */", 10205 Tab)); 10206 EXPECT_EQ("{\n" 10207 " /*\n" 10208 " * Comment\n" 10209 " */\n" 10210 " int i;\n" 10211 "}", 10212 format("{\n" 10213 "\t/*\n" 10214 "\t * Comment\n" 10215 "\t */\n" 10216 "\t int i;\n" 10217 "}", 10218 Tab)); 10219 10220 Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation; 10221 Tab.TabWidth = 8; 10222 Tab.IndentWidth = 8; 10223 EXPECT_EQ("if (aaaaaaaa && // q\n" 10224 " bb) // w\n" 10225 "\t;", 10226 format("if (aaaaaaaa &&// q\n" 10227 "bb)// w\n" 10228 ";", 10229 Tab)); 10230 EXPECT_EQ("if (aaa && bbb) // w\n" 10231 "\t;", 10232 format("if(aaa&&bbb)// w\n" 10233 ";", 10234 Tab)); 10235 verifyFormat("class X {\n" 10236 "\tvoid f() {\n" 10237 "\t\tsomeFunction(parameter1,\n" 10238 "\t\t\t parameter2);\n" 10239 "\t}\n" 10240 "};", 10241 Tab); 10242 verifyFormat("#define A \\\n" 10243 "\tvoid f() { \\\n" 10244 "\t\tsomeFunction( \\\n" 10245 "\t\t parameter1, \\\n" 10246 "\t\t parameter2); \\\n" 10247 "\t}", 10248 Tab); 10249 Tab.TabWidth = 4; 10250 Tab.IndentWidth = 8; 10251 verifyFormat("class TabWidth4Indent8 {\n" 10252 "\t\tvoid f() {\n" 10253 "\t\t\t\tsomeFunction(parameter1,\n" 10254 "\t\t\t\t\t\t\t parameter2);\n" 10255 "\t\t}\n" 10256 "};", 10257 Tab); 10258 Tab.TabWidth = 4; 10259 Tab.IndentWidth = 4; 10260 verifyFormat("class TabWidth4Indent4 {\n" 10261 "\tvoid f() {\n" 10262 "\t\tsomeFunction(parameter1,\n" 10263 "\t\t\t\t\t parameter2);\n" 10264 "\t}\n" 10265 "};", 10266 Tab); 10267 Tab.TabWidth = 8; 10268 Tab.IndentWidth = 4; 10269 verifyFormat("class TabWidth8Indent4 {\n" 10270 " void f() {\n" 10271 "\tsomeFunction(parameter1,\n" 10272 "\t\t parameter2);\n" 10273 " }\n" 10274 "};", 10275 Tab); 10276 Tab.TabWidth = 8; 10277 Tab.IndentWidth = 8; 10278 EXPECT_EQ("/*\n" 10279 "\t a\t\tcomment\n" 10280 "\t in multiple lines\n" 10281 " */", 10282 format(" /*\t \t \n" 10283 " \t \t a\t\tcomment\t \t\n" 10284 " \t \t in multiple lines\t\n" 10285 " \t */", 10286 Tab)); 10287 verifyFormat("{\n" 10288 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10289 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10290 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10291 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10292 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10293 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10294 "};", 10295 Tab); 10296 verifyFormat("enum AA {\n" 10297 "\ta1, // Force multiple lines\n" 10298 "\ta2,\n" 10299 "\ta3\n" 10300 "};", 10301 Tab); 10302 EXPECT_EQ("if (aaaaaaaa && // q\n" 10303 " bb) // w\n" 10304 "\t;", 10305 format("if (aaaaaaaa &&// q\n" 10306 "bb)// w\n" 10307 ";", 10308 Tab)); 10309 verifyFormat("class X {\n" 10310 "\tvoid f() {\n" 10311 "\t\tsomeFunction(parameter1,\n" 10312 "\t\t\t parameter2);\n" 10313 "\t}\n" 10314 "};", 10315 Tab); 10316 verifyFormat("{\n" 10317 "\tQ(\n" 10318 "\t {\n" 10319 "\t\t int a;\n" 10320 "\t\t someFunction(aaaaaaaa,\n" 10321 "\t\t\t\t bbbbbbb);\n" 10322 "\t },\n" 10323 "\t p);\n" 10324 "}", 10325 Tab); 10326 EXPECT_EQ("{\n" 10327 "\t/* aaaa\n" 10328 "\t bbbb */\n" 10329 "}", 10330 format("{\n" 10331 "/* aaaa\n" 10332 " bbbb */\n" 10333 "}", 10334 Tab)); 10335 EXPECT_EQ("{\n" 10336 "\t/*\n" 10337 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10338 "\t bbbbbbbbbbbbb\n" 10339 "\t*/\n" 10340 "}", 10341 format("{\n" 10342 "/*\n" 10343 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10344 "*/\n" 10345 "}", 10346 Tab)); 10347 EXPECT_EQ("{\n" 10348 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10349 "\t// bbbbbbbbbbbbb\n" 10350 "}", 10351 format("{\n" 10352 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10353 "}", 10354 Tab)); 10355 EXPECT_EQ("{\n" 10356 "\t/*\n" 10357 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10358 "\t bbbbbbbbbbbbb\n" 10359 "\t*/\n" 10360 "}", 10361 format("{\n" 10362 "\t/*\n" 10363 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10364 "\t*/\n" 10365 "}", 10366 Tab)); 10367 EXPECT_EQ("{\n" 10368 "\t/*\n" 10369 "\n" 10370 "\t*/\n" 10371 "}", 10372 format("{\n" 10373 "\t/*\n" 10374 "\n" 10375 "\t*/\n" 10376 "}", 10377 Tab)); 10378 EXPECT_EQ("{\n" 10379 "\t/*\n" 10380 " asdf\n" 10381 "\t*/\n" 10382 "}", 10383 format("{\n" 10384 "\t/*\n" 10385 " asdf\n" 10386 "\t*/\n" 10387 "}", 10388 Tab)); 10389 EXPECT_EQ("/* some\n" 10390 " comment */", 10391 format(" \t \t /* some\n" 10392 " \t \t comment */", 10393 Tab)); 10394 EXPECT_EQ("int a; /* some\n" 10395 " comment */", 10396 format(" \t \t int a; /* some\n" 10397 " \t \t comment */", 10398 Tab)); 10399 EXPECT_EQ("int a; /* some\n" 10400 "comment */", 10401 format(" \t \t int\ta; /* some\n" 10402 " \t \t comment */", 10403 Tab)); 10404 EXPECT_EQ("f(\"\t\t\"); /* some\n" 10405 " comment */", 10406 format(" \t \t f(\"\t\t\"); /* some\n" 10407 " \t \t comment */", 10408 Tab)); 10409 EXPECT_EQ("{\n" 10410 "\t/*\n" 10411 "\t * Comment\n" 10412 "\t */\n" 10413 "\tint i;\n" 10414 "}", 10415 format("{\n" 10416 "\t/*\n" 10417 "\t * Comment\n" 10418 "\t */\n" 10419 "\t int i;\n" 10420 "}", 10421 Tab)); 10422 Tab.TabWidth = 2; 10423 Tab.IndentWidth = 2; 10424 EXPECT_EQ("{\n" 10425 "\t/* aaaa\n" 10426 "\t\t bbbb */\n" 10427 "}", 10428 format("{\n" 10429 "/* aaaa\n" 10430 "\t bbbb */\n" 10431 "}", 10432 Tab)); 10433 EXPECT_EQ("{\n" 10434 "\t/*\n" 10435 "\t\taaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10436 "\t\tbbbbbbbbbbbbb\n" 10437 "\t*/\n" 10438 "}", 10439 format("{\n" 10440 "/*\n" 10441 "\taaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10442 "*/\n" 10443 "}", 10444 Tab)); 10445 Tab.AlignConsecutiveAssignments = true; 10446 Tab.AlignConsecutiveDeclarations = true; 10447 Tab.TabWidth = 4; 10448 Tab.IndentWidth = 4; 10449 verifyFormat("class Assign {\n" 10450 "\tvoid f() {\n" 10451 "\t\tint x = 123;\n" 10452 "\t\tint random = 4;\n" 10453 "\t\tstd::string alphabet =\n" 10454 "\t\t\t\"abcdefghijklmnopqrstuvwxyz\";\n" 10455 "\t}\n" 10456 "};", 10457 Tab); 10458 10459 Tab.UseTab = FormatStyle::UT_AlignWithSpaces; 10460 Tab.TabWidth = 8; 10461 Tab.IndentWidth = 8; 10462 EXPECT_EQ("if (aaaaaaaa && // q\n" 10463 " bb) // w\n" 10464 "\t;", 10465 format("if (aaaaaaaa &&// q\n" 10466 "bb)// w\n" 10467 ";", 10468 Tab)); 10469 EXPECT_EQ("if (aaa && bbb) // w\n" 10470 "\t;", 10471 format("if(aaa&&bbb)// w\n" 10472 ";", 10473 Tab)); 10474 verifyFormat("class X {\n" 10475 "\tvoid f() {\n" 10476 "\t\tsomeFunction(parameter1,\n" 10477 "\t\t parameter2);\n" 10478 "\t}\n" 10479 "};", 10480 Tab); 10481 verifyFormat("#define A \\\n" 10482 "\tvoid f() { \\\n" 10483 "\t\tsomeFunction( \\\n" 10484 "\t\t parameter1, \\\n" 10485 "\t\t parameter2); \\\n" 10486 "\t}", 10487 Tab); 10488 Tab.TabWidth = 4; 10489 Tab.IndentWidth = 8; 10490 verifyFormat("class TabWidth4Indent8 {\n" 10491 "\t\tvoid f() {\n" 10492 "\t\t\t\tsomeFunction(parameter1,\n" 10493 "\t\t\t\t parameter2);\n" 10494 "\t\t}\n" 10495 "};", 10496 Tab); 10497 Tab.TabWidth = 4; 10498 Tab.IndentWidth = 4; 10499 verifyFormat("class TabWidth4Indent4 {\n" 10500 "\tvoid f() {\n" 10501 "\t\tsomeFunction(parameter1,\n" 10502 "\t\t parameter2);\n" 10503 "\t}\n" 10504 "};", 10505 Tab); 10506 Tab.TabWidth = 8; 10507 Tab.IndentWidth = 4; 10508 verifyFormat("class TabWidth8Indent4 {\n" 10509 " void f() {\n" 10510 "\tsomeFunction(parameter1,\n" 10511 "\t parameter2);\n" 10512 " }\n" 10513 "};", 10514 Tab); 10515 Tab.TabWidth = 8; 10516 Tab.IndentWidth = 8; 10517 EXPECT_EQ("/*\n" 10518 " a\t\tcomment\n" 10519 " in multiple lines\n" 10520 " */", 10521 format(" /*\t \t \n" 10522 " \t \t a\t\tcomment\t \t\n" 10523 " \t \t in multiple lines\t\n" 10524 " \t */", 10525 Tab)); 10526 verifyFormat("{\n" 10527 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10528 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10529 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10530 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10531 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10532 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10533 "};", 10534 Tab); 10535 verifyFormat("enum AA {\n" 10536 "\ta1, // Force multiple lines\n" 10537 "\ta2,\n" 10538 "\ta3\n" 10539 "};", 10540 Tab); 10541 EXPECT_EQ("if (aaaaaaaa && // q\n" 10542 " bb) // w\n" 10543 "\t;", 10544 format("if (aaaaaaaa &&// q\n" 10545 "bb)// w\n" 10546 ";", 10547 Tab)); 10548 verifyFormat("class X {\n" 10549 "\tvoid f() {\n" 10550 "\t\tsomeFunction(parameter1,\n" 10551 "\t\t parameter2);\n" 10552 "\t}\n" 10553 "};", 10554 Tab); 10555 verifyFormat("{\n" 10556 "\tQ(\n" 10557 "\t {\n" 10558 "\t\t int a;\n" 10559 "\t\t someFunction(aaaaaaaa,\n" 10560 "\t\t bbbbbbb);\n" 10561 "\t },\n" 10562 "\t p);\n" 10563 "}", 10564 Tab); 10565 EXPECT_EQ("{\n" 10566 "\t/* aaaa\n" 10567 "\t bbbb */\n" 10568 "}", 10569 format("{\n" 10570 "/* aaaa\n" 10571 " bbbb */\n" 10572 "}", 10573 Tab)); 10574 EXPECT_EQ("{\n" 10575 "\t/*\n" 10576 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10577 "\t bbbbbbbbbbbbb\n" 10578 "\t*/\n" 10579 "}", 10580 format("{\n" 10581 "/*\n" 10582 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10583 "*/\n" 10584 "}", 10585 Tab)); 10586 EXPECT_EQ("{\n" 10587 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10588 "\t// bbbbbbbbbbbbb\n" 10589 "}", 10590 format("{\n" 10591 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10592 "}", 10593 Tab)); 10594 EXPECT_EQ("{\n" 10595 "\t/*\n" 10596 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10597 "\t bbbbbbbbbbbbb\n" 10598 "\t*/\n" 10599 "}", 10600 format("{\n" 10601 "\t/*\n" 10602 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10603 "\t*/\n" 10604 "}", 10605 Tab)); 10606 EXPECT_EQ("{\n" 10607 "\t/*\n" 10608 "\n" 10609 "\t*/\n" 10610 "}", 10611 format("{\n" 10612 "\t/*\n" 10613 "\n" 10614 "\t*/\n" 10615 "}", 10616 Tab)); 10617 EXPECT_EQ("{\n" 10618 "\t/*\n" 10619 " asdf\n" 10620 "\t*/\n" 10621 "}", 10622 format("{\n" 10623 "\t/*\n" 10624 " asdf\n" 10625 "\t*/\n" 10626 "}", 10627 Tab)); 10628 EXPECT_EQ("/* some\n" 10629 " comment */", 10630 format(" \t \t /* some\n" 10631 " \t \t comment */", 10632 Tab)); 10633 EXPECT_EQ("int a; /* some\n" 10634 " comment */", 10635 format(" \t \t int a; /* some\n" 10636 " \t \t comment */", 10637 Tab)); 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 "\t/*\n" 10650 "\t * Comment\n" 10651 "\t */\n" 10652 "\tint 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 Tab.TabWidth = 2; 10662 Tab.IndentWidth = 2; 10663 EXPECT_EQ("{\n" 10664 "\t/* aaaa\n" 10665 "\t bbbb */\n" 10666 "}", 10667 format("{\n" 10668 "/* aaaa\n" 10669 " bbbb */\n" 10670 "}", 10671 Tab)); 10672 EXPECT_EQ("{\n" 10673 "\t/*\n" 10674 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10675 "\t bbbbbbbbbbbbb\n" 10676 "\t*/\n" 10677 "}", 10678 format("{\n" 10679 "/*\n" 10680 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10681 "*/\n" 10682 "}", 10683 Tab)); 10684 Tab.AlignConsecutiveAssignments = true; 10685 Tab.AlignConsecutiveDeclarations = true; 10686 Tab.TabWidth = 4; 10687 Tab.IndentWidth = 4; 10688 verifyFormat("class Assign {\n" 10689 "\tvoid f() {\n" 10690 "\t\tint x = 123;\n" 10691 "\t\tint random = 4;\n" 10692 "\t\tstd::string alphabet =\n" 10693 "\t\t\t\"abcdefghijklmnopqrstuvwxyz\";\n" 10694 "\t}\n" 10695 "};", 10696 Tab); 10697 } 10698 10699 TEST_F(FormatTest, ZeroTabWidth) { 10700 FormatStyle Tab = getLLVMStyleWithColumns(42); 10701 Tab.IndentWidth = 8; 10702 Tab.UseTab = FormatStyle::UT_Never; 10703 Tab.TabWidth = 0; 10704 EXPECT_EQ("void a(){\n" 10705 " // line starts with '\t'\n" 10706 "};", 10707 format("void a(){\n" 10708 "\t// line starts with '\t'\n" 10709 "};", 10710 Tab)); 10711 10712 EXPECT_EQ("void a(){\n" 10713 " // line starts with '\t'\n" 10714 "};", 10715 format("void a(){\n" 10716 "\t\t// line starts with '\t'\n" 10717 "};", 10718 Tab)); 10719 10720 Tab.UseTab = FormatStyle::UT_ForIndentation; 10721 EXPECT_EQ("void a(){\n" 10722 " // line starts with '\t'\n" 10723 "};", 10724 format("void a(){\n" 10725 "\t// line starts with '\t'\n" 10726 "};", 10727 Tab)); 10728 10729 EXPECT_EQ("void a(){\n" 10730 " // line starts with '\t'\n" 10731 "};", 10732 format("void a(){\n" 10733 "\t\t// line starts with '\t'\n" 10734 "};", 10735 Tab)); 10736 10737 Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation; 10738 EXPECT_EQ("void a(){\n" 10739 " // line starts with '\t'\n" 10740 "};", 10741 format("void a(){\n" 10742 "\t// line starts with '\t'\n" 10743 "};", 10744 Tab)); 10745 10746 EXPECT_EQ("void a(){\n" 10747 " // line starts with '\t'\n" 10748 "};", 10749 format("void a(){\n" 10750 "\t\t// line starts with '\t'\n" 10751 "};", 10752 Tab)); 10753 10754 Tab.UseTab = FormatStyle::UT_AlignWithSpaces; 10755 EXPECT_EQ("void a(){\n" 10756 " // line starts with '\t'\n" 10757 "};", 10758 format("void a(){\n" 10759 "\t// line starts with '\t'\n" 10760 "};", 10761 Tab)); 10762 10763 EXPECT_EQ("void a(){\n" 10764 " // line starts with '\t'\n" 10765 "};", 10766 format("void a(){\n" 10767 "\t\t// line starts with '\t'\n" 10768 "};", 10769 Tab)); 10770 10771 Tab.UseTab = FormatStyle::UT_Always; 10772 EXPECT_EQ("void a(){\n" 10773 "// line starts with '\t'\n" 10774 "};", 10775 format("void a(){\n" 10776 "\t// line starts with '\t'\n" 10777 "};", 10778 Tab)); 10779 10780 EXPECT_EQ("void a(){\n" 10781 "// line starts with '\t'\n" 10782 "};", 10783 format("void a(){\n" 10784 "\t\t// line starts with '\t'\n" 10785 "};", 10786 Tab)); 10787 } 10788 10789 TEST_F(FormatTest, CalculatesOriginalColumn) { 10790 EXPECT_EQ("\"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 10791 "q\"; /* some\n" 10792 " comment */", 10793 format(" \"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 10794 "q\"; /* some\n" 10795 " comment */", 10796 getLLVMStyle())); 10797 EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n" 10798 "/* some\n" 10799 " comment */", 10800 format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n" 10801 " /* some\n" 10802 " comment */", 10803 getLLVMStyle())); 10804 EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 10805 "qqq\n" 10806 "/* some\n" 10807 " comment */", 10808 format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 10809 "qqq\n" 10810 " /* some\n" 10811 " comment */", 10812 getLLVMStyle())); 10813 EXPECT_EQ("inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 10814 "wwww; /* some\n" 10815 " comment */", 10816 format(" inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 10817 "wwww; /* some\n" 10818 " comment */", 10819 getLLVMStyle())); 10820 } 10821 10822 TEST_F(FormatTest, ConfigurableSpaceBeforeParens) { 10823 FormatStyle NoSpace = getLLVMStyle(); 10824 NoSpace.SpaceBeforeParens = FormatStyle::SBPO_Never; 10825 10826 verifyFormat("while(true)\n" 10827 " continue;", 10828 NoSpace); 10829 verifyFormat("for(;;)\n" 10830 " continue;", 10831 NoSpace); 10832 verifyFormat("if(true)\n" 10833 " f();\n" 10834 "else if(true)\n" 10835 " f();", 10836 NoSpace); 10837 verifyFormat("do {\n" 10838 " do_something();\n" 10839 "} while(something());", 10840 NoSpace); 10841 verifyFormat("switch(x) {\n" 10842 "default:\n" 10843 " break;\n" 10844 "}", 10845 NoSpace); 10846 verifyFormat("auto i = std::make_unique<int>(5);", NoSpace); 10847 verifyFormat("size_t x = sizeof(x);", NoSpace); 10848 verifyFormat("auto f(int x) -> decltype(x);", NoSpace); 10849 verifyFormat("int f(T x) noexcept(x.create());", NoSpace); 10850 verifyFormat("alignas(128) char a[128];", NoSpace); 10851 verifyFormat("size_t x = alignof(MyType);", NoSpace); 10852 verifyFormat("static_assert(sizeof(char) == 1, \"Impossible!\");", NoSpace); 10853 verifyFormat("int f() throw(Deprecated);", NoSpace); 10854 verifyFormat("typedef void (*cb)(int);", NoSpace); 10855 verifyFormat("T A::operator()();", NoSpace); 10856 verifyFormat("X A::operator++(T);", NoSpace); 10857 verifyFormat("auto lambda = []() { return 0; };", NoSpace); 10858 10859 FormatStyle Space = getLLVMStyle(); 10860 Space.SpaceBeforeParens = FormatStyle::SBPO_Always; 10861 10862 verifyFormat("int f ();", Space); 10863 verifyFormat("void f (int a, T b) {\n" 10864 " while (true)\n" 10865 " continue;\n" 10866 "}", 10867 Space); 10868 verifyFormat("if (true)\n" 10869 " f ();\n" 10870 "else if (true)\n" 10871 " f ();", 10872 Space); 10873 verifyFormat("do {\n" 10874 " do_something ();\n" 10875 "} while (something ());", 10876 Space); 10877 verifyFormat("switch (x) {\n" 10878 "default:\n" 10879 " break;\n" 10880 "}", 10881 Space); 10882 verifyFormat("A::A () : a (1) {}", Space); 10883 verifyFormat("void f () __attribute__ ((asdf));", Space); 10884 verifyFormat("*(&a + 1);\n" 10885 "&((&a)[1]);\n" 10886 "a[(b + c) * d];\n" 10887 "(((a + 1) * 2) + 3) * 4;", 10888 Space); 10889 verifyFormat("#define A(x) x", Space); 10890 verifyFormat("#define A (x) x", Space); 10891 verifyFormat("#if defined(x)\n" 10892 "#endif", 10893 Space); 10894 verifyFormat("auto i = std::make_unique<int> (5);", Space); 10895 verifyFormat("size_t x = sizeof (x);", Space); 10896 verifyFormat("auto f (int x) -> decltype (x);", Space); 10897 verifyFormat("int f (T x) noexcept (x.create ());", Space); 10898 verifyFormat("alignas (128) char a[128];", Space); 10899 verifyFormat("size_t x = alignof (MyType);", Space); 10900 verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");", Space); 10901 verifyFormat("int f () throw (Deprecated);", Space); 10902 verifyFormat("typedef void (*cb) (int);", Space); 10903 verifyFormat("T A::operator() ();", Space); 10904 verifyFormat("X A::operator++ (T);", Space); 10905 verifyFormat("auto lambda = [] () { return 0; };", Space); 10906 verifyFormat("int x = int (y);", Space); 10907 10908 FormatStyle SomeSpace = getLLVMStyle(); 10909 SomeSpace.SpaceBeforeParens = FormatStyle::SBPO_NonEmptyParentheses; 10910 10911 verifyFormat("[]() -> float {}", SomeSpace); 10912 verifyFormat("[] (auto foo) {}", SomeSpace); 10913 verifyFormat("[foo]() -> int {}", SomeSpace); 10914 verifyFormat("int f();", SomeSpace); 10915 verifyFormat("void f (int a, T b) {\n" 10916 " while (true)\n" 10917 " continue;\n" 10918 "}", 10919 SomeSpace); 10920 verifyFormat("if (true)\n" 10921 " f();\n" 10922 "else if (true)\n" 10923 " f();", 10924 SomeSpace); 10925 verifyFormat("do {\n" 10926 " do_something();\n" 10927 "} while (something());", 10928 SomeSpace); 10929 verifyFormat("switch (x) {\n" 10930 "default:\n" 10931 " break;\n" 10932 "}", 10933 SomeSpace); 10934 verifyFormat("A::A() : a (1) {}", SomeSpace); 10935 verifyFormat("void f() __attribute__ ((asdf));", SomeSpace); 10936 verifyFormat("*(&a + 1);\n" 10937 "&((&a)[1]);\n" 10938 "a[(b + c) * d];\n" 10939 "(((a + 1) * 2) + 3) * 4;", 10940 SomeSpace); 10941 verifyFormat("#define A(x) x", SomeSpace); 10942 verifyFormat("#define A (x) x", SomeSpace); 10943 verifyFormat("#if defined(x)\n" 10944 "#endif", 10945 SomeSpace); 10946 verifyFormat("auto i = std::make_unique<int> (5);", SomeSpace); 10947 verifyFormat("size_t x = sizeof (x);", SomeSpace); 10948 verifyFormat("auto f (int x) -> decltype (x);", SomeSpace); 10949 verifyFormat("int f (T x) noexcept (x.create());", SomeSpace); 10950 verifyFormat("alignas (128) char a[128];", SomeSpace); 10951 verifyFormat("size_t x = alignof (MyType);", SomeSpace); 10952 verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");", 10953 SomeSpace); 10954 verifyFormat("int f() throw (Deprecated);", SomeSpace); 10955 verifyFormat("typedef void (*cb) (int);", SomeSpace); 10956 verifyFormat("T A::operator()();", SomeSpace); 10957 verifyFormat("X A::operator++ (T);", SomeSpace); 10958 verifyFormat("int x = int (y);", SomeSpace); 10959 verifyFormat("auto lambda = []() { return 0; };", SomeSpace); 10960 } 10961 10962 TEST_F(FormatTest, SpaceAfterLogicalNot) { 10963 FormatStyle Spaces = getLLVMStyle(); 10964 Spaces.SpaceAfterLogicalNot = true; 10965 10966 verifyFormat("bool x = ! y", Spaces); 10967 verifyFormat("if (! isFailure())", Spaces); 10968 verifyFormat("if (! (a && b))", Spaces); 10969 verifyFormat("\"Error!\"", Spaces); 10970 verifyFormat("! ! x", Spaces); 10971 } 10972 10973 TEST_F(FormatTest, ConfigurableSpacesInParentheses) { 10974 FormatStyle Spaces = getLLVMStyle(); 10975 10976 Spaces.SpacesInParentheses = true; 10977 verifyFormat("do_something( ::globalVar );", Spaces); 10978 verifyFormat("call( x, y, z );", Spaces); 10979 verifyFormat("call();", Spaces); 10980 verifyFormat("std::function<void( int, int )> callback;", Spaces); 10981 verifyFormat("void inFunction() { std::function<void( int, int )> fct; }", 10982 Spaces); 10983 verifyFormat("while ( (bool)1 )\n" 10984 " continue;", 10985 Spaces); 10986 verifyFormat("for ( ;; )\n" 10987 " continue;", 10988 Spaces); 10989 verifyFormat("if ( true )\n" 10990 " f();\n" 10991 "else if ( true )\n" 10992 " f();", 10993 Spaces); 10994 verifyFormat("do {\n" 10995 " do_something( (int)i );\n" 10996 "} while ( something() );", 10997 Spaces); 10998 verifyFormat("switch ( x ) {\n" 10999 "default:\n" 11000 " break;\n" 11001 "}", 11002 Spaces); 11003 11004 Spaces.SpacesInParentheses = false; 11005 Spaces.SpacesInCStyleCastParentheses = true; 11006 verifyFormat("Type *A = ( Type * )P;", Spaces); 11007 verifyFormat("Type *A = ( vector<Type *, int *> )P;", Spaces); 11008 verifyFormat("x = ( int32 )y;", Spaces); 11009 verifyFormat("int a = ( int )(2.0f);", Spaces); 11010 verifyFormat("#define AA(X) sizeof((( X * )NULL)->a)", Spaces); 11011 verifyFormat("my_int a = ( my_int )sizeof(int);", Spaces); 11012 verifyFormat("#define x (( int )-1)", Spaces); 11013 11014 // Run the first set of tests again with: 11015 Spaces.SpacesInParentheses = false; 11016 Spaces.SpaceInEmptyParentheses = true; 11017 Spaces.SpacesInCStyleCastParentheses = true; 11018 verifyFormat("call(x, y, z);", Spaces); 11019 verifyFormat("call( );", Spaces); 11020 verifyFormat("std::function<void(int, int)> callback;", Spaces); 11021 verifyFormat("while (( bool )1)\n" 11022 " continue;", 11023 Spaces); 11024 verifyFormat("for (;;)\n" 11025 " continue;", 11026 Spaces); 11027 verifyFormat("if (true)\n" 11028 " f( );\n" 11029 "else if (true)\n" 11030 " f( );", 11031 Spaces); 11032 verifyFormat("do {\n" 11033 " do_something(( int )i);\n" 11034 "} while (something( ));", 11035 Spaces); 11036 verifyFormat("switch (x) {\n" 11037 "default:\n" 11038 " break;\n" 11039 "}", 11040 Spaces); 11041 11042 // Run the first set of tests again with: 11043 Spaces.SpaceAfterCStyleCast = true; 11044 verifyFormat("call(x, y, z);", Spaces); 11045 verifyFormat("call( );", Spaces); 11046 verifyFormat("std::function<void(int, int)> callback;", Spaces); 11047 verifyFormat("while (( bool ) 1)\n" 11048 " continue;", 11049 Spaces); 11050 verifyFormat("for (;;)\n" 11051 " continue;", 11052 Spaces); 11053 verifyFormat("if (true)\n" 11054 " f( );\n" 11055 "else if (true)\n" 11056 " f( );", 11057 Spaces); 11058 verifyFormat("do {\n" 11059 " do_something(( int ) i);\n" 11060 "} while (something( ));", 11061 Spaces); 11062 verifyFormat("switch (x) {\n" 11063 "default:\n" 11064 " break;\n" 11065 "}", 11066 Spaces); 11067 11068 // Run subset of tests again with: 11069 Spaces.SpacesInCStyleCastParentheses = false; 11070 Spaces.SpaceAfterCStyleCast = true; 11071 verifyFormat("while ((bool) 1)\n" 11072 " continue;", 11073 Spaces); 11074 verifyFormat("do {\n" 11075 " do_something((int) i);\n" 11076 "} while (something( ));", 11077 Spaces); 11078 } 11079 11080 TEST_F(FormatTest, ConfigurableSpacesInSquareBrackets) { 11081 verifyFormat("int a[5];"); 11082 verifyFormat("a[3] += 42;"); 11083 11084 FormatStyle Spaces = getLLVMStyle(); 11085 Spaces.SpacesInSquareBrackets = true; 11086 // Not lambdas. 11087 verifyFormat("int a[ 5 ];", Spaces); 11088 verifyFormat("a[ 3 ] += 42;", Spaces); 11089 verifyFormat("constexpr char hello[]{\"hello\"};", Spaces); 11090 verifyFormat("double &operator[](int i) { return 0; }\n" 11091 "int i;", 11092 Spaces); 11093 verifyFormat("std::unique_ptr<int[]> foo() {}", Spaces); 11094 verifyFormat("int i = a[ a ][ a ]->f();", Spaces); 11095 verifyFormat("int i = (*b)[ a ]->f();", Spaces); 11096 // Lambdas. 11097 verifyFormat("int c = []() -> int { return 2; }();\n", Spaces); 11098 verifyFormat("return [ i, args... ] {};", Spaces); 11099 verifyFormat("int foo = [ &bar ]() {};", Spaces); 11100 verifyFormat("int foo = [ = ]() {};", Spaces); 11101 verifyFormat("int foo = [ & ]() {};", Spaces); 11102 verifyFormat("int foo = [ =, &bar ]() {};", Spaces); 11103 verifyFormat("int foo = [ &bar, = ]() {};", Spaces); 11104 } 11105 11106 TEST_F(FormatTest, ConfigurableSpaceBeforeBrackets) { 11107 FormatStyle NoSpaceStyle = getLLVMStyle(); 11108 verifyFormat("int a[5];", NoSpaceStyle); 11109 verifyFormat("a[3] += 42;", NoSpaceStyle); 11110 11111 verifyFormat("int a[1];", NoSpaceStyle); 11112 verifyFormat("int 1 [a];", NoSpaceStyle); 11113 verifyFormat("int a[1][2];", NoSpaceStyle); 11114 verifyFormat("a[7] = 5;", NoSpaceStyle); 11115 verifyFormat("int a = (f())[23];", NoSpaceStyle); 11116 verifyFormat("f([] {})", NoSpaceStyle); 11117 11118 FormatStyle Space = getLLVMStyle(); 11119 Space.SpaceBeforeSquareBrackets = true; 11120 verifyFormat("int c = []() -> int { return 2; }();\n", Space); 11121 verifyFormat("return [i, args...] {};", Space); 11122 11123 verifyFormat("int a [5];", Space); 11124 verifyFormat("a [3] += 42;", Space); 11125 verifyFormat("constexpr char hello []{\"hello\"};", Space); 11126 verifyFormat("double &operator[](int i) { return 0; }\n" 11127 "int i;", 11128 Space); 11129 verifyFormat("std::unique_ptr<int []> foo() {}", Space); 11130 verifyFormat("int i = a [a][a]->f();", Space); 11131 verifyFormat("int i = (*b) [a]->f();", Space); 11132 11133 verifyFormat("int a [1];", Space); 11134 verifyFormat("int 1 [a];", Space); 11135 verifyFormat("int a [1][2];", Space); 11136 verifyFormat("a [7] = 5;", Space); 11137 verifyFormat("int a = (f()) [23];", Space); 11138 verifyFormat("f([] {})", Space); 11139 } 11140 11141 TEST_F(FormatTest, ConfigurableSpaceBeforeAssignmentOperators) { 11142 verifyFormat("int a = 5;"); 11143 verifyFormat("a += 42;"); 11144 verifyFormat("a or_eq 8;"); 11145 11146 FormatStyle Spaces = getLLVMStyle(); 11147 Spaces.SpaceBeforeAssignmentOperators = false; 11148 verifyFormat("int a= 5;", Spaces); 11149 verifyFormat("a+= 42;", Spaces); 11150 verifyFormat("a or_eq 8;", Spaces); 11151 } 11152 11153 TEST_F(FormatTest, ConfigurableSpaceBeforeColon) { 11154 verifyFormat("class Foo : public Bar {};"); 11155 verifyFormat("Foo::Foo() : foo(1) {}"); 11156 verifyFormat("for (auto a : b) {\n}"); 11157 verifyFormat("int x = a ? b : c;"); 11158 verifyFormat("{\n" 11159 "label0:\n" 11160 " int x = 0;\n" 11161 "}"); 11162 verifyFormat("switch (x) {\n" 11163 "case 1:\n" 11164 "default:\n" 11165 "}"); 11166 11167 FormatStyle CtorInitializerStyle = getLLVMStyleWithColumns(30); 11168 CtorInitializerStyle.SpaceBeforeCtorInitializerColon = false; 11169 verifyFormat("class Foo : public Bar {};", CtorInitializerStyle); 11170 verifyFormat("Foo::Foo(): foo(1) {}", CtorInitializerStyle); 11171 verifyFormat("for (auto a : b) {\n}", CtorInitializerStyle); 11172 verifyFormat("int x = a ? b : c;", CtorInitializerStyle); 11173 verifyFormat("{\n" 11174 "label1:\n" 11175 " int x = 0;\n" 11176 "}", 11177 CtorInitializerStyle); 11178 verifyFormat("switch (x) {\n" 11179 "case 1:\n" 11180 "default:\n" 11181 "}", 11182 CtorInitializerStyle); 11183 CtorInitializerStyle.BreakConstructorInitializers = 11184 FormatStyle::BCIS_AfterColon; 11185 verifyFormat("Fooooooooooo::Fooooooooooo():\n" 11186 " aaaaaaaaaaaaaaaa(1),\n" 11187 " bbbbbbbbbbbbbbbb(2) {}", 11188 CtorInitializerStyle); 11189 CtorInitializerStyle.BreakConstructorInitializers = 11190 FormatStyle::BCIS_BeforeComma; 11191 verifyFormat("Fooooooooooo::Fooooooooooo()\n" 11192 " : aaaaaaaaaaaaaaaa(1)\n" 11193 " , bbbbbbbbbbbbbbbb(2) {}", 11194 CtorInitializerStyle); 11195 CtorInitializerStyle.BreakConstructorInitializers = 11196 FormatStyle::BCIS_BeforeColon; 11197 verifyFormat("Fooooooooooo::Fooooooooooo()\n" 11198 " : aaaaaaaaaaaaaaaa(1),\n" 11199 " bbbbbbbbbbbbbbbb(2) {}", 11200 CtorInitializerStyle); 11201 CtorInitializerStyle.ConstructorInitializerIndentWidth = 0; 11202 verifyFormat("Fooooooooooo::Fooooooooooo()\n" 11203 ": aaaaaaaaaaaaaaaa(1),\n" 11204 " bbbbbbbbbbbbbbbb(2) {}", 11205 CtorInitializerStyle); 11206 11207 FormatStyle InheritanceStyle = getLLVMStyleWithColumns(30); 11208 InheritanceStyle.SpaceBeforeInheritanceColon = false; 11209 verifyFormat("class Foo: public Bar {};", InheritanceStyle); 11210 verifyFormat("Foo::Foo() : foo(1) {}", InheritanceStyle); 11211 verifyFormat("for (auto a : b) {\n}", InheritanceStyle); 11212 verifyFormat("int x = a ? b : c;", InheritanceStyle); 11213 verifyFormat("{\n" 11214 "label2:\n" 11215 " int x = 0;\n" 11216 "}", 11217 InheritanceStyle); 11218 verifyFormat("switch (x) {\n" 11219 "case 1:\n" 11220 "default:\n" 11221 "}", 11222 InheritanceStyle); 11223 InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_AfterColon; 11224 verifyFormat("class Foooooooooooooooooooooo:\n" 11225 " public aaaaaaaaaaaaaaaaaa,\n" 11226 " public bbbbbbbbbbbbbbbbbb {\n" 11227 "}", 11228 InheritanceStyle); 11229 InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeComma; 11230 verifyFormat("class Foooooooooooooooooooooo\n" 11231 " : public aaaaaaaaaaaaaaaaaa\n" 11232 " , public bbbbbbbbbbbbbbbbbb {\n" 11233 "}", 11234 InheritanceStyle); 11235 InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeColon; 11236 verifyFormat("class Foooooooooooooooooooooo\n" 11237 " : public aaaaaaaaaaaaaaaaaa,\n" 11238 " public bbbbbbbbbbbbbbbbbb {\n" 11239 "}", 11240 InheritanceStyle); 11241 InheritanceStyle.ConstructorInitializerIndentWidth = 0; 11242 verifyFormat("class Foooooooooooooooooooooo\n" 11243 ": public aaaaaaaaaaaaaaaaaa,\n" 11244 " public bbbbbbbbbbbbbbbbbb {}", 11245 InheritanceStyle); 11246 11247 FormatStyle ForLoopStyle = getLLVMStyle(); 11248 ForLoopStyle.SpaceBeforeRangeBasedForLoopColon = false; 11249 verifyFormat("class Foo : public Bar {};", ForLoopStyle); 11250 verifyFormat("Foo::Foo() : foo(1) {}", ForLoopStyle); 11251 verifyFormat("for (auto a: b) {\n}", ForLoopStyle); 11252 verifyFormat("int x = a ? b : c;", ForLoopStyle); 11253 verifyFormat("{\n" 11254 "label2:\n" 11255 " int x = 0;\n" 11256 "}", 11257 ForLoopStyle); 11258 verifyFormat("switch (x) {\n" 11259 "case 1:\n" 11260 "default:\n" 11261 "}", 11262 ForLoopStyle); 11263 11264 FormatStyle NoSpaceStyle = getLLVMStyle(); 11265 NoSpaceStyle.SpaceBeforeCtorInitializerColon = false; 11266 NoSpaceStyle.SpaceBeforeInheritanceColon = false; 11267 NoSpaceStyle.SpaceBeforeRangeBasedForLoopColon = false; 11268 verifyFormat("class Foo: public Bar {};", NoSpaceStyle); 11269 verifyFormat("Foo::Foo(): foo(1) {}", NoSpaceStyle); 11270 verifyFormat("for (auto a: b) {\n}", NoSpaceStyle); 11271 verifyFormat("int x = a ? b : c;", NoSpaceStyle); 11272 verifyFormat("{\n" 11273 "label3:\n" 11274 " int x = 0;\n" 11275 "}", 11276 NoSpaceStyle); 11277 verifyFormat("switch (x) {\n" 11278 "case 1:\n" 11279 "default:\n" 11280 "}", 11281 NoSpaceStyle); 11282 } 11283 11284 TEST_F(FormatTest, AlignConsecutiveMacros) { 11285 FormatStyle Style = getLLVMStyle(); 11286 Style.AlignConsecutiveAssignments = true; 11287 Style.AlignConsecutiveDeclarations = true; 11288 Style.AlignConsecutiveMacros = false; 11289 11290 verifyFormat("#define a 3\n" 11291 "#define bbbb 4\n" 11292 "#define ccc (5)", 11293 Style); 11294 11295 verifyFormat("#define f(x) (x * x)\n" 11296 "#define fff(x, y, z) (x * y + z)\n" 11297 "#define ffff(x, y) (x - y)", 11298 Style); 11299 11300 verifyFormat("#define foo(x, y) (x + y)\n" 11301 "#define bar (5, 6)(2 + 2)", 11302 Style); 11303 11304 verifyFormat("#define a 3\n" 11305 "#define bbbb 4\n" 11306 "#define ccc (5)\n" 11307 "#define f(x) (x * x)\n" 11308 "#define fff(x, y, z) (x * y + z)\n" 11309 "#define ffff(x, y) (x - y)", 11310 Style); 11311 11312 Style.AlignConsecutiveMacros = true; 11313 verifyFormat("#define a 3\n" 11314 "#define bbbb 4\n" 11315 "#define ccc (5)", 11316 Style); 11317 11318 verifyFormat("#define f(x) (x * x)\n" 11319 "#define fff(x, y, z) (x * y + z)\n" 11320 "#define ffff(x, y) (x - y)", 11321 Style); 11322 11323 verifyFormat("#define foo(x, y) (x + y)\n" 11324 "#define bar (5, 6)(2 + 2)", 11325 Style); 11326 11327 verifyFormat("#define a 3\n" 11328 "#define bbbb 4\n" 11329 "#define ccc (5)\n" 11330 "#define f(x) (x * x)\n" 11331 "#define fff(x, y, z) (x * y + z)\n" 11332 "#define ffff(x, y) (x - y)", 11333 Style); 11334 11335 verifyFormat("#define a 5\n" 11336 "#define foo(x, y) (x + y)\n" 11337 "#define CCC (6)\n" 11338 "auto lambda = []() {\n" 11339 " auto ii = 0;\n" 11340 " float j = 0;\n" 11341 " return 0;\n" 11342 "};\n" 11343 "int i = 0;\n" 11344 "float i2 = 0;\n" 11345 "auto v = type{\n" 11346 " i = 1, //\n" 11347 " (i = 2), //\n" 11348 " i = 3 //\n" 11349 "};", 11350 Style); 11351 11352 Style.AlignConsecutiveMacros = false; 11353 Style.ColumnLimit = 20; 11354 11355 verifyFormat("#define a \\\n" 11356 " \"aabbbbbbbbbbbb\"\n" 11357 "#define D \\\n" 11358 " \"aabbbbbbbbbbbb\" \\\n" 11359 " \"ccddeeeeeeeee\"\n" 11360 "#define B \\\n" 11361 " \"QQQQQQQQQQQQQ\" \\\n" 11362 " \"FFFFFFFFFFFFF\" \\\n" 11363 " \"LLLLLLLL\"\n", 11364 Style); 11365 11366 Style.AlignConsecutiveMacros = true; 11367 verifyFormat("#define a \\\n" 11368 " \"aabbbbbbbbbbbb\"\n" 11369 "#define D \\\n" 11370 " \"aabbbbbbbbbbbb\" \\\n" 11371 " \"ccddeeeeeeeee\"\n" 11372 "#define B \\\n" 11373 " \"QQQQQQQQQQQQQ\" \\\n" 11374 " \"FFFFFFFFFFFFF\" \\\n" 11375 " \"LLLLLLLL\"\n", 11376 Style); 11377 } 11378 11379 TEST_F(FormatTest, AlignConsecutiveAssignments) { 11380 FormatStyle Alignment = getLLVMStyle(); 11381 Alignment.AlignConsecutiveMacros = true; 11382 Alignment.AlignConsecutiveAssignments = false; 11383 verifyFormat("int a = 5;\n" 11384 "int oneTwoThree = 123;", 11385 Alignment); 11386 verifyFormat("int a = 5;\n" 11387 "int oneTwoThree = 123;", 11388 Alignment); 11389 11390 Alignment.AlignConsecutiveAssignments = true; 11391 verifyFormat("int a = 5;\n" 11392 "int oneTwoThree = 123;", 11393 Alignment); 11394 verifyFormat("int a = method();\n" 11395 "int oneTwoThree = 133;", 11396 Alignment); 11397 verifyFormat("a &= 5;\n" 11398 "bcd *= 5;\n" 11399 "ghtyf += 5;\n" 11400 "dvfvdb -= 5;\n" 11401 "a /= 5;\n" 11402 "vdsvsv %= 5;\n" 11403 "sfdbddfbdfbb ^= 5;\n" 11404 "dvsdsv |= 5;\n" 11405 "int dsvvdvsdvvv = 123;", 11406 Alignment); 11407 verifyFormat("int i = 1, j = 10;\n" 11408 "something = 2000;", 11409 Alignment); 11410 verifyFormat("something = 2000;\n" 11411 "int i = 1, j = 10;\n", 11412 Alignment); 11413 verifyFormat("something = 2000;\n" 11414 "another = 911;\n" 11415 "int i = 1, j = 10;\n" 11416 "oneMore = 1;\n" 11417 "i = 2;", 11418 Alignment); 11419 verifyFormat("int a = 5;\n" 11420 "int one = 1;\n" 11421 "method();\n" 11422 "int oneTwoThree = 123;\n" 11423 "int oneTwo = 12;", 11424 Alignment); 11425 verifyFormat("int oneTwoThree = 123;\n" 11426 "int oneTwo = 12;\n" 11427 "method();\n", 11428 Alignment); 11429 verifyFormat("int oneTwoThree = 123; // comment\n" 11430 "int oneTwo = 12; // comment", 11431 Alignment); 11432 EXPECT_EQ("int a = 5;\n" 11433 "\n" 11434 "int oneTwoThree = 123;", 11435 format("int a = 5;\n" 11436 "\n" 11437 "int oneTwoThree= 123;", 11438 Alignment)); 11439 EXPECT_EQ("int a = 5;\n" 11440 "int one = 1;\n" 11441 "\n" 11442 "int oneTwoThree = 123;", 11443 format("int a = 5;\n" 11444 "int one = 1;\n" 11445 "\n" 11446 "int oneTwoThree = 123;", 11447 Alignment)); 11448 EXPECT_EQ("int a = 5;\n" 11449 "int one = 1;\n" 11450 "\n" 11451 "int oneTwoThree = 123;\n" 11452 "int oneTwo = 12;", 11453 format("int a = 5;\n" 11454 "int one = 1;\n" 11455 "\n" 11456 "int oneTwoThree = 123;\n" 11457 "int oneTwo = 12;", 11458 Alignment)); 11459 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign; 11460 verifyFormat("#define A \\\n" 11461 " int aaaa = 12; \\\n" 11462 " int b = 23; \\\n" 11463 " int ccc = 234; \\\n" 11464 " int dddddddddd = 2345;", 11465 Alignment); 11466 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left; 11467 verifyFormat("#define A \\\n" 11468 " int aaaa = 12; \\\n" 11469 " int b = 23; \\\n" 11470 " int ccc = 234; \\\n" 11471 " int dddddddddd = 2345;", 11472 Alignment); 11473 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right; 11474 verifyFormat("#define A " 11475 " \\\n" 11476 " int aaaa = 12; " 11477 " \\\n" 11478 " int b = 23; " 11479 " \\\n" 11480 " int ccc = 234; " 11481 " \\\n" 11482 " int dddddddddd = 2345;", 11483 Alignment); 11484 verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int " 11485 "k = 4, int l = 5,\n" 11486 " int m = 6) {\n" 11487 " int j = 10;\n" 11488 " otherThing = 1;\n" 11489 "}", 11490 Alignment); 11491 verifyFormat("void SomeFunction(int parameter = 0) {\n" 11492 " int i = 1;\n" 11493 " int j = 2;\n" 11494 " int big = 10000;\n" 11495 "}", 11496 Alignment); 11497 verifyFormat("class C {\n" 11498 "public:\n" 11499 " int i = 1;\n" 11500 " virtual void f() = 0;\n" 11501 "};", 11502 Alignment); 11503 verifyFormat("int i = 1;\n" 11504 "if (SomeType t = getSomething()) {\n" 11505 "}\n" 11506 "int j = 2;\n" 11507 "int big = 10000;", 11508 Alignment); 11509 verifyFormat("int j = 7;\n" 11510 "for (int k = 0; k < N; ++k) {\n" 11511 "}\n" 11512 "int j = 2;\n" 11513 "int big = 10000;\n" 11514 "}", 11515 Alignment); 11516 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 11517 verifyFormat("int i = 1;\n" 11518 "LooooooooooongType loooooooooooooooooooooongVariable\n" 11519 " = someLooooooooooooooooongFunction();\n" 11520 "int j = 2;", 11521 Alignment); 11522 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 11523 verifyFormat("int i = 1;\n" 11524 "LooooooooooongType loooooooooooooooooooooongVariable =\n" 11525 " someLooooooooooooooooongFunction();\n" 11526 "int j = 2;", 11527 Alignment); 11528 11529 verifyFormat("auto lambda = []() {\n" 11530 " auto i = 0;\n" 11531 " return 0;\n" 11532 "};\n" 11533 "int i = 0;\n" 11534 "auto v = type{\n" 11535 " i = 1, //\n" 11536 " (i = 2), //\n" 11537 " i = 3 //\n" 11538 "};", 11539 Alignment); 11540 11541 verifyFormat( 11542 "int i = 1;\n" 11543 "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n" 11544 " loooooooooooooooooooooongParameterB);\n" 11545 "int j = 2;", 11546 Alignment); 11547 11548 verifyFormat("template <typename T, typename T_0 = very_long_type_name_0,\n" 11549 " typename B = very_long_type_name_1,\n" 11550 " typename T_2 = very_long_type_name_2>\n" 11551 "auto foo() {}\n", 11552 Alignment); 11553 verifyFormat("int a, b = 1;\n" 11554 "int c = 2;\n" 11555 "int dd = 3;\n", 11556 Alignment); 11557 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n" 11558 "float b[1][] = {{3.f}};\n", 11559 Alignment); 11560 verifyFormat("for (int i = 0; i < 1; i++)\n" 11561 " int x = 1;\n", 11562 Alignment); 11563 verifyFormat("for (i = 0; i < 1; i++)\n" 11564 " x = 1;\n" 11565 "y = 1;\n", 11566 Alignment); 11567 } 11568 11569 TEST_F(FormatTest, AlignConsecutiveDeclarations) { 11570 FormatStyle Alignment = getLLVMStyle(); 11571 Alignment.AlignConsecutiveMacros = true; 11572 Alignment.AlignConsecutiveDeclarations = false; 11573 verifyFormat("float const a = 5;\n" 11574 "int oneTwoThree = 123;", 11575 Alignment); 11576 verifyFormat("int a = 5;\n" 11577 "float const oneTwoThree = 123;", 11578 Alignment); 11579 11580 Alignment.AlignConsecutiveDeclarations = true; 11581 verifyFormat("float const a = 5;\n" 11582 "int oneTwoThree = 123;", 11583 Alignment); 11584 verifyFormat("int a = method();\n" 11585 "float const oneTwoThree = 133;", 11586 Alignment); 11587 verifyFormat("int i = 1, j = 10;\n" 11588 "something = 2000;", 11589 Alignment); 11590 verifyFormat("something = 2000;\n" 11591 "int i = 1, j = 10;\n", 11592 Alignment); 11593 verifyFormat("float something = 2000;\n" 11594 "double another = 911;\n" 11595 "int i = 1, j = 10;\n" 11596 "const int *oneMore = 1;\n" 11597 "unsigned i = 2;", 11598 Alignment); 11599 verifyFormat("float a = 5;\n" 11600 "int one = 1;\n" 11601 "method();\n" 11602 "const double oneTwoThree = 123;\n" 11603 "const unsigned int oneTwo = 12;", 11604 Alignment); 11605 verifyFormat("int oneTwoThree{0}; // comment\n" 11606 "unsigned oneTwo; // comment", 11607 Alignment); 11608 EXPECT_EQ("float const a = 5;\n" 11609 "\n" 11610 "int oneTwoThree = 123;", 11611 format("float const a = 5;\n" 11612 "\n" 11613 "int oneTwoThree= 123;", 11614 Alignment)); 11615 EXPECT_EQ("float a = 5;\n" 11616 "int one = 1;\n" 11617 "\n" 11618 "unsigned oneTwoThree = 123;", 11619 format("float a = 5;\n" 11620 "int one = 1;\n" 11621 "\n" 11622 "unsigned oneTwoThree = 123;", 11623 Alignment)); 11624 EXPECT_EQ("float a = 5;\n" 11625 "int one = 1;\n" 11626 "\n" 11627 "unsigned oneTwoThree = 123;\n" 11628 "int oneTwo = 12;", 11629 format("float a = 5;\n" 11630 "int one = 1;\n" 11631 "\n" 11632 "unsigned oneTwoThree = 123;\n" 11633 "int oneTwo = 12;", 11634 Alignment)); 11635 // Function prototype alignment 11636 verifyFormat("int a();\n" 11637 "double b();", 11638 Alignment); 11639 verifyFormat("int a(int x);\n" 11640 "double b();", 11641 Alignment); 11642 unsigned OldColumnLimit = Alignment.ColumnLimit; 11643 // We need to set ColumnLimit to zero, in order to stress nested alignments, 11644 // otherwise the function parameters will be re-flowed onto a single line. 11645 Alignment.ColumnLimit = 0; 11646 EXPECT_EQ("int a(int x,\n" 11647 " float y);\n" 11648 "double b(int x,\n" 11649 " double y);", 11650 format("int a(int x,\n" 11651 " float y);\n" 11652 "double b(int x,\n" 11653 " double y);", 11654 Alignment)); 11655 // This ensures that function parameters of function declarations are 11656 // correctly indented when their owning functions are indented. 11657 // The failure case here is for 'double y' to not be indented enough. 11658 EXPECT_EQ("double a(int x);\n" 11659 "int b(int y,\n" 11660 " double z);", 11661 format("double a(int x);\n" 11662 "int b(int y,\n" 11663 " double z);", 11664 Alignment)); 11665 // Set ColumnLimit low so that we induce wrapping immediately after 11666 // the function name and opening paren. 11667 Alignment.ColumnLimit = 13; 11668 verifyFormat("int function(\n" 11669 " int x,\n" 11670 " bool y);", 11671 Alignment); 11672 Alignment.ColumnLimit = OldColumnLimit; 11673 // Ensure function pointers don't screw up recursive alignment 11674 verifyFormat("int a(int x, void (*fp)(int y));\n" 11675 "double b();", 11676 Alignment); 11677 Alignment.AlignConsecutiveAssignments = true; 11678 // Ensure recursive alignment is broken by function braces, so that the 11679 // "a = 1" does not align with subsequent assignments inside the function 11680 // body. 11681 verifyFormat("int func(int a = 1) {\n" 11682 " int b = 2;\n" 11683 " int cc = 3;\n" 11684 "}", 11685 Alignment); 11686 verifyFormat("float something = 2000;\n" 11687 "double another = 911;\n" 11688 "int i = 1, j = 10;\n" 11689 "const int *oneMore = 1;\n" 11690 "unsigned i = 2;", 11691 Alignment); 11692 verifyFormat("int oneTwoThree = {0}; // comment\n" 11693 "unsigned oneTwo = 0; // comment", 11694 Alignment); 11695 // Make sure that scope is correctly tracked, in the absence of braces 11696 verifyFormat("for (int i = 0; i < n; i++)\n" 11697 " j = i;\n" 11698 "double x = 1;\n", 11699 Alignment); 11700 verifyFormat("if (int i = 0)\n" 11701 " j = i;\n" 11702 "double x = 1;\n", 11703 Alignment); 11704 // Ensure operator[] and operator() are comprehended 11705 verifyFormat("struct test {\n" 11706 " long long int foo();\n" 11707 " int operator[](int a);\n" 11708 " double bar();\n" 11709 "};\n", 11710 Alignment); 11711 verifyFormat("struct test {\n" 11712 " long long int foo();\n" 11713 " int operator()(int a);\n" 11714 " double bar();\n" 11715 "};\n", 11716 Alignment); 11717 EXPECT_EQ("void SomeFunction(int parameter = 0) {\n" 11718 " int const i = 1;\n" 11719 " int * j = 2;\n" 11720 " int big = 10000;\n" 11721 "\n" 11722 " unsigned oneTwoThree = 123;\n" 11723 " int oneTwo = 12;\n" 11724 " method();\n" 11725 " float k = 2;\n" 11726 " int ll = 10000;\n" 11727 "}", 11728 format("void SomeFunction(int parameter= 0) {\n" 11729 " int const i= 1;\n" 11730 " int *j=2;\n" 11731 " int big = 10000;\n" 11732 "\n" 11733 "unsigned oneTwoThree =123;\n" 11734 "int oneTwo = 12;\n" 11735 " method();\n" 11736 "float k= 2;\n" 11737 "int ll=10000;\n" 11738 "}", 11739 Alignment)); 11740 Alignment.AlignConsecutiveAssignments = false; 11741 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign; 11742 verifyFormat("#define A \\\n" 11743 " int aaaa = 12; \\\n" 11744 " float b = 23; \\\n" 11745 " const int ccc = 234; \\\n" 11746 " unsigned dddddddddd = 2345;", 11747 Alignment); 11748 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left; 11749 verifyFormat("#define A \\\n" 11750 " int aaaa = 12; \\\n" 11751 " float b = 23; \\\n" 11752 " const int ccc = 234; \\\n" 11753 " unsigned dddddddddd = 2345;", 11754 Alignment); 11755 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right; 11756 Alignment.ColumnLimit = 30; 11757 verifyFormat("#define A \\\n" 11758 " int aaaa = 12; \\\n" 11759 " float b = 23; \\\n" 11760 " const int ccc = 234; \\\n" 11761 " int dddddddddd = 2345;", 11762 Alignment); 11763 Alignment.ColumnLimit = 80; 11764 verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int " 11765 "k = 4, int l = 5,\n" 11766 " int m = 6) {\n" 11767 " const int j = 10;\n" 11768 " otherThing = 1;\n" 11769 "}", 11770 Alignment); 11771 verifyFormat("void SomeFunction(int parameter = 0) {\n" 11772 " int const i = 1;\n" 11773 " int * j = 2;\n" 11774 " int big = 10000;\n" 11775 "}", 11776 Alignment); 11777 verifyFormat("class C {\n" 11778 "public:\n" 11779 " int i = 1;\n" 11780 " virtual void f() = 0;\n" 11781 "};", 11782 Alignment); 11783 verifyFormat("float i = 1;\n" 11784 "if (SomeType t = getSomething()) {\n" 11785 "}\n" 11786 "const unsigned j = 2;\n" 11787 "int big = 10000;", 11788 Alignment); 11789 verifyFormat("float j = 7;\n" 11790 "for (int k = 0; k < N; ++k) {\n" 11791 "}\n" 11792 "unsigned j = 2;\n" 11793 "int big = 10000;\n" 11794 "}", 11795 Alignment); 11796 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 11797 verifyFormat("float i = 1;\n" 11798 "LooooooooooongType loooooooooooooooooooooongVariable\n" 11799 " = someLooooooooooooooooongFunction();\n" 11800 "int j = 2;", 11801 Alignment); 11802 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 11803 verifyFormat("int i = 1;\n" 11804 "LooooooooooongType loooooooooooooooooooooongVariable =\n" 11805 " someLooooooooooooooooongFunction();\n" 11806 "int j = 2;", 11807 Alignment); 11808 11809 Alignment.AlignConsecutiveAssignments = true; 11810 verifyFormat("auto lambda = []() {\n" 11811 " auto ii = 0;\n" 11812 " float j = 0;\n" 11813 " return 0;\n" 11814 "};\n" 11815 "int i = 0;\n" 11816 "float i2 = 0;\n" 11817 "auto v = type{\n" 11818 " i = 1, //\n" 11819 " (i = 2), //\n" 11820 " i = 3 //\n" 11821 "};", 11822 Alignment); 11823 Alignment.AlignConsecutiveAssignments = false; 11824 11825 verifyFormat( 11826 "int i = 1;\n" 11827 "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n" 11828 " loooooooooooooooooooooongParameterB);\n" 11829 "int j = 2;", 11830 Alignment); 11831 11832 // Test interactions with ColumnLimit and AlignConsecutiveAssignments: 11833 // We expect declarations and assignments to align, as long as it doesn't 11834 // exceed the column limit, starting a new alignment sequence whenever it 11835 // happens. 11836 Alignment.AlignConsecutiveAssignments = true; 11837 Alignment.ColumnLimit = 30; 11838 verifyFormat("float ii = 1;\n" 11839 "unsigned j = 2;\n" 11840 "int someVerylongVariable = 1;\n" 11841 "AnotherLongType ll = 123456;\n" 11842 "VeryVeryLongType k = 2;\n" 11843 "int myvar = 1;", 11844 Alignment); 11845 Alignment.ColumnLimit = 80; 11846 Alignment.AlignConsecutiveAssignments = false; 11847 11848 verifyFormat( 11849 "template <typename LongTemplate, typename VeryLongTemplateTypeName,\n" 11850 " typename LongType, typename B>\n" 11851 "auto foo() {}\n", 11852 Alignment); 11853 verifyFormat("float a, b = 1;\n" 11854 "int c = 2;\n" 11855 "int dd = 3;\n", 11856 Alignment); 11857 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n" 11858 "float b[1][] = {{3.f}};\n", 11859 Alignment); 11860 Alignment.AlignConsecutiveAssignments = true; 11861 verifyFormat("float a, b = 1;\n" 11862 "int c = 2;\n" 11863 "int dd = 3;\n", 11864 Alignment); 11865 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n" 11866 "float b[1][] = {{3.f}};\n", 11867 Alignment); 11868 Alignment.AlignConsecutiveAssignments = false; 11869 11870 Alignment.ColumnLimit = 30; 11871 Alignment.BinPackParameters = false; 11872 verifyFormat("void foo(float a,\n" 11873 " float b,\n" 11874 " int c,\n" 11875 " uint32_t *d) {\n" 11876 " int * e = 0;\n" 11877 " float f = 0;\n" 11878 " double g = 0;\n" 11879 "}\n" 11880 "void bar(ino_t a,\n" 11881 " int b,\n" 11882 " uint32_t *c,\n" 11883 " bool d) {}\n", 11884 Alignment); 11885 Alignment.BinPackParameters = true; 11886 Alignment.ColumnLimit = 80; 11887 11888 // Bug 33507 11889 Alignment.PointerAlignment = FormatStyle::PAS_Middle; 11890 verifyFormat( 11891 "auto found = range::find_if(vsProducts, [&](auto * aProduct) {\n" 11892 " static const Version verVs2017;\n" 11893 " return true;\n" 11894 "});\n", 11895 Alignment); 11896 Alignment.PointerAlignment = FormatStyle::PAS_Right; 11897 11898 // See llvm.org/PR35641 11899 Alignment.AlignConsecutiveDeclarations = true; 11900 verifyFormat("int func() { //\n" 11901 " int b;\n" 11902 " unsigned c;\n" 11903 "}", 11904 Alignment); 11905 11906 // See PR37175 11907 FormatStyle Style = getMozillaStyle(); 11908 Style.AlignConsecutiveDeclarations = true; 11909 EXPECT_EQ("DECOR1 /**/ int8_t /**/ DECOR2 /**/\n" 11910 "foo(int a);", 11911 format("DECOR1 /**/ int8_t /**/ DECOR2 /**/ foo (int a);", Style)); 11912 } 11913 11914 TEST_F(FormatTest, LinuxBraceBreaking) { 11915 FormatStyle LinuxBraceStyle = getLLVMStyle(); 11916 LinuxBraceStyle.BreakBeforeBraces = FormatStyle::BS_Linux; 11917 verifyFormat("namespace a\n" 11918 "{\n" 11919 "class A\n" 11920 "{\n" 11921 " void f()\n" 11922 " {\n" 11923 " if (true) {\n" 11924 " a();\n" 11925 " b();\n" 11926 " } else {\n" 11927 " a();\n" 11928 " }\n" 11929 " }\n" 11930 " void g() { return; }\n" 11931 "};\n" 11932 "struct B {\n" 11933 " int x;\n" 11934 "};\n" 11935 "} // namespace a\n", 11936 LinuxBraceStyle); 11937 verifyFormat("enum X {\n" 11938 " Y = 0,\n" 11939 "}\n", 11940 LinuxBraceStyle); 11941 verifyFormat("struct S {\n" 11942 " int Type;\n" 11943 " union {\n" 11944 " int x;\n" 11945 " double y;\n" 11946 " } Value;\n" 11947 " class C\n" 11948 " {\n" 11949 " MyFavoriteType Value;\n" 11950 " } Class;\n" 11951 "}\n", 11952 LinuxBraceStyle); 11953 } 11954 11955 TEST_F(FormatTest, MozillaBraceBreaking) { 11956 FormatStyle MozillaBraceStyle = getLLVMStyle(); 11957 MozillaBraceStyle.BreakBeforeBraces = FormatStyle::BS_Mozilla; 11958 MozillaBraceStyle.FixNamespaceComments = false; 11959 verifyFormat("namespace a {\n" 11960 "class A\n" 11961 "{\n" 11962 " void f()\n" 11963 " {\n" 11964 " if (true) {\n" 11965 " a();\n" 11966 " b();\n" 11967 " }\n" 11968 " }\n" 11969 " void g() { return; }\n" 11970 "};\n" 11971 "enum E\n" 11972 "{\n" 11973 " A,\n" 11974 " // foo\n" 11975 " B,\n" 11976 " C\n" 11977 "};\n" 11978 "struct B\n" 11979 "{\n" 11980 " int x;\n" 11981 "};\n" 11982 "}\n", 11983 MozillaBraceStyle); 11984 verifyFormat("struct S\n" 11985 "{\n" 11986 " int Type;\n" 11987 " union\n" 11988 " {\n" 11989 " int x;\n" 11990 " double y;\n" 11991 " } Value;\n" 11992 " class C\n" 11993 " {\n" 11994 " MyFavoriteType Value;\n" 11995 " } Class;\n" 11996 "}\n", 11997 MozillaBraceStyle); 11998 } 11999 12000 TEST_F(FormatTest, StroustrupBraceBreaking) { 12001 FormatStyle StroustrupBraceStyle = getLLVMStyle(); 12002 StroustrupBraceStyle.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 12003 verifyFormat("namespace a {\n" 12004 "class A {\n" 12005 " void f()\n" 12006 " {\n" 12007 " if (true) {\n" 12008 " a();\n" 12009 " b();\n" 12010 " }\n" 12011 " }\n" 12012 " void g() { return; }\n" 12013 "};\n" 12014 "struct B {\n" 12015 " int x;\n" 12016 "};\n" 12017 "} // namespace a\n", 12018 StroustrupBraceStyle); 12019 12020 verifyFormat("void foo()\n" 12021 "{\n" 12022 " if (a) {\n" 12023 " a();\n" 12024 " }\n" 12025 " else {\n" 12026 " b();\n" 12027 " }\n" 12028 "}\n", 12029 StroustrupBraceStyle); 12030 12031 verifyFormat("#ifdef _DEBUG\n" 12032 "int foo(int i = 0)\n" 12033 "#else\n" 12034 "int foo(int i = 5)\n" 12035 "#endif\n" 12036 "{\n" 12037 " return i;\n" 12038 "}", 12039 StroustrupBraceStyle); 12040 12041 verifyFormat("void foo() {}\n" 12042 "void bar()\n" 12043 "#ifdef _DEBUG\n" 12044 "{\n" 12045 " foo();\n" 12046 "}\n" 12047 "#else\n" 12048 "{\n" 12049 "}\n" 12050 "#endif", 12051 StroustrupBraceStyle); 12052 12053 verifyFormat("void foobar() { int i = 5; }\n" 12054 "#ifdef _DEBUG\n" 12055 "void bar() {}\n" 12056 "#else\n" 12057 "void bar() { foobar(); }\n" 12058 "#endif", 12059 StroustrupBraceStyle); 12060 } 12061 12062 TEST_F(FormatTest, AllmanBraceBreaking) { 12063 FormatStyle AllmanBraceStyle = getLLVMStyle(); 12064 AllmanBraceStyle.BreakBeforeBraces = FormatStyle::BS_Allman; 12065 12066 EXPECT_EQ("namespace a\n" 12067 "{\n" 12068 "void f();\n" 12069 "void g();\n" 12070 "} // namespace a\n", 12071 format("namespace a\n" 12072 "{\n" 12073 "void f();\n" 12074 "void g();\n" 12075 "}\n", 12076 AllmanBraceStyle)); 12077 12078 verifyFormat("namespace a\n" 12079 "{\n" 12080 "class A\n" 12081 "{\n" 12082 " void f()\n" 12083 " {\n" 12084 " if (true)\n" 12085 " {\n" 12086 " a();\n" 12087 " b();\n" 12088 " }\n" 12089 " }\n" 12090 " void g() { return; }\n" 12091 "};\n" 12092 "struct B\n" 12093 "{\n" 12094 " int x;\n" 12095 "};\n" 12096 "union C\n" 12097 "{\n" 12098 "};\n" 12099 "} // namespace a", 12100 AllmanBraceStyle); 12101 12102 verifyFormat("void f()\n" 12103 "{\n" 12104 " if (true)\n" 12105 " {\n" 12106 " a();\n" 12107 " }\n" 12108 " else if (false)\n" 12109 " {\n" 12110 " b();\n" 12111 " }\n" 12112 " else\n" 12113 " {\n" 12114 " c();\n" 12115 " }\n" 12116 "}\n", 12117 AllmanBraceStyle); 12118 12119 verifyFormat("void f()\n" 12120 "{\n" 12121 " for (int i = 0; i < 10; ++i)\n" 12122 " {\n" 12123 " a();\n" 12124 " }\n" 12125 " while (false)\n" 12126 " {\n" 12127 " b();\n" 12128 " }\n" 12129 " do\n" 12130 " {\n" 12131 " c();\n" 12132 " } while (false)\n" 12133 "}\n", 12134 AllmanBraceStyle); 12135 12136 verifyFormat("void f(int a)\n" 12137 "{\n" 12138 " switch (a)\n" 12139 " {\n" 12140 " case 0:\n" 12141 " break;\n" 12142 " case 1:\n" 12143 " {\n" 12144 " break;\n" 12145 " }\n" 12146 " case 2:\n" 12147 " {\n" 12148 " }\n" 12149 " break;\n" 12150 " default:\n" 12151 " break;\n" 12152 " }\n" 12153 "}\n", 12154 AllmanBraceStyle); 12155 12156 verifyFormat("enum X\n" 12157 "{\n" 12158 " Y = 0,\n" 12159 "}\n", 12160 AllmanBraceStyle); 12161 verifyFormat("enum X\n" 12162 "{\n" 12163 " Y = 0\n" 12164 "}\n", 12165 AllmanBraceStyle); 12166 12167 verifyFormat("@interface BSApplicationController ()\n" 12168 "{\n" 12169 "@private\n" 12170 " id _extraIvar;\n" 12171 "}\n" 12172 "@end\n", 12173 AllmanBraceStyle); 12174 12175 verifyFormat("#ifdef _DEBUG\n" 12176 "int foo(int i = 0)\n" 12177 "#else\n" 12178 "int foo(int i = 5)\n" 12179 "#endif\n" 12180 "{\n" 12181 " return i;\n" 12182 "}", 12183 AllmanBraceStyle); 12184 12185 verifyFormat("void foo() {}\n" 12186 "void bar()\n" 12187 "#ifdef _DEBUG\n" 12188 "{\n" 12189 " foo();\n" 12190 "}\n" 12191 "#else\n" 12192 "{\n" 12193 "}\n" 12194 "#endif", 12195 AllmanBraceStyle); 12196 12197 verifyFormat("void foobar() { int i = 5; }\n" 12198 "#ifdef _DEBUG\n" 12199 "void bar() {}\n" 12200 "#else\n" 12201 "void bar() { foobar(); }\n" 12202 "#endif", 12203 AllmanBraceStyle); 12204 12205 // This shouldn't affect ObjC blocks.. 12206 verifyFormat("[self doSomeThingWithACompletionHandler:^{\n" 12207 " // ...\n" 12208 " int i;\n" 12209 "}];", 12210 AllmanBraceStyle); 12211 verifyFormat("void (^block)(void) = ^{\n" 12212 " // ...\n" 12213 " int i;\n" 12214 "};", 12215 AllmanBraceStyle); 12216 // .. or dict literals. 12217 verifyFormat("void f()\n" 12218 "{\n" 12219 " // ...\n" 12220 " [object someMethod:@{@\"a\" : @\"b\"}];\n" 12221 "}", 12222 AllmanBraceStyle); 12223 verifyFormat("void f()\n" 12224 "{\n" 12225 " // ...\n" 12226 " [object someMethod:@{a : @\"b\"}];\n" 12227 "}", 12228 AllmanBraceStyle); 12229 verifyFormat("int f()\n" 12230 "{ // comment\n" 12231 " return 42;\n" 12232 "}", 12233 AllmanBraceStyle); 12234 12235 AllmanBraceStyle.ColumnLimit = 19; 12236 verifyFormat("void f() { int i; }", AllmanBraceStyle); 12237 AllmanBraceStyle.ColumnLimit = 18; 12238 verifyFormat("void f()\n" 12239 "{\n" 12240 " int i;\n" 12241 "}", 12242 AllmanBraceStyle); 12243 AllmanBraceStyle.ColumnLimit = 80; 12244 12245 FormatStyle BreakBeforeBraceShortIfs = AllmanBraceStyle; 12246 BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine = 12247 FormatStyle::SIS_WithoutElse; 12248 BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true; 12249 verifyFormat("void f(bool b)\n" 12250 "{\n" 12251 " if (b)\n" 12252 " {\n" 12253 " return;\n" 12254 " }\n" 12255 "}\n", 12256 BreakBeforeBraceShortIfs); 12257 verifyFormat("void f(bool b)\n" 12258 "{\n" 12259 " if constexpr (b)\n" 12260 " {\n" 12261 " return;\n" 12262 " }\n" 12263 "}\n", 12264 BreakBeforeBraceShortIfs); 12265 verifyFormat("void f(bool b)\n" 12266 "{\n" 12267 " if CONSTEXPR (b)\n" 12268 " {\n" 12269 " return;\n" 12270 " }\n" 12271 "}\n", 12272 BreakBeforeBraceShortIfs); 12273 verifyFormat("void f(bool b)\n" 12274 "{\n" 12275 " if (b) return;\n" 12276 "}\n", 12277 BreakBeforeBraceShortIfs); 12278 verifyFormat("void f(bool b)\n" 12279 "{\n" 12280 " if constexpr (b) return;\n" 12281 "}\n", 12282 BreakBeforeBraceShortIfs); 12283 verifyFormat("void f(bool b)\n" 12284 "{\n" 12285 " if CONSTEXPR (b) return;\n" 12286 "}\n", 12287 BreakBeforeBraceShortIfs); 12288 verifyFormat("void f(bool b)\n" 12289 "{\n" 12290 " while (b)\n" 12291 " {\n" 12292 " return;\n" 12293 " }\n" 12294 "}\n", 12295 BreakBeforeBraceShortIfs); 12296 } 12297 12298 TEST_F(FormatTest, WhitesmithsBraceBreaking) { 12299 FormatStyle WhitesmithsBraceStyle = getLLVMStyle(); 12300 WhitesmithsBraceStyle.BreakBeforeBraces = FormatStyle::BS_Whitesmiths; 12301 12302 // Make a few changes to the style for testing purposes 12303 WhitesmithsBraceStyle.AllowShortFunctionsOnASingleLine = 12304 FormatStyle::SFS_Empty; 12305 WhitesmithsBraceStyle.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None; 12306 WhitesmithsBraceStyle.ColumnLimit = 0; 12307 12308 // FIXME: this test case can't decide whether there should be a blank line 12309 // after the ~D() line or not. It adds one if one doesn't exist in the test 12310 // and it removes the line if one exists. 12311 /* 12312 verifyFormat("class A;\n" 12313 "namespace B\n" 12314 " {\n" 12315 "class C;\n" 12316 "// Comment\n" 12317 "class D\n" 12318 " {\n" 12319 "public:\n" 12320 " D();\n" 12321 " ~D() {}\n" 12322 "private:\n" 12323 " enum E\n" 12324 " {\n" 12325 " F\n" 12326 " }\n" 12327 " };\n" 12328 " } // namespace B\n", 12329 WhitesmithsBraceStyle); 12330 */ 12331 12332 verifyFormat("namespace a\n" 12333 " {\n" 12334 "class A\n" 12335 " {\n" 12336 " void f()\n" 12337 " {\n" 12338 " if (true)\n" 12339 " {\n" 12340 " a();\n" 12341 " b();\n" 12342 " }\n" 12343 " }\n" 12344 " void g()\n" 12345 " {\n" 12346 " return;\n" 12347 " }\n" 12348 " };\n" 12349 "struct B\n" 12350 " {\n" 12351 " int x;\n" 12352 " };\n" 12353 " } // namespace a", 12354 WhitesmithsBraceStyle); 12355 12356 verifyFormat("void f()\n" 12357 " {\n" 12358 " if (true)\n" 12359 " {\n" 12360 " a();\n" 12361 " }\n" 12362 " else if (false)\n" 12363 " {\n" 12364 " b();\n" 12365 " }\n" 12366 " else\n" 12367 " {\n" 12368 " c();\n" 12369 " }\n" 12370 " }\n", 12371 WhitesmithsBraceStyle); 12372 12373 verifyFormat("void f()\n" 12374 " {\n" 12375 " for (int i = 0; i < 10; ++i)\n" 12376 " {\n" 12377 " a();\n" 12378 " }\n" 12379 " while (false)\n" 12380 " {\n" 12381 " b();\n" 12382 " }\n" 12383 " do\n" 12384 " {\n" 12385 " c();\n" 12386 " } while (false)\n" 12387 " }\n", 12388 WhitesmithsBraceStyle); 12389 12390 // FIXME: the block and the break under case 2 in this test don't get indented 12391 // correctly 12392 /* 12393 verifyFormat("void switchTest1(int a)\n" 12394 " {\n" 12395 " switch (a)\n" 12396 " {\n" 12397 " case 2:\n" 12398 " {\n" 12399 " }\n" 12400 " break;\n" 12401 " }\n" 12402 " }\n", 12403 WhitesmithsBraceStyle); 12404 */ 12405 12406 // FIXME: the block and the break under case 2 in this test don't get indented 12407 // correctly 12408 /* 12409 verifyFormat("void switchTest2(int a)\n" 12410 " {\n" 12411 " switch (a)\n" 12412 " {\n" 12413 " case 0:\n" 12414 " break;\n" 12415 " case 1:\n" 12416 " {\n" 12417 " break;\n" 12418 " }\n" 12419 " case 2:\n" 12420 " {\n" 12421 " }\n" 12422 " break;\n" 12423 " default:\n" 12424 " break;\n" 12425 " }\n" 12426 " }\n", 12427 WhitesmithsBraceStyle); 12428 */ 12429 12430 verifyFormat("enum X\n" 12431 " {\n" 12432 " Y = 0, // testing\n" 12433 " }\n", 12434 WhitesmithsBraceStyle); 12435 12436 verifyFormat("enum X\n" 12437 " {\n" 12438 " Y = 0\n" 12439 " }\n", 12440 WhitesmithsBraceStyle); 12441 verifyFormat("enum X\n" 12442 " {\n" 12443 " Y = 0,\n" 12444 " Z = 1\n" 12445 " };\n", 12446 WhitesmithsBraceStyle); 12447 12448 verifyFormat("@interface BSApplicationController ()\n" 12449 " {\n" 12450 "@private\n" 12451 " id _extraIvar;\n" 12452 " }\n" 12453 "@end\n", 12454 WhitesmithsBraceStyle); 12455 12456 verifyFormat("#ifdef _DEBUG\n" 12457 "int foo(int i = 0)\n" 12458 "#else\n" 12459 "int foo(int i = 5)\n" 12460 "#endif\n" 12461 " {\n" 12462 " return i;\n" 12463 " }", 12464 WhitesmithsBraceStyle); 12465 12466 verifyFormat("void foo() {}\n" 12467 "void bar()\n" 12468 "#ifdef _DEBUG\n" 12469 " {\n" 12470 " foo();\n" 12471 " }\n" 12472 "#else\n" 12473 " {\n" 12474 " }\n" 12475 "#endif", 12476 WhitesmithsBraceStyle); 12477 12478 verifyFormat("void foobar()\n" 12479 " {\n" 12480 " int i = 5;\n" 12481 " }\n" 12482 "#ifdef _DEBUG\n" 12483 "void bar()\n" 12484 " {\n" 12485 " }\n" 12486 "#else\n" 12487 "void bar()\n" 12488 " {\n" 12489 " foobar();\n" 12490 " }\n" 12491 "#endif", 12492 WhitesmithsBraceStyle); 12493 12494 // This shouldn't affect ObjC blocks.. 12495 verifyFormat("[self doSomeThingWithACompletionHandler:^{\n" 12496 " // ...\n" 12497 " int i;\n" 12498 "}];", 12499 WhitesmithsBraceStyle); 12500 verifyFormat("void (^block)(void) = ^{\n" 12501 " // ...\n" 12502 " int i;\n" 12503 "};", 12504 WhitesmithsBraceStyle); 12505 // .. or dict literals. 12506 verifyFormat("void f()\n" 12507 " {\n" 12508 " [object someMethod:@{@\"a\" : @\"b\"}];\n" 12509 " }", 12510 WhitesmithsBraceStyle); 12511 12512 verifyFormat("int f()\n" 12513 " { // comment\n" 12514 " return 42;\n" 12515 " }", 12516 WhitesmithsBraceStyle); 12517 12518 FormatStyle BreakBeforeBraceShortIfs = WhitesmithsBraceStyle; 12519 BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine = 12520 FormatStyle::SIS_Always; 12521 BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true; 12522 verifyFormat("void f(bool b)\n" 12523 " {\n" 12524 " if (b)\n" 12525 " {\n" 12526 " return;\n" 12527 " }\n" 12528 " }\n", 12529 BreakBeforeBraceShortIfs); 12530 verifyFormat("void f(bool b)\n" 12531 " {\n" 12532 " if (b) return;\n" 12533 " }\n", 12534 BreakBeforeBraceShortIfs); 12535 verifyFormat("void f(bool b)\n" 12536 " {\n" 12537 " while (b)\n" 12538 " {\n" 12539 " return;\n" 12540 " }\n" 12541 " }\n", 12542 BreakBeforeBraceShortIfs); 12543 } 12544 12545 TEST_F(FormatTest, GNUBraceBreaking) { 12546 FormatStyle GNUBraceStyle = getLLVMStyle(); 12547 GNUBraceStyle.BreakBeforeBraces = FormatStyle::BS_GNU; 12548 verifyFormat("namespace a\n" 12549 "{\n" 12550 "class A\n" 12551 "{\n" 12552 " void f()\n" 12553 " {\n" 12554 " int a;\n" 12555 " {\n" 12556 " int b;\n" 12557 " }\n" 12558 " if (true)\n" 12559 " {\n" 12560 " a();\n" 12561 " b();\n" 12562 " }\n" 12563 " }\n" 12564 " void g() { return; }\n" 12565 "}\n" 12566 "} // namespace a", 12567 GNUBraceStyle); 12568 12569 verifyFormat("void f()\n" 12570 "{\n" 12571 " if (true)\n" 12572 " {\n" 12573 " a();\n" 12574 " }\n" 12575 " else if (false)\n" 12576 " {\n" 12577 " b();\n" 12578 " }\n" 12579 " else\n" 12580 " {\n" 12581 " c();\n" 12582 " }\n" 12583 "}\n", 12584 GNUBraceStyle); 12585 12586 verifyFormat("void f()\n" 12587 "{\n" 12588 " for (int i = 0; i < 10; ++i)\n" 12589 " {\n" 12590 " a();\n" 12591 " }\n" 12592 " while (false)\n" 12593 " {\n" 12594 " b();\n" 12595 " }\n" 12596 " do\n" 12597 " {\n" 12598 " c();\n" 12599 " }\n" 12600 " while (false);\n" 12601 "}\n", 12602 GNUBraceStyle); 12603 12604 verifyFormat("void f(int a)\n" 12605 "{\n" 12606 " switch (a)\n" 12607 " {\n" 12608 " case 0:\n" 12609 " break;\n" 12610 " case 1:\n" 12611 " {\n" 12612 " break;\n" 12613 " }\n" 12614 " case 2:\n" 12615 " {\n" 12616 " }\n" 12617 " break;\n" 12618 " default:\n" 12619 " break;\n" 12620 " }\n" 12621 "}\n", 12622 GNUBraceStyle); 12623 12624 verifyFormat("enum X\n" 12625 "{\n" 12626 " Y = 0,\n" 12627 "}\n", 12628 GNUBraceStyle); 12629 12630 verifyFormat("@interface BSApplicationController ()\n" 12631 "{\n" 12632 "@private\n" 12633 " id _extraIvar;\n" 12634 "}\n" 12635 "@end\n", 12636 GNUBraceStyle); 12637 12638 verifyFormat("#ifdef _DEBUG\n" 12639 "int foo(int i = 0)\n" 12640 "#else\n" 12641 "int foo(int i = 5)\n" 12642 "#endif\n" 12643 "{\n" 12644 " return i;\n" 12645 "}", 12646 GNUBraceStyle); 12647 12648 verifyFormat("void foo() {}\n" 12649 "void bar()\n" 12650 "#ifdef _DEBUG\n" 12651 "{\n" 12652 " foo();\n" 12653 "}\n" 12654 "#else\n" 12655 "{\n" 12656 "}\n" 12657 "#endif", 12658 GNUBraceStyle); 12659 12660 verifyFormat("void foobar() { int i = 5; }\n" 12661 "#ifdef _DEBUG\n" 12662 "void bar() {}\n" 12663 "#else\n" 12664 "void bar() { foobar(); }\n" 12665 "#endif", 12666 GNUBraceStyle); 12667 } 12668 12669 TEST_F(FormatTest, WebKitBraceBreaking) { 12670 FormatStyle WebKitBraceStyle = getLLVMStyle(); 12671 WebKitBraceStyle.BreakBeforeBraces = FormatStyle::BS_WebKit; 12672 WebKitBraceStyle.FixNamespaceComments = false; 12673 verifyFormat("namespace a {\n" 12674 "class A {\n" 12675 " void f()\n" 12676 " {\n" 12677 " if (true) {\n" 12678 " a();\n" 12679 " b();\n" 12680 " }\n" 12681 " }\n" 12682 " void g() { return; }\n" 12683 "};\n" 12684 "enum E {\n" 12685 " A,\n" 12686 " // foo\n" 12687 " B,\n" 12688 " C\n" 12689 "};\n" 12690 "struct B {\n" 12691 " int x;\n" 12692 "};\n" 12693 "}\n", 12694 WebKitBraceStyle); 12695 verifyFormat("struct S {\n" 12696 " int Type;\n" 12697 " union {\n" 12698 " int x;\n" 12699 " double y;\n" 12700 " } Value;\n" 12701 " class C {\n" 12702 " MyFavoriteType Value;\n" 12703 " } Class;\n" 12704 "};\n", 12705 WebKitBraceStyle); 12706 } 12707 12708 TEST_F(FormatTest, CatchExceptionReferenceBinding) { 12709 verifyFormat("void f() {\n" 12710 " try {\n" 12711 " } catch (const Exception &e) {\n" 12712 " }\n" 12713 "}\n", 12714 getLLVMStyle()); 12715 } 12716 12717 TEST_F(FormatTest, UnderstandsPragmas) { 12718 verifyFormat("#pragma omp reduction(| : var)"); 12719 verifyFormat("#pragma omp reduction(+ : var)"); 12720 12721 EXPECT_EQ("#pragma mark Any non-hyphenated or hyphenated string " 12722 "(including parentheses).", 12723 format("#pragma mark Any non-hyphenated or hyphenated string " 12724 "(including parentheses).")); 12725 } 12726 12727 TEST_F(FormatTest, UnderstandPragmaOption) { 12728 verifyFormat("#pragma option -C -A"); 12729 12730 EXPECT_EQ("#pragma option -C -A", format("#pragma option -C -A")); 12731 } 12732 12733 TEST_F(FormatTest, OptimizeBreakPenaltyVsExcess) { 12734 FormatStyle Style = getLLVMStyle(); 12735 Style.ColumnLimit = 20; 12736 12737 // See PR41213 12738 EXPECT_EQ("/*\n" 12739 " *\t9012345\n" 12740 " * /8901\n" 12741 " */", 12742 format("/*\n" 12743 " *\t9012345 /8901\n" 12744 " */", 12745 Style)); 12746 EXPECT_EQ("/*\n" 12747 " *345678\n" 12748 " *\t/8901\n" 12749 " */", 12750 format("/*\n" 12751 " *345678\t/8901\n" 12752 " */", 12753 Style)); 12754 12755 verifyFormat("int a; // the\n" 12756 " // comment", 12757 Style); 12758 EXPECT_EQ("int a; /* first line\n" 12759 " * second\n" 12760 " * line third\n" 12761 " * line\n" 12762 " */", 12763 format("int a; /* first line\n" 12764 " * second\n" 12765 " * line third\n" 12766 " * line\n" 12767 " */", 12768 Style)); 12769 EXPECT_EQ("int a; // first line\n" 12770 " // second\n" 12771 " // line third\n" 12772 " // line", 12773 format("int a; // first line\n" 12774 " // second line\n" 12775 " // third line", 12776 Style)); 12777 12778 Style.PenaltyExcessCharacter = 90; 12779 verifyFormat("int a; // the comment", Style); 12780 EXPECT_EQ("int a; // the comment\n" 12781 " // aaa", 12782 format("int a; // the comment aaa", Style)); 12783 EXPECT_EQ("int a; /* first line\n" 12784 " * second line\n" 12785 " * third line\n" 12786 " */", 12787 format("int a; /* first line\n" 12788 " * second line\n" 12789 " * third line\n" 12790 " */", 12791 Style)); 12792 EXPECT_EQ("int a; // first line\n" 12793 " // second line\n" 12794 " // third line", 12795 format("int a; // first line\n" 12796 " // second line\n" 12797 " // third line", 12798 Style)); 12799 // FIXME: Investigate why this is not getting the same layout as the test 12800 // above. 12801 EXPECT_EQ("int a; /* first line\n" 12802 " * second line\n" 12803 " * third line\n" 12804 " */", 12805 format("int a; /* first line second line third line" 12806 "\n*/", 12807 Style)); 12808 12809 EXPECT_EQ("// foo bar baz bazfoo\n" 12810 "// foo bar foo bar\n", 12811 format("// foo bar baz bazfoo\n" 12812 "// foo bar foo bar\n", 12813 Style)); 12814 EXPECT_EQ("// foo bar baz bazfoo\n" 12815 "// foo bar foo bar\n", 12816 format("// foo bar baz bazfoo\n" 12817 "// foo bar foo bar\n", 12818 Style)); 12819 12820 // FIXME: Optimally, we'd keep bazfoo on the first line and reflow bar to the 12821 // next one. 12822 EXPECT_EQ("// foo bar baz bazfoo\n" 12823 "// bar foo bar\n", 12824 format("// foo bar baz bazfoo bar\n" 12825 "// foo bar\n", 12826 Style)); 12827 12828 EXPECT_EQ("// foo bar baz bazfoo\n" 12829 "// foo bar baz bazfoo\n" 12830 "// bar foo bar\n", 12831 format("// foo bar baz bazfoo\n" 12832 "// foo bar baz bazfoo bar\n" 12833 "// foo bar\n", 12834 Style)); 12835 12836 EXPECT_EQ("// foo bar baz bazfoo\n" 12837 "// foo bar baz bazfoo\n" 12838 "// bar foo bar\n", 12839 format("// foo bar baz bazfoo\n" 12840 "// foo bar baz bazfoo bar\n" 12841 "// foo bar\n", 12842 Style)); 12843 12844 // Make sure we do not keep protruding characters if strict mode reflow is 12845 // cheaper than keeping protruding characters. 12846 Style.ColumnLimit = 21; 12847 EXPECT_EQ( 12848 "// foo foo foo foo\n" 12849 "// foo foo foo foo\n" 12850 "// foo foo foo foo\n", 12851 format("// foo foo foo foo foo foo foo foo foo foo foo foo\n", Style)); 12852 12853 EXPECT_EQ("int a = /* long block\n" 12854 " comment */\n" 12855 " 42;", 12856 format("int a = /* long block comment */ 42;", Style)); 12857 } 12858 12859 #define EXPECT_ALL_STYLES_EQUAL(Styles) \ 12860 for (size_t i = 1; i < Styles.size(); ++i) \ 12861 EXPECT_EQ(Styles[0], Styles[i]) \ 12862 << "Style #" << i << " of " << Styles.size() << " differs from Style #0" 12863 12864 TEST_F(FormatTest, GetsPredefinedStyleByName) { 12865 SmallVector<FormatStyle, 3> Styles; 12866 Styles.resize(3); 12867 12868 Styles[0] = getLLVMStyle(); 12869 EXPECT_TRUE(getPredefinedStyle("LLVM", FormatStyle::LK_Cpp, &Styles[1])); 12870 EXPECT_TRUE(getPredefinedStyle("lLvM", FormatStyle::LK_Cpp, &Styles[2])); 12871 EXPECT_ALL_STYLES_EQUAL(Styles); 12872 12873 Styles[0] = getGoogleStyle(); 12874 EXPECT_TRUE(getPredefinedStyle("Google", FormatStyle::LK_Cpp, &Styles[1])); 12875 EXPECT_TRUE(getPredefinedStyle("gOOgle", FormatStyle::LK_Cpp, &Styles[2])); 12876 EXPECT_ALL_STYLES_EQUAL(Styles); 12877 12878 Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript); 12879 EXPECT_TRUE( 12880 getPredefinedStyle("Google", FormatStyle::LK_JavaScript, &Styles[1])); 12881 EXPECT_TRUE( 12882 getPredefinedStyle("gOOgle", FormatStyle::LK_JavaScript, &Styles[2])); 12883 EXPECT_ALL_STYLES_EQUAL(Styles); 12884 12885 Styles[0] = getChromiumStyle(FormatStyle::LK_Cpp); 12886 EXPECT_TRUE(getPredefinedStyle("Chromium", FormatStyle::LK_Cpp, &Styles[1])); 12887 EXPECT_TRUE(getPredefinedStyle("cHRoMiUM", FormatStyle::LK_Cpp, &Styles[2])); 12888 EXPECT_ALL_STYLES_EQUAL(Styles); 12889 12890 Styles[0] = getMozillaStyle(); 12891 EXPECT_TRUE(getPredefinedStyle("Mozilla", FormatStyle::LK_Cpp, &Styles[1])); 12892 EXPECT_TRUE(getPredefinedStyle("moZILla", FormatStyle::LK_Cpp, &Styles[2])); 12893 EXPECT_ALL_STYLES_EQUAL(Styles); 12894 12895 Styles[0] = getWebKitStyle(); 12896 EXPECT_TRUE(getPredefinedStyle("WebKit", FormatStyle::LK_Cpp, &Styles[1])); 12897 EXPECT_TRUE(getPredefinedStyle("wEbKit", FormatStyle::LK_Cpp, &Styles[2])); 12898 EXPECT_ALL_STYLES_EQUAL(Styles); 12899 12900 Styles[0] = getGNUStyle(); 12901 EXPECT_TRUE(getPredefinedStyle("GNU", FormatStyle::LK_Cpp, &Styles[1])); 12902 EXPECT_TRUE(getPredefinedStyle("gnU", FormatStyle::LK_Cpp, &Styles[2])); 12903 EXPECT_ALL_STYLES_EQUAL(Styles); 12904 12905 EXPECT_FALSE(getPredefinedStyle("qwerty", FormatStyle::LK_Cpp, &Styles[0])); 12906 } 12907 12908 TEST_F(FormatTest, GetsCorrectBasedOnStyle) { 12909 SmallVector<FormatStyle, 8> Styles; 12910 Styles.resize(2); 12911 12912 Styles[0] = getGoogleStyle(); 12913 Styles[1] = getLLVMStyle(); 12914 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value()); 12915 EXPECT_ALL_STYLES_EQUAL(Styles); 12916 12917 Styles.resize(5); 12918 Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript); 12919 Styles[1] = getLLVMStyle(); 12920 Styles[1].Language = FormatStyle::LK_JavaScript; 12921 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value()); 12922 12923 Styles[2] = getLLVMStyle(); 12924 Styles[2].Language = FormatStyle::LK_JavaScript; 12925 EXPECT_EQ(0, parseConfiguration("Language: JavaScript\n" 12926 "BasedOnStyle: Google", 12927 &Styles[2]) 12928 .value()); 12929 12930 Styles[3] = getLLVMStyle(); 12931 Styles[3].Language = FormatStyle::LK_JavaScript; 12932 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google\n" 12933 "Language: JavaScript", 12934 &Styles[3]) 12935 .value()); 12936 12937 Styles[4] = getLLVMStyle(); 12938 Styles[4].Language = FormatStyle::LK_JavaScript; 12939 EXPECT_EQ(0, parseConfiguration("---\n" 12940 "BasedOnStyle: LLVM\n" 12941 "IndentWidth: 123\n" 12942 "---\n" 12943 "BasedOnStyle: Google\n" 12944 "Language: JavaScript", 12945 &Styles[4]) 12946 .value()); 12947 EXPECT_ALL_STYLES_EQUAL(Styles); 12948 } 12949 12950 #define CHECK_PARSE_BOOL_FIELD(FIELD, CONFIG_NAME) \ 12951 Style.FIELD = false; \ 12952 EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": true", &Style).value()); \ 12953 EXPECT_TRUE(Style.FIELD); \ 12954 EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": false", &Style).value()); \ 12955 EXPECT_FALSE(Style.FIELD); 12956 12957 #define CHECK_PARSE_BOOL(FIELD) CHECK_PARSE_BOOL_FIELD(FIELD, #FIELD) 12958 12959 #define CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, CONFIG_NAME) \ 12960 Style.STRUCT.FIELD = false; \ 12961 EXPECT_EQ(0, \ 12962 parseConfiguration(#STRUCT ":\n " CONFIG_NAME ": true", &Style) \ 12963 .value()); \ 12964 EXPECT_TRUE(Style.STRUCT.FIELD); \ 12965 EXPECT_EQ(0, \ 12966 parseConfiguration(#STRUCT ":\n " CONFIG_NAME ": false", &Style) \ 12967 .value()); \ 12968 EXPECT_FALSE(Style.STRUCT.FIELD); 12969 12970 #define CHECK_PARSE_NESTED_BOOL(STRUCT, FIELD) \ 12971 CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, #FIELD) 12972 12973 #define CHECK_PARSE(TEXT, FIELD, VALUE) \ 12974 EXPECT_NE(VALUE, Style.FIELD); \ 12975 EXPECT_EQ(0, parseConfiguration(TEXT, &Style).value()); \ 12976 EXPECT_EQ(VALUE, Style.FIELD) 12977 12978 TEST_F(FormatTest, ParsesConfigurationBools) { 12979 FormatStyle Style = {}; 12980 Style.Language = FormatStyle::LK_Cpp; 12981 CHECK_PARSE_BOOL(AlignOperands); 12982 CHECK_PARSE_BOOL(AlignTrailingComments); 12983 CHECK_PARSE_BOOL(AlignConsecutiveAssignments); 12984 CHECK_PARSE_BOOL(AlignConsecutiveDeclarations); 12985 CHECK_PARSE_BOOL(AlignConsecutiveMacros); 12986 CHECK_PARSE_BOOL(AllowAllArgumentsOnNextLine); 12987 CHECK_PARSE_BOOL(AllowAllConstructorInitializersOnNextLine); 12988 CHECK_PARSE_BOOL(AllowAllParametersOfDeclarationOnNextLine); 12989 CHECK_PARSE_BOOL(AllowShortCaseLabelsOnASingleLine); 12990 CHECK_PARSE_BOOL(AllowShortEnumsOnASingleLine); 12991 CHECK_PARSE_BOOL(AllowShortLoopsOnASingleLine); 12992 CHECK_PARSE_BOOL(BinPackArguments); 12993 CHECK_PARSE_BOOL(BinPackParameters); 12994 CHECK_PARSE_BOOL(BreakAfterJavaFieldAnnotations); 12995 CHECK_PARSE_BOOL(BreakBeforeTernaryOperators); 12996 CHECK_PARSE_BOOL(BreakStringLiterals); 12997 CHECK_PARSE_BOOL(CompactNamespaces); 12998 CHECK_PARSE_BOOL(ConstructorInitializerAllOnOneLineOrOnePerLine); 12999 CHECK_PARSE_BOOL(DeriveLineEnding); 13000 CHECK_PARSE_BOOL(DerivePointerAlignment); 13001 CHECK_PARSE_BOOL_FIELD(DerivePointerAlignment, "DerivePointerBinding"); 13002 CHECK_PARSE_BOOL(DisableFormat); 13003 CHECK_PARSE_BOOL(IndentCaseLabels); 13004 CHECK_PARSE_BOOL(IndentCaseBlocks); 13005 CHECK_PARSE_BOOL(IndentGotoLabels); 13006 CHECK_PARSE_BOOL(IndentWrappedFunctionNames); 13007 CHECK_PARSE_BOOL(KeepEmptyLinesAtTheStartOfBlocks); 13008 CHECK_PARSE_BOOL(ObjCSpaceAfterProperty); 13009 CHECK_PARSE_BOOL(ObjCSpaceBeforeProtocolList); 13010 CHECK_PARSE_BOOL(Cpp11BracedListStyle); 13011 CHECK_PARSE_BOOL(ReflowComments); 13012 CHECK_PARSE_BOOL(SortIncludes); 13013 CHECK_PARSE_BOOL(SortUsingDeclarations); 13014 CHECK_PARSE_BOOL(SpacesInParentheses); 13015 CHECK_PARSE_BOOL(SpacesInSquareBrackets); 13016 CHECK_PARSE_BOOL(SpacesInAngles); 13017 CHECK_PARSE_BOOL(SpacesInConditionalStatement); 13018 CHECK_PARSE_BOOL(SpaceInEmptyBlock); 13019 CHECK_PARSE_BOOL(SpaceInEmptyParentheses); 13020 CHECK_PARSE_BOOL(SpacesInContainerLiterals); 13021 CHECK_PARSE_BOOL(SpacesInCStyleCastParentheses); 13022 CHECK_PARSE_BOOL(SpaceAfterCStyleCast); 13023 CHECK_PARSE_BOOL(SpaceAfterTemplateKeyword); 13024 CHECK_PARSE_BOOL(SpaceAfterLogicalNot); 13025 CHECK_PARSE_BOOL(SpaceBeforeAssignmentOperators); 13026 CHECK_PARSE_BOOL(SpaceBeforeCpp11BracedList); 13027 CHECK_PARSE_BOOL(SpaceBeforeCtorInitializerColon); 13028 CHECK_PARSE_BOOL(SpaceBeforeInheritanceColon); 13029 CHECK_PARSE_BOOL(SpaceBeforeRangeBasedForLoopColon); 13030 CHECK_PARSE_BOOL(SpaceBeforeSquareBrackets); 13031 CHECK_PARSE_BOOL(UseCRLF); 13032 13033 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterCaseLabel); 13034 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterClass); 13035 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterEnum); 13036 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterFunction); 13037 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterNamespace); 13038 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterObjCDeclaration); 13039 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterStruct); 13040 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterUnion); 13041 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterExternBlock); 13042 CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeCatch); 13043 CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeElse); 13044 CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeLambdaBody); 13045 CHECK_PARSE_NESTED_BOOL(BraceWrapping, IndentBraces); 13046 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyFunction); 13047 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyRecord); 13048 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyNamespace); 13049 } 13050 13051 #undef CHECK_PARSE_BOOL 13052 13053 TEST_F(FormatTest, ParsesConfiguration) { 13054 FormatStyle Style = {}; 13055 Style.Language = FormatStyle::LK_Cpp; 13056 CHECK_PARSE("AccessModifierOffset: -1234", AccessModifierOffset, -1234); 13057 CHECK_PARSE("ConstructorInitializerIndentWidth: 1234", 13058 ConstructorInitializerIndentWidth, 1234u); 13059 CHECK_PARSE("ObjCBlockIndentWidth: 1234", ObjCBlockIndentWidth, 1234u); 13060 CHECK_PARSE("ColumnLimit: 1234", ColumnLimit, 1234u); 13061 CHECK_PARSE("MaxEmptyLinesToKeep: 1234", MaxEmptyLinesToKeep, 1234u); 13062 CHECK_PARSE("PenaltyBreakAssignment: 1234", PenaltyBreakAssignment, 1234u); 13063 CHECK_PARSE("PenaltyBreakBeforeFirstCallParameter: 1234", 13064 PenaltyBreakBeforeFirstCallParameter, 1234u); 13065 CHECK_PARSE("PenaltyBreakTemplateDeclaration: 1234", 13066 PenaltyBreakTemplateDeclaration, 1234u); 13067 CHECK_PARSE("PenaltyExcessCharacter: 1234", PenaltyExcessCharacter, 1234u); 13068 CHECK_PARSE("PenaltyReturnTypeOnItsOwnLine: 1234", 13069 PenaltyReturnTypeOnItsOwnLine, 1234u); 13070 CHECK_PARSE("SpacesBeforeTrailingComments: 1234", 13071 SpacesBeforeTrailingComments, 1234u); 13072 CHECK_PARSE("IndentWidth: 32", IndentWidth, 32u); 13073 CHECK_PARSE("ContinuationIndentWidth: 11", ContinuationIndentWidth, 11u); 13074 CHECK_PARSE("CommentPragmas: '// abc$'", CommentPragmas, "// abc$"); 13075 13076 Style.PointerAlignment = FormatStyle::PAS_Middle; 13077 CHECK_PARSE("PointerAlignment: Left", PointerAlignment, 13078 FormatStyle::PAS_Left); 13079 CHECK_PARSE("PointerAlignment: Right", PointerAlignment, 13080 FormatStyle::PAS_Right); 13081 CHECK_PARSE("PointerAlignment: Middle", PointerAlignment, 13082 FormatStyle::PAS_Middle); 13083 // For backward compatibility: 13084 CHECK_PARSE("PointerBindsToType: Left", PointerAlignment, 13085 FormatStyle::PAS_Left); 13086 CHECK_PARSE("PointerBindsToType: Right", PointerAlignment, 13087 FormatStyle::PAS_Right); 13088 CHECK_PARSE("PointerBindsToType: Middle", PointerAlignment, 13089 FormatStyle::PAS_Middle); 13090 13091 Style.Standard = FormatStyle::LS_Auto; 13092 CHECK_PARSE("Standard: c++03", Standard, FormatStyle::LS_Cpp03); 13093 CHECK_PARSE("Standard: c++11", Standard, FormatStyle::LS_Cpp11); 13094 CHECK_PARSE("Standard: c++14", Standard, FormatStyle::LS_Cpp14); 13095 CHECK_PARSE("Standard: c++17", Standard, FormatStyle::LS_Cpp17); 13096 CHECK_PARSE("Standard: c++20", Standard, FormatStyle::LS_Cpp20); 13097 CHECK_PARSE("Standard: Auto", Standard, FormatStyle::LS_Auto); 13098 CHECK_PARSE("Standard: Latest", Standard, FormatStyle::LS_Latest); 13099 // Legacy aliases: 13100 CHECK_PARSE("Standard: Cpp03", Standard, FormatStyle::LS_Cpp03); 13101 CHECK_PARSE("Standard: Cpp11", Standard, FormatStyle::LS_Latest); 13102 CHECK_PARSE("Standard: C++03", Standard, FormatStyle::LS_Cpp03); 13103 CHECK_PARSE("Standard: C++11", Standard, FormatStyle::LS_Cpp11); 13104 13105 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 13106 CHECK_PARSE("BreakBeforeBinaryOperators: NonAssignment", 13107 BreakBeforeBinaryOperators, FormatStyle::BOS_NonAssignment); 13108 CHECK_PARSE("BreakBeforeBinaryOperators: None", BreakBeforeBinaryOperators, 13109 FormatStyle::BOS_None); 13110 CHECK_PARSE("BreakBeforeBinaryOperators: All", BreakBeforeBinaryOperators, 13111 FormatStyle::BOS_All); 13112 // For backward compatibility: 13113 CHECK_PARSE("BreakBeforeBinaryOperators: false", BreakBeforeBinaryOperators, 13114 FormatStyle::BOS_None); 13115 CHECK_PARSE("BreakBeforeBinaryOperators: true", BreakBeforeBinaryOperators, 13116 FormatStyle::BOS_All); 13117 13118 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon; 13119 CHECK_PARSE("BreakConstructorInitializers: BeforeComma", 13120 BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma); 13121 CHECK_PARSE("BreakConstructorInitializers: AfterColon", 13122 BreakConstructorInitializers, FormatStyle::BCIS_AfterColon); 13123 CHECK_PARSE("BreakConstructorInitializers: BeforeColon", 13124 BreakConstructorInitializers, FormatStyle::BCIS_BeforeColon); 13125 // For backward compatibility: 13126 CHECK_PARSE("BreakConstructorInitializersBeforeComma: true", 13127 BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma); 13128 13129 Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon; 13130 CHECK_PARSE("BreakInheritanceList: BeforeComma", BreakInheritanceList, 13131 FormatStyle::BILS_BeforeComma); 13132 CHECK_PARSE("BreakInheritanceList: AfterColon", BreakInheritanceList, 13133 FormatStyle::BILS_AfterColon); 13134 CHECK_PARSE("BreakInheritanceList: BeforeColon", BreakInheritanceList, 13135 FormatStyle::BILS_BeforeColon); 13136 // For backward compatibility: 13137 CHECK_PARSE("BreakBeforeInheritanceComma: true", BreakInheritanceList, 13138 FormatStyle::BILS_BeforeComma); 13139 13140 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 13141 CHECK_PARSE("AlignAfterOpenBracket: Align", AlignAfterOpenBracket, 13142 FormatStyle::BAS_Align); 13143 CHECK_PARSE("AlignAfterOpenBracket: DontAlign", AlignAfterOpenBracket, 13144 FormatStyle::BAS_DontAlign); 13145 CHECK_PARSE("AlignAfterOpenBracket: AlwaysBreak", AlignAfterOpenBracket, 13146 FormatStyle::BAS_AlwaysBreak); 13147 // For backward compatibility: 13148 CHECK_PARSE("AlignAfterOpenBracket: false", AlignAfterOpenBracket, 13149 FormatStyle::BAS_DontAlign); 13150 CHECK_PARSE("AlignAfterOpenBracket: true", AlignAfterOpenBracket, 13151 FormatStyle::BAS_Align); 13152 13153 Style.AlignEscapedNewlines = FormatStyle::ENAS_Left; 13154 CHECK_PARSE("AlignEscapedNewlines: DontAlign", AlignEscapedNewlines, 13155 FormatStyle::ENAS_DontAlign); 13156 CHECK_PARSE("AlignEscapedNewlines: Left", AlignEscapedNewlines, 13157 FormatStyle::ENAS_Left); 13158 CHECK_PARSE("AlignEscapedNewlines: Right", AlignEscapedNewlines, 13159 FormatStyle::ENAS_Right); 13160 // For backward compatibility: 13161 CHECK_PARSE("AlignEscapedNewlinesLeft: true", AlignEscapedNewlines, 13162 FormatStyle::ENAS_Left); 13163 CHECK_PARSE("AlignEscapedNewlinesLeft: false", AlignEscapedNewlines, 13164 FormatStyle::ENAS_Right); 13165 13166 Style.UseTab = FormatStyle::UT_ForIndentation; 13167 CHECK_PARSE("UseTab: Never", UseTab, FormatStyle::UT_Never); 13168 CHECK_PARSE("UseTab: ForIndentation", UseTab, FormatStyle::UT_ForIndentation); 13169 CHECK_PARSE("UseTab: Always", UseTab, FormatStyle::UT_Always); 13170 CHECK_PARSE("UseTab: ForContinuationAndIndentation", UseTab, 13171 FormatStyle::UT_ForContinuationAndIndentation); 13172 CHECK_PARSE("UseTab: AlignWithSpaces", UseTab, 13173 FormatStyle::UT_AlignWithSpaces); 13174 // For backward compatibility: 13175 CHECK_PARSE("UseTab: false", UseTab, FormatStyle::UT_Never); 13176 CHECK_PARSE("UseTab: true", UseTab, FormatStyle::UT_Always); 13177 13178 Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty; 13179 CHECK_PARSE("AllowShortBlocksOnASingleLine: Never", 13180 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never); 13181 CHECK_PARSE("AllowShortBlocksOnASingleLine: Empty", 13182 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Empty); 13183 CHECK_PARSE("AllowShortBlocksOnASingleLine: Always", 13184 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always); 13185 // For backward compatibility: 13186 CHECK_PARSE("AllowShortBlocksOnASingleLine: false", 13187 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never); 13188 CHECK_PARSE("AllowShortBlocksOnASingleLine: true", 13189 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always); 13190 13191 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; 13192 CHECK_PARSE("AllowShortFunctionsOnASingleLine: None", 13193 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None); 13194 CHECK_PARSE("AllowShortFunctionsOnASingleLine: Inline", 13195 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Inline); 13196 CHECK_PARSE("AllowShortFunctionsOnASingleLine: Empty", 13197 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Empty); 13198 CHECK_PARSE("AllowShortFunctionsOnASingleLine: All", 13199 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All); 13200 // For backward compatibility: 13201 CHECK_PARSE("AllowShortFunctionsOnASingleLine: false", 13202 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None); 13203 CHECK_PARSE("AllowShortFunctionsOnASingleLine: true", 13204 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All); 13205 13206 Style.SpaceBeforeParens = FormatStyle::SBPO_Always; 13207 CHECK_PARSE("SpaceBeforeParens: Never", SpaceBeforeParens, 13208 FormatStyle::SBPO_Never); 13209 CHECK_PARSE("SpaceBeforeParens: Always", SpaceBeforeParens, 13210 FormatStyle::SBPO_Always); 13211 CHECK_PARSE("SpaceBeforeParens: ControlStatements", SpaceBeforeParens, 13212 FormatStyle::SBPO_ControlStatements); 13213 CHECK_PARSE("SpaceBeforeParens: NonEmptyParentheses", SpaceBeforeParens, 13214 FormatStyle::SBPO_NonEmptyParentheses); 13215 // For backward compatibility: 13216 CHECK_PARSE("SpaceAfterControlStatementKeyword: false", SpaceBeforeParens, 13217 FormatStyle::SBPO_Never); 13218 CHECK_PARSE("SpaceAfterControlStatementKeyword: true", SpaceBeforeParens, 13219 FormatStyle::SBPO_ControlStatements); 13220 13221 Style.ColumnLimit = 123; 13222 FormatStyle BaseStyle = getLLVMStyle(); 13223 CHECK_PARSE("BasedOnStyle: LLVM", ColumnLimit, BaseStyle.ColumnLimit); 13224 CHECK_PARSE("BasedOnStyle: LLVM\nColumnLimit: 1234", ColumnLimit, 1234u); 13225 13226 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 13227 CHECK_PARSE("BreakBeforeBraces: Attach", BreakBeforeBraces, 13228 FormatStyle::BS_Attach); 13229 CHECK_PARSE("BreakBeforeBraces: Linux", BreakBeforeBraces, 13230 FormatStyle::BS_Linux); 13231 CHECK_PARSE("BreakBeforeBraces: Mozilla", BreakBeforeBraces, 13232 FormatStyle::BS_Mozilla); 13233 CHECK_PARSE("BreakBeforeBraces: Stroustrup", BreakBeforeBraces, 13234 FormatStyle::BS_Stroustrup); 13235 CHECK_PARSE("BreakBeforeBraces: Allman", BreakBeforeBraces, 13236 FormatStyle::BS_Allman); 13237 CHECK_PARSE("BreakBeforeBraces: Whitesmiths", BreakBeforeBraces, 13238 FormatStyle::BS_Whitesmiths); 13239 CHECK_PARSE("BreakBeforeBraces: GNU", BreakBeforeBraces, FormatStyle::BS_GNU); 13240 CHECK_PARSE("BreakBeforeBraces: WebKit", BreakBeforeBraces, 13241 FormatStyle::BS_WebKit); 13242 CHECK_PARSE("BreakBeforeBraces: Custom", BreakBeforeBraces, 13243 FormatStyle::BS_Custom); 13244 13245 Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Never; 13246 CHECK_PARSE("BraceWrapping:\n" 13247 " AfterControlStatement: MultiLine", 13248 BraceWrapping.AfterControlStatement, 13249 FormatStyle::BWACS_MultiLine); 13250 CHECK_PARSE("BraceWrapping:\n" 13251 " AfterControlStatement: Always", 13252 BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Always); 13253 CHECK_PARSE("BraceWrapping:\n" 13254 " AfterControlStatement: Never", 13255 BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Never); 13256 // For backward compatibility: 13257 CHECK_PARSE("BraceWrapping:\n" 13258 " AfterControlStatement: true", 13259 BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Always); 13260 CHECK_PARSE("BraceWrapping:\n" 13261 " AfterControlStatement: false", 13262 BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Never); 13263 13264 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All; 13265 CHECK_PARSE("AlwaysBreakAfterReturnType: None", AlwaysBreakAfterReturnType, 13266 FormatStyle::RTBS_None); 13267 CHECK_PARSE("AlwaysBreakAfterReturnType: All", AlwaysBreakAfterReturnType, 13268 FormatStyle::RTBS_All); 13269 CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevel", 13270 AlwaysBreakAfterReturnType, FormatStyle::RTBS_TopLevel); 13271 CHECK_PARSE("AlwaysBreakAfterReturnType: AllDefinitions", 13272 AlwaysBreakAfterReturnType, FormatStyle::RTBS_AllDefinitions); 13273 CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevelDefinitions", 13274 AlwaysBreakAfterReturnType, 13275 FormatStyle::RTBS_TopLevelDefinitions); 13276 13277 Style.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes; 13278 CHECK_PARSE("AlwaysBreakTemplateDeclarations: No", 13279 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_No); 13280 CHECK_PARSE("AlwaysBreakTemplateDeclarations: MultiLine", 13281 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_MultiLine); 13282 CHECK_PARSE("AlwaysBreakTemplateDeclarations: Yes", 13283 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_Yes); 13284 CHECK_PARSE("AlwaysBreakTemplateDeclarations: false", 13285 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_MultiLine); 13286 CHECK_PARSE("AlwaysBreakTemplateDeclarations: true", 13287 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_Yes); 13288 13289 Style.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_All; 13290 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: None", 13291 AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_None); 13292 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: All", 13293 AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_All); 13294 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: TopLevel", 13295 AlwaysBreakAfterDefinitionReturnType, 13296 FormatStyle::DRTBS_TopLevel); 13297 13298 Style.NamespaceIndentation = FormatStyle::NI_All; 13299 CHECK_PARSE("NamespaceIndentation: None", NamespaceIndentation, 13300 FormatStyle::NI_None); 13301 CHECK_PARSE("NamespaceIndentation: Inner", NamespaceIndentation, 13302 FormatStyle::NI_Inner); 13303 CHECK_PARSE("NamespaceIndentation: All", NamespaceIndentation, 13304 FormatStyle::NI_All); 13305 13306 Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Always; 13307 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Never", 13308 AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never); 13309 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: WithoutElse", 13310 AllowShortIfStatementsOnASingleLine, 13311 FormatStyle::SIS_WithoutElse); 13312 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Always", 13313 AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Always); 13314 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: false", 13315 AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never); 13316 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: true", 13317 AllowShortIfStatementsOnASingleLine, 13318 FormatStyle::SIS_WithoutElse); 13319 13320 // FIXME: This is required because parsing a configuration simply overwrites 13321 // the first N elements of the list instead of resetting it. 13322 Style.ForEachMacros.clear(); 13323 std::vector<std::string> BoostForeach; 13324 BoostForeach.push_back("BOOST_FOREACH"); 13325 CHECK_PARSE("ForEachMacros: [BOOST_FOREACH]", ForEachMacros, BoostForeach); 13326 std::vector<std::string> BoostAndQForeach; 13327 BoostAndQForeach.push_back("BOOST_FOREACH"); 13328 BoostAndQForeach.push_back("Q_FOREACH"); 13329 CHECK_PARSE("ForEachMacros: [BOOST_FOREACH, Q_FOREACH]", ForEachMacros, 13330 BoostAndQForeach); 13331 13332 Style.StatementMacros.clear(); 13333 CHECK_PARSE("StatementMacros: [QUNUSED]", StatementMacros, 13334 std::vector<std::string>{"QUNUSED"}); 13335 CHECK_PARSE("StatementMacros: [QUNUSED, QT_REQUIRE_VERSION]", StatementMacros, 13336 std::vector<std::string>({"QUNUSED", "QT_REQUIRE_VERSION"})); 13337 13338 Style.NamespaceMacros.clear(); 13339 CHECK_PARSE("NamespaceMacros: [TESTSUITE]", NamespaceMacros, 13340 std::vector<std::string>{"TESTSUITE"}); 13341 CHECK_PARSE("NamespaceMacros: [TESTSUITE, SUITE]", NamespaceMacros, 13342 std::vector<std::string>({"TESTSUITE", "SUITE"})); 13343 13344 Style.IncludeStyle.IncludeCategories.clear(); 13345 std::vector<tooling::IncludeStyle::IncludeCategory> ExpectedCategories = { 13346 {"abc/.*", 2, 0}, {".*", 1, 0}}; 13347 CHECK_PARSE("IncludeCategories:\n" 13348 " - Regex: abc/.*\n" 13349 " Priority: 2\n" 13350 " - Regex: .*\n" 13351 " Priority: 1", 13352 IncludeStyle.IncludeCategories, ExpectedCategories); 13353 CHECK_PARSE("IncludeIsMainRegex: 'abc$'", IncludeStyle.IncludeIsMainRegex, 13354 "abc$"); 13355 CHECK_PARSE("IncludeIsMainSourceRegex: 'abc$'", 13356 IncludeStyle.IncludeIsMainSourceRegex, "abc$"); 13357 13358 Style.RawStringFormats.clear(); 13359 std::vector<FormatStyle::RawStringFormat> ExpectedRawStringFormats = { 13360 { 13361 FormatStyle::LK_TextProto, 13362 {"pb", "proto"}, 13363 {"PARSE_TEXT_PROTO"}, 13364 /*CanonicalDelimiter=*/"", 13365 "llvm", 13366 }, 13367 { 13368 FormatStyle::LK_Cpp, 13369 {"cc", "cpp"}, 13370 {"C_CODEBLOCK", "CPPEVAL"}, 13371 /*CanonicalDelimiter=*/"cc", 13372 /*BasedOnStyle=*/"", 13373 }, 13374 }; 13375 13376 CHECK_PARSE("RawStringFormats:\n" 13377 " - Language: TextProto\n" 13378 " Delimiters:\n" 13379 " - 'pb'\n" 13380 " - 'proto'\n" 13381 " EnclosingFunctions:\n" 13382 " - 'PARSE_TEXT_PROTO'\n" 13383 " BasedOnStyle: llvm\n" 13384 " - Language: Cpp\n" 13385 " Delimiters:\n" 13386 " - 'cc'\n" 13387 " - 'cpp'\n" 13388 " EnclosingFunctions:\n" 13389 " - 'C_CODEBLOCK'\n" 13390 " - 'CPPEVAL'\n" 13391 " CanonicalDelimiter: 'cc'", 13392 RawStringFormats, ExpectedRawStringFormats); 13393 } 13394 13395 TEST_F(FormatTest, ParsesConfigurationWithLanguages) { 13396 FormatStyle Style = {}; 13397 Style.Language = FormatStyle::LK_Cpp; 13398 CHECK_PARSE("Language: Cpp\n" 13399 "IndentWidth: 12", 13400 IndentWidth, 12u); 13401 EXPECT_EQ(parseConfiguration("Language: JavaScript\n" 13402 "IndentWidth: 34", 13403 &Style), 13404 ParseError::Unsuitable); 13405 FormatStyle BinPackedTCS = {}; 13406 BinPackedTCS.Language = FormatStyle::LK_JavaScript; 13407 EXPECT_EQ(parseConfiguration("BinPackArguments: true\n" 13408 "InsertTrailingCommas: Wrapped", 13409 &BinPackedTCS), 13410 ParseError::BinPackTrailingCommaConflict); 13411 EXPECT_EQ(12u, Style.IndentWidth); 13412 CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u); 13413 EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language); 13414 13415 Style.Language = FormatStyle::LK_JavaScript; 13416 CHECK_PARSE("Language: JavaScript\n" 13417 "IndentWidth: 12", 13418 IndentWidth, 12u); 13419 CHECK_PARSE("IndentWidth: 23", IndentWidth, 23u); 13420 EXPECT_EQ(parseConfiguration("Language: Cpp\n" 13421 "IndentWidth: 34", 13422 &Style), 13423 ParseError::Unsuitable); 13424 EXPECT_EQ(23u, Style.IndentWidth); 13425 CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u); 13426 EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language); 13427 13428 CHECK_PARSE("BasedOnStyle: LLVM\n" 13429 "IndentWidth: 67", 13430 IndentWidth, 67u); 13431 13432 CHECK_PARSE("---\n" 13433 "Language: JavaScript\n" 13434 "IndentWidth: 12\n" 13435 "---\n" 13436 "Language: Cpp\n" 13437 "IndentWidth: 34\n" 13438 "...\n", 13439 IndentWidth, 12u); 13440 13441 Style.Language = FormatStyle::LK_Cpp; 13442 CHECK_PARSE("---\n" 13443 "Language: JavaScript\n" 13444 "IndentWidth: 12\n" 13445 "---\n" 13446 "Language: Cpp\n" 13447 "IndentWidth: 34\n" 13448 "...\n", 13449 IndentWidth, 34u); 13450 CHECK_PARSE("---\n" 13451 "IndentWidth: 78\n" 13452 "---\n" 13453 "Language: JavaScript\n" 13454 "IndentWidth: 56\n" 13455 "...\n", 13456 IndentWidth, 78u); 13457 13458 Style.ColumnLimit = 123; 13459 Style.IndentWidth = 234; 13460 Style.BreakBeforeBraces = FormatStyle::BS_Linux; 13461 Style.TabWidth = 345; 13462 EXPECT_FALSE(parseConfiguration("---\n" 13463 "IndentWidth: 456\n" 13464 "BreakBeforeBraces: Allman\n" 13465 "---\n" 13466 "Language: JavaScript\n" 13467 "IndentWidth: 111\n" 13468 "TabWidth: 111\n" 13469 "---\n" 13470 "Language: Cpp\n" 13471 "BreakBeforeBraces: Stroustrup\n" 13472 "TabWidth: 789\n" 13473 "...\n", 13474 &Style)); 13475 EXPECT_EQ(123u, Style.ColumnLimit); 13476 EXPECT_EQ(456u, Style.IndentWidth); 13477 EXPECT_EQ(FormatStyle::BS_Stroustrup, Style.BreakBeforeBraces); 13478 EXPECT_EQ(789u, Style.TabWidth); 13479 13480 EXPECT_EQ(parseConfiguration("---\n" 13481 "Language: JavaScript\n" 13482 "IndentWidth: 56\n" 13483 "---\n" 13484 "IndentWidth: 78\n" 13485 "...\n", 13486 &Style), 13487 ParseError::Error); 13488 EXPECT_EQ(parseConfiguration("---\n" 13489 "Language: JavaScript\n" 13490 "IndentWidth: 56\n" 13491 "---\n" 13492 "Language: JavaScript\n" 13493 "IndentWidth: 78\n" 13494 "...\n", 13495 &Style), 13496 ParseError::Error); 13497 13498 EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language); 13499 } 13500 13501 #undef CHECK_PARSE 13502 13503 TEST_F(FormatTest, UsesLanguageForBasedOnStyle) { 13504 FormatStyle Style = {}; 13505 Style.Language = FormatStyle::LK_JavaScript; 13506 Style.BreakBeforeTernaryOperators = true; 13507 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Style).value()); 13508 EXPECT_FALSE(Style.BreakBeforeTernaryOperators); 13509 13510 Style.BreakBeforeTernaryOperators = true; 13511 EXPECT_EQ(0, parseConfiguration("---\n" 13512 "BasedOnStyle: Google\n" 13513 "---\n" 13514 "Language: JavaScript\n" 13515 "IndentWidth: 76\n" 13516 "...\n", 13517 &Style) 13518 .value()); 13519 EXPECT_FALSE(Style.BreakBeforeTernaryOperators); 13520 EXPECT_EQ(76u, Style.IndentWidth); 13521 EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language); 13522 } 13523 13524 TEST_F(FormatTest, ConfigurationRoundTripTest) { 13525 FormatStyle Style = getLLVMStyle(); 13526 std::string YAML = configurationAsText(Style); 13527 FormatStyle ParsedStyle = {}; 13528 ParsedStyle.Language = FormatStyle::LK_Cpp; 13529 EXPECT_EQ(0, parseConfiguration(YAML, &ParsedStyle).value()); 13530 EXPECT_EQ(Style, ParsedStyle); 13531 } 13532 13533 TEST_F(FormatTest, WorksFor8bitEncodings) { 13534 EXPECT_EQ("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 \"\n" 13535 "\"\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \"\n" 13536 "\"\xe7\xe8\xec\xed\xfe\xfe \"\n" 13537 "\"\xef\xee\xf0\xf3...\"", 13538 format("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 " 13539 "\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \xe7\xe8\xec\xed\xfe\xfe " 13540 "\xef\xee\xf0\xf3...\"", 13541 getLLVMStyleWithColumns(12))); 13542 } 13543 13544 TEST_F(FormatTest, HandlesUTF8BOM) { 13545 EXPECT_EQ("\xef\xbb\xbf", format("\xef\xbb\xbf")); 13546 EXPECT_EQ("\xef\xbb\xbf#include <iostream>", 13547 format("\xef\xbb\xbf#include <iostream>")); 13548 EXPECT_EQ("\xef\xbb\xbf\n#include <iostream>", 13549 format("\xef\xbb\xbf\n#include <iostream>")); 13550 } 13551 13552 // FIXME: Encode Cyrillic and CJK characters below to appease MS compilers. 13553 #if !defined(_MSC_VER) 13554 13555 TEST_F(FormatTest, CountsUTF8CharactersProperly) { 13556 verifyFormat("\"Однажды в студёную зимнюю пору...\"", 13557 getLLVMStyleWithColumns(35)); 13558 verifyFormat("\"一 二 三 四 五 六 七 八 九 十\"", 13559 getLLVMStyleWithColumns(31)); 13560 verifyFormat("// Однажды в студёную зимнюю пору...", 13561 getLLVMStyleWithColumns(36)); 13562 verifyFormat("// 一 二 三 四 五 六 七 八 九 十", getLLVMStyleWithColumns(32)); 13563 verifyFormat("/* Однажды в студёную зимнюю пору... */", 13564 getLLVMStyleWithColumns(39)); 13565 verifyFormat("/* 一 二 三 四 五 六 七 八 九 十 */", 13566 getLLVMStyleWithColumns(35)); 13567 } 13568 13569 TEST_F(FormatTest, SplitsUTF8Strings) { 13570 // Non-printable characters' width is currently considered to be the length in 13571 // bytes in UTF8. The characters can be displayed in very different manner 13572 // (zero-width, single width with a substitution glyph, expanded to their code 13573 // (e.g. "<8d>"), so there's no single correct way to handle them. 13574 EXPECT_EQ("\"aaaaÄ\"\n" 13575 "\"\xc2\x8d\";", 13576 format("\"aaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10))); 13577 EXPECT_EQ("\"aaaaaaaÄ\"\n" 13578 "\"\xc2\x8d\";", 13579 format("\"aaaaaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10))); 13580 EXPECT_EQ("\"Однажды, в \"\n" 13581 "\"студёную \"\n" 13582 "\"зимнюю \"\n" 13583 "\"пору,\"", 13584 format("\"Однажды, в студёную зимнюю пору,\"", 13585 getLLVMStyleWithColumns(13))); 13586 EXPECT_EQ( 13587 "\"一 二 三 \"\n" 13588 "\"四 五六 \"\n" 13589 "\"七 八 九 \"\n" 13590 "\"十\"", 13591 format("\"一 二 三 四 五六 七 八 九 十\"", getLLVMStyleWithColumns(11))); 13592 EXPECT_EQ("\"一\t\"\n" 13593 "\"二 \t\"\n" 13594 "\"三 四 \"\n" 13595 "\"五\t\"\n" 13596 "\"六 \t\"\n" 13597 "\"七 \"\n" 13598 "\"八九十\tqq\"", 13599 format("\"一\t二 \t三 四 五\t六 \t七 八九十\tqq\"", 13600 getLLVMStyleWithColumns(11))); 13601 13602 // UTF8 character in an escape sequence. 13603 EXPECT_EQ("\"aaaaaa\"\n" 13604 "\"\\\xC2\x8D\"", 13605 format("\"aaaaaa\\\xC2\x8D\"", getLLVMStyleWithColumns(10))); 13606 } 13607 13608 TEST_F(FormatTest, HandlesDoubleWidthCharsInMultiLineStrings) { 13609 EXPECT_EQ("const char *sssss =\n" 13610 " \"一二三四五六七八\\\n" 13611 " 九 十\";", 13612 format("const char *sssss = \"一二三四五六七八\\\n" 13613 " 九 十\";", 13614 getLLVMStyleWithColumns(30))); 13615 } 13616 13617 TEST_F(FormatTest, SplitsUTF8LineComments) { 13618 EXPECT_EQ("// aaaaÄ\xc2\x8d", 13619 format("// aaaaÄ\xc2\x8d", getLLVMStyleWithColumns(10))); 13620 EXPECT_EQ("// Я из лесу\n" 13621 "// вышел; был\n" 13622 "// сильный\n" 13623 "// мороз.", 13624 format("// Я из лесу вышел; был сильный мороз.", 13625 getLLVMStyleWithColumns(13))); 13626 EXPECT_EQ("// 一二三\n" 13627 "// 四五六七\n" 13628 "// 八 九\n" 13629 "// 十", 13630 format("// 一二三 四五六七 八 九 十", getLLVMStyleWithColumns(9))); 13631 } 13632 13633 TEST_F(FormatTest, SplitsUTF8BlockComments) { 13634 EXPECT_EQ("/* Гляжу,\n" 13635 " * поднимается\n" 13636 " * медленно в\n" 13637 " * гору\n" 13638 " * Лошадка,\n" 13639 " * везущая\n" 13640 " * хворосту\n" 13641 " * воз. */", 13642 format("/* Гляжу, поднимается медленно в гору\n" 13643 " * Лошадка, везущая хворосту воз. */", 13644 getLLVMStyleWithColumns(13))); 13645 EXPECT_EQ( 13646 "/* 一二三\n" 13647 " * 四五六七\n" 13648 " * 八 九\n" 13649 " * 十 */", 13650 format("/* 一二三 四五六七 八 九 十 */", getLLVMStyleWithColumns(9))); 13651 EXPECT_EQ("/* �������� ��������\n" 13652 " * ��������\n" 13653 " * ������-�� */", 13654 format("/* �������� �������� �������� ������-�� */", getLLVMStyleWithColumns(12))); 13655 } 13656 13657 #endif // _MSC_VER 13658 13659 TEST_F(FormatTest, ConstructorInitializerIndentWidth) { 13660 FormatStyle Style = getLLVMStyle(); 13661 13662 Style.ConstructorInitializerIndentWidth = 4; 13663 verifyFormat( 13664 "SomeClass::Constructor()\n" 13665 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 13666 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 13667 Style); 13668 13669 Style.ConstructorInitializerIndentWidth = 2; 13670 verifyFormat( 13671 "SomeClass::Constructor()\n" 13672 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 13673 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 13674 Style); 13675 13676 Style.ConstructorInitializerIndentWidth = 0; 13677 verifyFormat( 13678 "SomeClass::Constructor()\n" 13679 ": aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 13680 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 13681 Style); 13682 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 13683 verifyFormat( 13684 "SomeLongTemplateVariableName<\n" 13685 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>", 13686 Style); 13687 verifyFormat("bool smaller = 1 < " 13688 "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 13689 " " 13690 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 13691 Style); 13692 13693 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 13694 verifyFormat("SomeClass::Constructor() :\n" 13695 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa),\n" 13696 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa) {}", 13697 Style); 13698 } 13699 13700 TEST_F(FormatTest, BreakConstructorInitializersBeforeComma) { 13701 FormatStyle Style = getLLVMStyle(); 13702 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 13703 Style.ConstructorInitializerIndentWidth = 4; 13704 verifyFormat("SomeClass::Constructor()\n" 13705 " : a(a)\n" 13706 " , b(b)\n" 13707 " , c(c) {}", 13708 Style); 13709 verifyFormat("SomeClass::Constructor()\n" 13710 " : a(a) {}", 13711 Style); 13712 13713 Style.ColumnLimit = 0; 13714 verifyFormat("SomeClass::Constructor()\n" 13715 " : a(a) {}", 13716 Style); 13717 verifyFormat("SomeClass::Constructor() noexcept\n" 13718 " : a(a) {}", 13719 Style); 13720 verifyFormat("SomeClass::Constructor()\n" 13721 " : a(a)\n" 13722 " , b(b)\n" 13723 " , c(c) {}", 13724 Style); 13725 verifyFormat("SomeClass::Constructor()\n" 13726 " : a(a) {\n" 13727 " foo();\n" 13728 " bar();\n" 13729 "}", 13730 Style); 13731 13732 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 13733 verifyFormat("SomeClass::Constructor()\n" 13734 " : a(a)\n" 13735 " , b(b)\n" 13736 " , c(c) {\n}", 13737 Style); 13738 verifyFormat("SomeClass::Constructor()\n" 13739 " : a(a) {\n}", 13740 Style); 13741 13742 Style.ColumnLimit = 80; 13743 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 13744 Style.ConstructorInitializerIndentWidth = 2; 13745 verifyFormat("SomeClass::Constructor()\n" 13746 " : a(a)\n" 13747 " , b(b)\n" 13748 " , c(c) {}", 13749 Style); 13750 13751 Style.ConstructorInitializerIndentWidth = 0; 13752 verifyFormat("SomeClass::Constructor()\n" 13753 ": a(a)\n" 13754 ", b(b)\n" 13755 ", c(c) {}", 13756 Style); 13757 13758 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 13759 Style.ConstructorInitializerIndentWidth = 4; 13760 verifyFormat("SomeClass::Constructor() : aaaaaaaa(aaaaaaaa) {}", Style); 13761 verifyFormat( 13762 "SomeClass::Constructor() : aaaaa(aaaaa), aaaaa(aaaaa), aaaaa(aaaaa)\n", 13763 Style); 13764 verifyFormat( 13765 "SomeClass::Constructor()\n" 13766 " : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa) {}", 13767 Style); 13768 Style.ConstructorInitializerIndentWidth = 4; 13769 Style.ColumnLimit = 60; 13770 verifyFormat("SomeClass::Constructor()\n" 13771 " : aaaaaaaa(aaaaaaaa)\n" 13772 " , aaaaaaaa(aaaaaaaa)\n" 13773 " , aaaaaaaa(aaaaaaaa) {}", 13774 Style); 13775 } 13776 13777 TEST_F(FormatTest, Destructors) { 13778 verifyFormat("void F(int &i) { i.~int(); }"); 13779 verifyFormat("void F(int &i) { i->~int(); }"); 13780 } 13781 13782 TEST_F(FormatTest, FormatsWithWebKitStyle) { 13783 FormatStyle Style = getWebKitStyle(); 13784 13785 // Don't indent in outer namespaces. 13786 verifyFormat("namespace outer {\n" 13787 "int i;\n" 13788 "namespace inner {\n" 13789 " int i;\n" 13790 "} // namespace inner\n" 13791 "} // namespace outer\n" 13792 "namespace other_outer {\n" 13793 "int i;\n" 13794 "}", 13795 Style); 13796 13797 // Don't indent case labels. 13798 verifyFormat("switch (variable) {\n" 13799 "case 1:\n" 13800 "case 2:\n" 13801 " doSomething();\n" 13802 " break;\n" 13803 "default:\n" 13804 " ++variable;\n" 13805 "}", 13806 Style); 13807 13808 // Wrap before binary operators. 13809 EXPECT_EQ("void f()\n" 13810 "{\n" 13811 " if (aaaaaaaaaaaaaaaa\n" 13812 " && bbbbbbbbbbbbbbbbbbbbbbbb\n" 13813 " && (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n" 13814 " return;\n" 13815 "}", 13816 format("void f() {\n" 13817 "if (aaaaaaaaaaaaaaaa\n" 13818 "&& bbbbbbbbbbbbbbbbbbbbbbbb\n" 13819 "&& (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n" 13820 "return;\n" 13821 "}", 13822 Style)); 13823 13824 // Allow functions on a single line. 13825 verifyFormat("void f() { return; }", Style); 13826 13827 // Allow empty blocks on a single line and insert a space in empty blocks. 13828 EXPECT_EQ("void f() { }", format("void f() {}", Style)); 13829 EXPECT_EQ("while (true) { }", format("while (true) {}", Style)); 13830 // However, don't merge non-empty short loops. 13831 EXPECT_EQ("while (true) {\n" 13832 " continue;\n" 13833 "}", 13834 format("while (true) { continue; }", Style)); 13835 13836 // Constructor initializers are formatted one per line with the "," on the 13837 // new line. 13838 verifyFormat("Constructor()\n" 13839 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 13840 " , aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaa, // break\n" 13841 " aaaaaaaaaaaaaa)\n" 13842 " , aaaaaaaaaaaaaaaaaaaaaaa()\n" 13843 "{\n" 13844 "}", 13845 Style); 13846 verifyFormat("SomeClass::Constructor()\n" 13847 " : a(a)\n" 13848 "{\n" 13849 "}", 13850 Style); 13851 EXPECT_EQ("SomeClass::Constructor()\n" 13852 " : a(a)\n" 13853 "{\n" 13854 "}", 13855 format("SomeClass::Constructor():a(a){}", Style)); 13856 verifyFormat("SomeClass::Constructor()\n" 13857 " : a(a)\n" 13858 " , b(b)\n" 13859 " , c(c)\n" 13860 "{\n" 13861 "}", 13862 Style); 13863 verifyFormat("SomeClass::Constructor()\n" 13864 " : a(a)\n" 13865 "{\n" 13866 " foo();\n" 13867 " bar();\n" 13868 "}", 13869 Style); 13870 13871 // Access specifiers should be aligned left. 13872 verifyFormat("class C {\n" 13873 "public:\n" 13874 " int i;\n" 13875 "};", 13876 Style); 13877 13878 // Do not align comments. 13879 verifyFormat("int a; // Do not\n" 13880 "double b; // align comments.", 13881 Style); 13882 13883 // Do not align operands. 13884 EXPECT_EQ("ASSERT(aaaa\n" 13885 " || bbbb);", 13886 format("ASSERT ( aaaa\n||bbbb);", Style)); 13887 13888 // Accept input's line breaks. 13889 EXPECT_EQ("if (aaaaaaaaaaaaaaa\n" 13890 " || bbbbbbbbbbbbbbb) {\n" 13891 " i++;\n" 13892 "}", 13893 format("if (aaaaaaaaaaaaaaa\n" 13894 "|| bbbbbbbbbbbbbbb) { i++; }", 13895 Style)); 13896 EXPECT_EQ("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) {\n" 13897 " i++;\n" 13898 "}", 13899 format("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) { i++; }", Style)); 13900 13901 // Don't automatically break all macro definitions (llvm.org/PR17842). 13902 verifyFormat("#define aNumber 10", Style); 13903 // However, generally keep the line breaks that the user authored. 13904 EXPECT_EQ("#define aNumber \\\n" 13905 " 10", 13906 format("#define aNumber \\\n" 13907 " 10", 13908 Style)); 13909 13910 // Keep empty and one-element array literals on a single line. 13911 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[]\n" 13912 " copyItems:YES];", 13913 format("NSArray*a=[[NSArray alloc] initWithArray:@[]\n" 13914 "copyItems:YES];", 13915 Style)); 13916 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\" ]\n" 13917 " copyItems:YES];", 13918 format("NSArray*a=[[NSArray alloc]initWithArray:@[ @\"a\" ]\n" 13919 " copyItems:YES];", 13920 Style)); 13921 // FIXME: This does not seem right, there should be more indentation before 13922 // the array literal's entries. Nested blocks have the same problem. 13923 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[\n" 13924 " @\"a\",\n" 13925 " @\"a\"\n" 13926 "]\n" 13927 " copyItems:YES];", 13928 format("NSArray* a = [[NSArray alloc] initWithArray:@[\n" 13929 " @\"a\",\n" 13930 " @\"a\"\n" 13931 " ]\n" 13932 " copyItems:YES];", 13933 Style)); 13934 EXPECT_EQ( 13935 "NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n" 13936 " copyItems:YES];", 13937 format("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n" 13938 " copyItems:YES];", 13939 Style)); 13940 13941 verifyFormat("[self.a b:c c:d];", Style); 13942 EXPECT_EQ("[self.a b:c\n" 13943 " c:d];", 13944 format("[self.a b:c\n" 13945 "c:d];", 13946 Style)); 13947 } 13948 13949 TEST_F(FormatTest, FormatsLambdas) { 13950 verifyFormat("int c = [b]() mutable { return [&b] { return b++; }(); }();\n"); 13951 verifyFormat( 13952 "int c = [b]() mutable noexcept { return [&b] { return b++; }(); }();\n"); 13953 verifyFormat("int c = [&] { [=] { return b++; }(); }();\n"); 13954 verifyFormat("int c = [&, &a, a] { [=, c, &d] { return b++; }(); }();\n"); 13955 verifyFormat("int c = [&a, &a, a] { [=, a, b, &c] { return b++; }(); }();\n"); 13956 verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] { return b++; }(); }}\n"); 13957 verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] {}(); }}\n"); 13958 verifyFormat("auto c = [a = [b = 42] {}] {};\n"); 13959 verifyFormat("auto c = [a = &i + 10, b = [] {}] {};\n"); 13960 verifyFormat("int x = f(*+[] {});"); 13961 verifyFormat("void f() {\n" 13962 " other(x.begin(), x.end(), [&](int, int) { return 1; });\n" 13963 "}\n"); 13964 verifyFormat("void f() {\n" 13965 " other(x.begin(), //\n" 13966 " x.end(), //\n" 13967 " [&](int, int) { return 1; });\n" 13968 "}\n"); 13969 verifyFormat("void f() {\n" 13970 " other.other.other.other.other(\n" 13971 " x.begin(), x.end(),\n" 13972 " [something, rather](int, int, int, int, int, int, int) { " 13973 "return 1; });\n" 13974 "}\n"); 13975 verifyFormat( 13976 "void f() {\n" 13977 " other.other.other.other.other(\n" 13978 " x.begin(), x.end(),\n" 13979 " [something, rather](int, int, int, int, int, int, int) {\n" 13980 " //\n" 13981 " });\n" 13982 "}\n"); 13983 verifyFormat("SomeFunction([]() { // A cool function...\n" 13984 " return 43;\n" 13985 "});"); 13986 EXPECT_EQ("SomeFunction([]() {\n" 13987 "#define A a\n" 13988 " return 43;\n" 13989 "});", 13990 format("SomeFunction([](){\n" 13991 "#define A a\n" 13992 "return 43;\n" 13993 "});")); 13994 verifyFormat("void f() {\n" 13995 " SomeFunction([](decltype(x), A *a) {});\n" 13996 "}"); 13997 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 13998 " [](const aaaaaaaaaa &a) { return a; });"); 13999 verifyFormat("string abc = SomeFunction(aaaaaaaaaaaaa, aaaaa, []() {\n" 14000 " SomeOtherFunctioooooooooooooooooooooooooon();\n" 14001 "});"); 14002 verifyFormat("Constructor()\n" 14003 " : Field([] { // comment\n" 14004 " int i;\n" 14005 " }) {}"); 14006 verifyFormat("auto my_lambda = [](const string &some_parameter) {\n" 14007 " return some_parameter.size();\n" 14008 "};"); 14009 verifyFormat("std::function<std::string(const std::string &)> my_lambda =\n" 14010 " [](const string &s) { return s; };"); 14011 verifyFormat("int i = aaaaaa ? 1 //\n" 14012 " : [] {\n" 14013 " return 2; //\n" 14014 " }();"); 14015 verifyFormat("llvm::errs() << \"number of twos is \"\n" 14016 " << std::count_if(v.begin(), v.end(), [](int x) {\n" 14017 " return x == 2; // force break\n" 14018 " });"); 14019 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 14020 " [=](int iiiiiiiiiiii) {\n" 14021 " return aaaaaaaaaaaaaaaaaaaaaaa !=\n" 14022 " aaaaaaaaaaaaaaaaaaaaaaa;\n" 14023 " });", 14024 getLLVMStyleWithColumns(60)); 14025 verifyFormat("SomeFunction({[&] {\n" 14026 " // comment\n" 14027 " },\n" 14028 " [&] {\n" 14029 " // comment\n" 14030 " }});"); 14031 verifyFormat("SomeFunction({[&] {\n" 14032 " // comment\n" 14033 "}});"); 14034 verifyFormat( 14035 "virtual aaaaaaaaaaaaaaaa(\n" 14036 " std::function<bool()> bbbbbbbbbbbb = [&]() { return true; },\n" 14037 " aaaaa aaaaaaaaa);"); 14038 14039 // Lambdas with return types. 14040 verifyFormat("int c = []() -> int { return 2; }();\n"); 14041 verifyFormat("int c = []() -> int * { return 2; }();\n"); 14042 verifyFormat("int c = []() -> vector<int> { return {2}; }();\n"); 14043 verifyFormat("Foo([]() -> std::vector<int> { return {2}; }());"); 14044 verifyGoogleFormat("auto a = [&b, c](D* d) -> D* {};"); 14045 verifyGoogleFormat("auto a = [&b, c](D* d) -> pair<D*, D*> {};"); 14046 verifyGoogleFormat("auto a = [&b, c](D* d) -> D& {};"); 14047 verifyGoogleFormat("auto a = [&b, c](D* d) -> const D* {};"); 14048 verifyFormat("[a, a]() -> a<1> {};"); 14049 verifyFormat("[]() -> foo<5 + 2> { return {}; };"); 14050 verifyFormat("[]() -> foo<5 - 2> { return {}; };"); 14051 verifyFormat("[]() -> foo<5 / 2> { return {}; };"); 14052 verifyFormat("[]() -> foo<5 * 2> { return {}; };"); 14053 verifyFormat("[]() -> foo<5 % 2> { return {}; };"); 14054 verifyFormat("[]() -> foo<5 << 2> { return {}; };"); 14055 verifyFormat("[]() -> foo<!5> { return {}; };"); 14056 verifyFormat("[]() -> foo<~5> { return {}; };"); 14057 verifyFormat("[]() -> foo<5 | 2> { return {}; };"); 14058 verifyFormat("[]() -> foo<5 || 2> { return {}; };"); 14059 verifyFormat("[]() -> foo<5 & 2> { return {}; };"); 14060 verifyFormat("[]() -> foo<5 && 2> { return {}; };"); 14061 verifyFormat("[]() -> foo<5 == 2> { return {}; };"); 14062 verifyFormat("[]() -> foo<5 != 2> { return {}; };"); 14063 verifyFormat("[]() -> foo<5 >= 2> { return {}; };"); 14064 verifyFormat("[]() -> foo<5 <= 2> { return {}; };"); 14065 verifyFormat("[]() -> foo<5 < 2> { return {}; };"); 14066 verifyFormat("[]() -> foo<2 ? 1 : 0> { return {}; };"); 14067 verifyFormat("namespace bar {\n" 14068 "// broken:\n" 14069 "auto foo{[]() -> foo<5 + 2> { return {}; }};\n" 14070 "} // namespace bar"); 14071 verifyFormat("namespace bar {\n" 14072 "// broken:\n" 14073 "auto foo{[]() -> foo<5 - 2> { return {}; }};\n" 14074 "} // namespace bar"); 14075 verifyFormat("namespace bar {\n" 14076 "// broken:\n" 14077 "auto foo{[]() -> foo<5 / 2> { return {}; }};\n" 14078 "} // namespace bar"); 14079 verifyFormat("namespace bar {\n" 14080 "// broken:\n" 14081 "auto foo{[]() -> foo<5 * 2> { return {}; }};\n" 14082 "} // namespace bar"); 14083 verifyFormat("namespace bar {\n" 14084 "// broken:\n" 14085 "auto foo{[]() -> foo<5 % 2> { return {}; }};\n" 14086 "} // namespace bar"); 14087 verifyFormat("namespace bar {\n" 14088 "// broken:\n" 14089 "auto foo{[]() -> foo<5 << 2> { return {}; }};\n" 14090 "} // namespace bar"); 14091 verifyFormat("namespace bar {\n" 14092 "// broken:\n" 14093 "auto foo{[]() -> foo<!5> { return {}; }};\n" 14094 "} // namespace bar"); 14095 verifyFormat("namespace bar {\n" 14096 "// broken:\n" 14097 "auto foo{[]() -> foo<~5> { return {}; }};\n" 14098 "} // namespace bar"); 14099 verifyFormat("namespace bar {\n" 14100 "// broken:\n" 14101 "auto foo{[]() -> foo<5 | 2> { return {}; }};\n" 14102 "} // namespace bar"); 14103 verifyFormat("namespace bar {\n" 14104 "// broken:\n" 14105 "auto foo{[]() -> foo<5 || 2> { return {}; }};\n" 14106 "} // namespace bar"); 14107 verifyFormat("namespace bar {\n" 14108 "// broken:\n" 14109 "auto foo{[]() -> foo<5 & 2> { return {}; }};\n" 14110 "} // namespace bar"); 14111 verifyFormat("namespace bar {\n" 14112 "// broken:\n" 14113 "auto foo{[]() -> foo<5 && 2> { return {}; }};\n" 14114 "} // namespace bar"); 14115 verifyFormat("namespace bar {\n" 14116 "// broken:\n" 14117 "auto foo{[]() -> foo<5 == 2> { return {}; }};\n" 14118 "} // namespace bar"); 14119 verifyFormat("namespace bar {\n" 14120 "// broken:\n" 14121 "auto foo{[]() -> foo<5 != 2> { return {}; }};\n" 14122 "} // namespace bar"); 14123 verifyFormat("namespace bar {\n" 14124 "// broken:\n" 14125 "auto foo{[]() -> foo<5 >= 2> { return {}; }};\n" 14126 "} // namespace bar"); 14127 verifyFormat("namespace bar {\n" 14128 "// broken:\n" 14129 "auto foo{[]() -> foo<5 <= 2> { return {}; }};\n" 14130 "} // namespace bar"); 14131 verifyFormat("namespace bar {\n" 14132 "// broken:\n" 14133 "auto foo{[]() -> foo<5 < 2> { return {}; }};\n" 14134 "} // namespace bar"); 14135 verifyFormat("namespace bar {\n" 14136 "// broken:\n" 14137 "auto foo{[]() -> foo<2 ? 1 : 0> { return {}; }};\n" 14138 "} // namespace bar"); 14139 verifyFormat("[]() -> a<1> {};"); 14140 verifyFormat("[]() -> a<1> { ; };"); 14141 verifyFormat("[]() -> a<1> { ; }();"); 14142 verifyFormat("[a, a]() -> a<true> {};"); 14143 verifyFormat("[]() -> a<true> {};"); 14144 verifyFormat("[]() -> a<true> { ; };"); 14145 verifyFormat("[]() -> a<true> { ; }();"); 14146 verifyFormat("[a, a]() -> a<false> {};"); 14147 verifyFormat("[]() -> a<false> {};"); 14148 verifyFormat("[]() -> a<false> { ; };"); 14149 verifyFormat("[]() -> a<false> { ; }();"); 14150 verifyFormat("auto foo{[]() -> foo<false> { ; }};"); 14151 verifyFormat("namespace bar {\n" 14152 "auto foo{[]() -> foo<false> { ; }};\n" 14153 "} // namespace bar"); 14154 verifyFormat("auto aaaaaaaa = [](int i, // break for some reason\n" 14155 " int j) -> int {\n" 14156 " return ffffffffffffffffffffffffffffffffffffffffffff(i * j);\n" 14157 "};"); 14158 verifyFormat( 14159 "aaaaaaaaaaaaaaaaaaaaaa(\n" 14160 " [](aaaaaaaaaaaaaaaaaaaaaaaaaaa &aaa) -> aaaaaaaaaaaaaaaa {\n" 14161 " return aaaaaaaaaaaaaaaaa;\n" 14162 " });", 14163 getLLVMStyleWithColumns(70)); 14164 verifyFormat("[]() //\n" 14165 " -> int {\n" 14166 " return 1; //\n" 14167 "};"); 14168 verifyFormat("[]() -> Void<T...> {};"); 14169 verifyFormat("[a, b]() -> Tuple<T...> { return {}; };"); 14170 14171 // Lambdas with explicit template argument lists. 14172 verifyFormat( 14173 "auto L = []<template <typename> class T, class U>(T<U> &&a) {};\n"); 14174 14175 // Multiple lambdas in the same parentheses change indentation rules. These 14176 // lambdas are forced to start on new lines. 14177 verifyFormat("SomeFunction(\n" 14178 " []() {\n" 14179 " //\n" 14180 " },\n" 14181 " []() {\n" 14182 " //\n" 14183 " });"); 14184 14185 // A lambda passed as arg0 is always pushed to the next line. 14186 verifyFormat("SomeFunction(\n" 14187 " [this] {\n" 14188 " //\n" 14189 " },\n" 14190 " 1);\n"); 14191 14192 // A multi-line lambda passed as arg1 forces arg0 to be pushed out, just like 14193 // the arg0 case above. 14194 auto Style = getGoogleStyle(); 14195 Style.BinPackArguments = false; 14196 verifyFormat("SomeFunction(\n" 14197 " a,\n" 14198 " [this] {\n" 14199 " //\n" 14200 " },\n" 14201 " b);\n", 14202 Style); 14203 verifyFormat("SomeFunction(\n" 14204 " a,\n" 14205 " [this] {\n" 14206 " //\n" 14207 " },\n" 14208 " b);\n"); 14209 14210 // A lambda with a very long line forces arg0 to be pushed out irrespective of 14211 // the BinPackArguments value (as long as the code is wide enough). 14212 verifyFormat( 14213 "something->SomeFunction(\n" 14214 " a,\n" 14215 " [this] {\n" 14216 " " 14217 "D0000000000000000000000000000000000000000000000000000000000001();\n" 14218 " },\n" 14219 " b);\n"); 14220 14221 // A multi-line lambda is pulled up as long as the introducer fits on the 14222 // previous line and there are no further args. 14223 verifyFormat("function(1, [this, that] {\n" 14224 " //\n" 14225 "});\n"); 14226 verifyFormat("function([this, that] {\n" 14227 " //\n" 14228 "});\n"); 14229 // FIXME: this format is not ideal and we should consider forcing the first 14230 // arg onto its own line. 14231 verifyFormat("function(a, b, c, //\n" 14232 " d, [this, that] {\n" 14233 " //\n" 14234 " });\n"); 14235 14236 // Multiple lambdas are treated correctly even when there is a short arg0. 14237 verifyFormat("SomeFunction(\n" 14238 " 1,\n" 14239 " [this] {\n" 14240 " //\n" 14241 " },\n" 14242 " [this] {\n" 14243 " //\n" 14244 " },\n" 14245 " 1);\n"); 14246 14247 // More complex introducers. 14248 verifyFormat("return [i, args...] {};"); 14249 14250 // Not lambdas. 14251 verifyFormat("constexpr char hello[]{\"hello\"};"); 14252 verifyFormat("double &operator[](int i) { return 0; }\n" 14253 "int i;"); 14254 verifyFormat("std::unique_ptr<int[]> foo() {}"); 14255 verifyFormat("int i = a[a][a]->f();"); 14256 verifyFormat("int i = (*b)[a]->f();"); 14257 14258 // Other corner cases. 14259 verifyFormat("void f() {\n" 14260 " bar([]() {} // Did not respect SpacesBeforeTrailingComments\n" 14261 " );\n" 14262 "}"); 14263 14264 // Lambdas created through weird macros. 14265 verifyFormat("void f() {\n" 14266 " MACRO((const AA &a) { return 1; });\n" 14267 " MACRO((AA &a) { return 1; });\n" 14268 "}"); 14269 14270 verifyFormat("if (blah_blah(whatever, whatever, [] {\n" 14271 " doo_dah();\n" 14272 " doo_dah();\n" 14273 " })) {\n" 14274 "}"); 14275 verifyFormat("if constexpr (blah_blah(whatever, whatever, [] {\n" 14276 " doo_dah();\n" 14277 " doo_dah();\n" 14278 " })) {\n" 14279 "}"); 14280 verifyFormat("if CONSTEXPR (blah_blah(whatever, whatever, [] {\n" 14281 " doo_dah();\n" 14282 " doo_dah();\n" 14283 " })) {\n" 14284 "}"); 14285 verifyFormat("auto lambda = []() {\n" 14286 " int a = 2\n" 14287 "#if A\n" 14288 " + 2\n" 14289 "#endif\n" 14290 " ;\n" 14291 "};"); 14292 14293 // Lambdas with complex multiline introducers. 14294 verifyFormat( 14295 "aaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 14296 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]()\n" 14297 " -> ::std::unordered_set<\n" 14298 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> {\n" 14299 " //\n" 14300 " });"); 14301 14302 FormatStyle DoNotMerge = getLLVMStyle(); 14303 DoNotMerge.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None; 14304 verifyFormat("auto c = []() {\n" 14305 " return b;\n" 14306 "};", 14307 "auto c = []() { return b; };", DoNotMerge); 14308 verifyFormat("auto c = []() {\n" 14309 "};", 14310 " auto c = []() {};", DoNotMerge); 14311 14312 FormatStyle MergeEmptyOnly = getLLVMStyle(); 14313 MergeEmptyOnly.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Empty; 14314 verifyFormat("auto c = []() {\n" 14315 " return b;\n" 14316 "};", 14317 "auto c = []() {\n" 14318 " return b;\n" 14319 " };", 14320 MergeEmptyOnly); 14321 verifyFormat("auto c = []() {};", 14322 "auto c = []() {\n" 14323 "};", 14324 MergeEmptyOnly); 14325 14326 FormatStyle MergeInline = getLLVMStyle(); 14327 MergeInline.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Inline; 14328 verifyFormat("auto c = []() {\n" 14329 " return b;\n" 14330 "};", 14331 "auto c = []() { return b; };", MergeInline); 14332 verifyFormat("function([]() { return b; })", "function([]() { return b; })", 14333 MergeInline); 14334 verifyFormat("function([]() { return b; }, a)", 14335 "function([]() { return b; }, a)", MergeInline); 14336 verifyFormat("function(a, []() { return b; })", 14337 "function(a, []() { return b; })", MergeInline); 14338 14339 // Check option "BraceWrapping.BeforeLambdaBody" and different state of 14340 // AllowShortLambdasOnASingleLine 14341 FormatStyle LLVMWithBeforeLambdaBody = getLLVMStyle(); 14342 LLVMWithBeforeLambdaBody.BreakBeforeBraces = FormatStyle::BS_Custom; 14343 LLVMWithBeforeLambdaBody.BraceWrapping.BeforeLambdaBody = true; 14344 LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine = 14345 FormatStyle::ShortLambdaStyle::SLS_None; 14346 verifyFormat("FctWithOneNestedLambdaInline_SLS_None(\n" 14347 " []()\n" 14348 " {\n" 14349 " return 17;\n" 14350 " });", 14351 LLVMWithBeforeLambdaBody); 14352 verifyFormat("FctWithOneNestedLambdaEmpty_SLS_None(\n" 14353 " []()\n" 14354 " {\n" 14355 " });", 14356 LLVMWithBeforeLambdaBody); 14357 verifyFormat("auto fct_SLS_None = []()\n" 14358 "{\n" 14359 " return 17;\n" 14360 "};", 14361 LLVMWithBeforeLambdaBody); 14362 verifyFormat("TwoNestedLambdas_SLS_None(\n" 14363 " []()\n" 14364 " {\n" 14365 " return Call(\n" 14366 " []()\n" 14367 " {\n" 14368 " return 17;\n" 14369 " });\n" 14370 " });", 14371 LLVMWithBeforeLambdaBody); 14372 verifyFormat("void Fct()\n" 14373 "{\n" 14374 " return {[]()\n" 14375 " {\n" 14376 " return 17;\n" 14377 " }};\n" 14378 "}", 14379 LLVMWithBeforeLambdaBody); 14380 14381 LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine = 14382 FormatStyle::ShortLambdaStyle::SLS_Empty; 14383 verifyFormat("FctWithOneNestedLambdaInline_SLS_Empty(\n" 14384 " []()\n" 14385 " {\n" 14386 " return 17;\n" 14387 " });", 14388 LLVMWithBeforeLambdaBody); 14389 verifyFormat("FctWithOneNestedLambdaEmpty_SLS_Empty([]() {});", 14390 LLVMWithBeforeLambdaBody); 14391 verifyFormat("FctWithOneNestedLambdaEmptyInsideAVeryVeryVeryVeryVeryVeryVeryL" 14392 "ongFunctionName_SLS_Empty(\n" 14393 " []() {});", 14394 LLVMWithBeforeLambdaBody); 14395 verifyFormat("FctWithMultipleParams_SLS_Empty(A, B,\n" 14396 " []()\n" 14397 " {\n" 14398 " return 17;\n" 14399 " });", 14400 LLVMWithBeforeLambdaBody); 14401 verifyFormat("auto fct_SLS_Empty = []()\n" 14402 "{\n" 14403 " return 17;\n" 14404 "};", 14405 LLVMWithBeforeLambdaBody); 14406 verifyFormat("TwoNestedLambdas_SLS_Empty(\n" 14407 " []()\n" 14408 " {\n" 14409 " return Call([]() {});\n" 14410 " });", 14411 LLVMWithBeforeLambdaBody); 14412 verifyFormat("TwoNestedLambdas_SLS_Empty(A,\n" 14413 " []()\n" 14414 " {\n" 14415 " return Call([]() {});\n" 14416 " });", 14417 LLVMWithBeforeLambdaBody); 14418 verifyFormat( 14419 "FctWithLongLineInLambda_SLS_Empty(\n" 14420 " []()\n" 14421 " {\n" 14422 " return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n" 14423 " AndShouldNotBeConsiderAsInline,\n" 14424 " LambdaBodyMustBeBreak);\n" 14425 " });", 14426 LLVMWithBeforeLambdaBody); 14427 14428 LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine = 14429 FormatStyle::ShortLambdaStyle::SLS_Inline; 14430 verifyFormat("FctWithOneNestedLambdaInline_SLS_Inline([]() { return 17; });", 14431 LLVMWithBeforeLambdaBody); 14432 verifyFormat("FctWithOneNestedLambdaEmpty_SLS_Inline([]() {});", 14433 LLVMWithBeforeLambdaBody); 14434 verifyFormat("auto fct_SLS_Inline = []()\n" 14435 "{\n" 14436 " return 17;\n" 14437 "};", 14438 LLVMWithBeforeLambdaBody); 14439 verifyFormat("TwoNestedLambdas_SLS_Inline([]() { return Call([]() { return " 14440 "17; }); });", 14441 LLVMWithBeforeLambdaBody); 14442 verifyFormat( 14443 "FctWithLongLineInLambda_SLS_Inline(\n" 14444 " []()\n" 14445 " {\n" 14446 " return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n" 14447 " AndShouldNotBeConsiderAsInline,\n" 14448 " LambdaBodyMustBeBreak);\n" 14449 " });", 14450 LLVMWithBeforeLambdaBody); 14451 verifyFormat("FctWithMultipleParams_SLS_Inline(" 14452 "VeryLongParameterThatShouldAskToBeOnMultiLine,\n" 14453 " []() { return 17; });", 14454 LLVMWithBeforeLambdaBody); 14455 verifyFormat( 14456 "FctWithMultipleParams_SLS_Inline(FirstParam, []() { return 17; });", 14457 LLVMWithBeforeLambdaBody); 14458 14459 LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine = 14460 FormatStyle::ShortLambdaStyle::SLS_All; 14461 verifyFormat("FctWithOneNestedLambdaInline_SLS_All([]() { return 17; });", 14462 LLVMWithBeforeLambdaBody); 14463 verifyFormat("FctWithOneNestedLambdaEmpty_SLS_All([]() {});", 14464 LLVMWithBeforeLambdaBody); 14465 verifyFormat("auto fct_SLS_All = []() { return 17; };", 14466 LLVMWithBeforeLambdaBody); 14467 verifyFormat("FctWithOneParam_SLS_All(\n" 14468 " []()\n" 14469 " {\n" 14470 " // A cool function...\n" 14471 " return 43;\n" 14472 " });", 14473 LLVMWithBeforeLambdaBody); 14474 verifyFormat("FctWithMultipleParams_SLS_All(" 14475 "VeryLongParameterThatShouldAskToBeOnMultiLine,\n" 14476 " []() { return 17; });", 14477 LLVMWithBeforeLambdaBody); 14478 verifyFormat("FctWithMultipleParams_SLS_All(A, []() { return 17; });", 14479 LLVMWithBeforeLambdaBody); 14480 verifyFormat("FctWithMultipleParams_SLS_All(A, B, []() { return 17; });", 14481 LLVMWithBeforeLambdaBody); 14482 verifyFormat( 14483 "FctWithLongLineInLambda_SLS_All(\n" 14484 " []()\n" 14485 " {\n" 14486 " return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n" 14487 " AndShouldNotBeConsiderAsInline,\n" 14488 " LambdaBodyMustBeBreak);\n" 14489 " });", 14490 LLVMWithBeforeLambdaBody); 14491 verifyFormat( 14492 "auto fct_SLS_All = []()\n" 14493 "{\n" 14494 " return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n" 14495 " AndShouldNotBeConsiderAsInline,\n" 14496 " LambdaBodyMustBeBreak);\n" 14497 "};", 14498 LLVMWithBeforeLambdaBody); 14499 LLVMWithBeforeLambdaBody.BinPackParameters = false; 14500 verifyFormat("FctAllOnSameLine_SLS_All([]() { return S; }, Fst, Second);", 14501 LLVMWithBeforeLambdaBody); 14502 verifyFormat( 14503 "FctWithLongLineInLambda_SLS_All([]() { return SomeValueNotSoLong; },\n" 14504 " FirstParam,\n" 14505 " SecondParam,\n" 14506 " ThirdParam,\n" 14507 " FourthParam);", 14508 LLVMWithBeforeLambdaBody); 14509 verifyFormat("FctWithLongLineInLambda_SLS_All(\n" 14510 " []() { return " 14511 "SomeValueVeryVeryVeryVeryVeryVeryVeryVeryVeryLong; },\n" 14512 " FirstParam,\n" 14513 " SecondParam,\n" 14514 " ThirdParam,\n" 14515 " FourthParam);", 14516 LLVMWithBeforeLambdaBody); 14517 verifyFormat( 14518 "FctWithLongLineInLambda_SLS_All(FirstParam,\n" 14519 " SecondParam,\n" 14520 " ThirdParam,\n" 14521 " FourthParam,\n" 14522 " []() { return SomeValueNotSoLong; });", 14523 LLVMWithBeforeLambdaBody); 14524 verifyFormat("FctWithLongLineInLambda_SLS_All(\n" 14525 " []()\n" 14526 " {\n" 14527 " return " 14528 "HereAVeryLongLineThatWillBeFormattedOnMultipleLineAndShouldNotB" 14529 "eConsiderAsInline;\n" 14530 " });", 14531 LLVMWithBeforeLambdaBody); 14532 verifyFormat( 14533 "FctWithLongLineInLambda_SLS_All(\n" 14534 " []()\n" 14535 " {\n" 14536 " return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n" 14537 " AndShouldNotBeConsiderAsInline,\n" 14538 " LambdaBodyMustBeBreak);\n" 14539 " });", 14540 LLVMWithBeforeLambdaBody); 14541 verifyFormat("FctWithTwoParams_SLS_All(\n" 14542 " []()\n" 14543 " {\n" 14544 " // A cool function...\n" 14545 " return 43;\n" 14546 " },\n" 14547 " 87);", 14548 LLVMWithBeforeLambdaBody); 14549 verifyFormat("FctWithTwoParams_SLS_All([]() { return 43; }, 87);", 14550 LLVMWithBeforeLambdaBody); 14551 verifyFormat("FctWithOneNestedLambdas_SLS_All([]() { return 17; });", 14552 LLVMWithBeforeLambdaBody); 14553 verifyFormat( 14554 "TwoNestedLambdas_SLS_All([]() { return Call([]() { return 17; }); });", 14555 LLVMWithBeforeLambdaBody); 14556 verifyFormat("TwoNestedLambdas_SLS_All([]() { return Call([]() { return 17; " 14557 "}); }, x);", 14558 LLVMWithBeforeLambdaBody); 14559 verifyFormat("TwoNestedLambdas_SLS_All(\n" 14560 " []()\n" 14561 " {\n" 14562 " // A cool function...\n" 14563 " return Call([]() { return 17; });\n" 14564 " });", 14565 LLVMWithBeforeLambdaBody); 14566 verifyFormat("TwoNestedLambdas_SLS_All(\n" 14567 " []()\n" 14568 " {\n" 14569 " return Call(\n" 14570 " []()\n" 14571 " {\n" 14572 " // A cool function...\n" 14573 " return 17;\n" 14574 " });\n" 14575 " });", 14576 LLVMWithBeforeLambdaBody); 14577 } 14578 14579 TEST_F(FormatTest, EmptyLinesInLambdas) { 14580 verifyFormat("auto lambda = []() {\n" 14581 " x(); //\n" 14582 "};", 14583 "auto lambda = []() {\n" 14584 "\n" 14585 " x(); //\n" 14586 "\n" 14587 "};"); 14588 } 14589 14590 TEST_F(FormatTest, FormatsBlocks) { 14591 FormatStyle ShortBlocks = getLLVMStyle(); 14592 ShortBlocks.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always; 14593 verifyFormat("int (^Block)(int, int);", ShortBlocks); 14594 verifyFormat("int (^Block1)(int, int) = ^(int i, int j)", ShortBlocks); 14595 verifyFormat("void (^block)(int) = ^(id test) { int i; };", ShortBlocks); 14596 verifyFormat("void (^block)(int) = ^(int test) { int i; };", ShortBlocks); 14597 verifyFormat("void (^block)(int) = ^id(int test) { int i; };", ShortBlocks); 14598 verifyFormat("void (^block)(int) = ^int(int test) { int i; };", ShortBlocks); 14599 14600 verifyFormat("foo(^{ bar(); });", ShortBlocks); 14601 verifyFormat("foo(a, ^{ bar(); });", ShortBlocks); 14602 verifyFormat("{ void (^block)(Object *x); }", ShortBlocks); 14603 14604 verifyFormat("[operation setCompletionBlock:^{\n" 14605 " [self onOperationDone];\n" 14606 "}];"); 14607 verifyFormat("int i = {[operation setCompletionBlock:^{\n" 14608 " [self onOperationDone];\n" 14609 "}]};"); 14610 verifyFormat("[operation setCompletionBlock:^(int *i) {\n" 14611 " f();\n" 14612 "}];"); 14613 verifyFormat("int a = [operation block:^int(int *i) {\n" 14614 " return 1;\n" 14615 "}];"); 14616 verifyFormat("[myObject doSomethingWith:arg1\n" 14617 " aaa:^int(int *a) {\n" 14618 " return 1;\n" 14619 " }\n" 14620 " bbb:f(a * bbbbbbbb)];"); 14621 14622 verifyFormat("[operation setCompletionBlock:^{\n" 14623 " [self.delegate newDataAvailable];\n" 14624 "}];", 14625 getLLVMStyleWithColumns(60)); 14626 verifyFormat("dispatch_async(_fileIOQueue, ^{\n" 14627 " NSString *path = [self sessionFilePath];\n" 14628 " if (path) {\n" 14629 " // ...\n" 14630 " }\n" 14631 "});"); 14632 verifyFormat("[[SessionService sharedService]\n" 14633 " loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 14634 " if (window) {\n" 14635 " [self windowDidLoad:window];\n" 14636 " } else {\n" 14637 " [self errorLoadingWindow];\n" 14638 " }\n" 14639 " }];"); 14640 verifyFormat("void (^largeBlock)(void) = ^{\n" 14641 " // ...\n" 14642 "};\n", 14643 getLLVMStyleWithColumns(40)); 14644 verifyFormat("[[SessionService sharedService]\n" 14645 " loadWindowWithCompletionBlock: //\n" 14646 " ^(SessionWindow *window) {\n" 14647 " if (window) {\n" 14648 " [self windowDidLoad:window];\n" 14649 " } else {\n" 14650 " [self errorLoadingWindow];\n" 14651 " }\n" 14652 " }];", 14653 getLLVMStyleWithColumns(60)); 14654 verifyFormat("[myObject doSomethingWith:arg1\n" 14655 " firstBlock:^(Foo *a) {\n" 14656 " // ...\n" 14657 " int i;\n" 14658 " }\n" 14659 " secondBlock:^(Bar *b) {\n" 14660 " // ...\n" 14661 " int i;\n" 14662 " }\n" 14663 " thirdBlock:^Foo(Bar *b) {\n" 14664 " // ...\n" 14665 " int i;\n" 14666 " }];"); 14667 verifyFormat("[myObject doSomethingWith:arg1\n" 14668 " firstBlock:-1\n" 14669 " secondBlock:^(Bar *b) {\n" 14670 " // ...\n" 14671 " int i;\n" 14672 " }];"); 14673 14674 verifyFormat("f(^{\n" 14675 " @autoreleasepool {\n" 14676 " if (a) {\n" 14677 " g();\n" 14678 " }\n" 14679 " }\n" 14680 "});"); 14681 verifyFormat("Block b = ^int *(A *a, B *b) {}"); 14682 verifyFormat("BOOL (^aaa)(void) = ^BOOL {\n" 14683 "};"); 14684 14685 FormatStyle FourIndent = getLLVMStyle(); 14686 FourIndent.ObjCBlockIndentWidth = 4; 14687 verifyFormat("[operation setCompletionBlock:^{\n" 14688 " [self onOperationDone];\n" 14689 "}];", 14690 FourIndent); 14691 } 14692 14693 TEST_F(FormatTest, FormatsBlocksWithZeroColumnWidth) { 14694 FormatStyle ZeroColumn = getLLVMStyle(); 14695 ZeroColumn.ColumnLimit = 0; 14696 14697 verifyFormat("[[SessionService sharedService] " 14698 "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 14699 " if (window) {\n" 14700 " [self windowDidLoad:window];\n" 14701 " } else {\n" 14702 " [self errorLoadingWindow];\n" 14703 " }\n" 14704 "}];", 14705 ZeroColumn); 14706 EXPECT_EQ("[[SessionService sharedService]\n" 14707 " loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 14708 " if (window) {\n" 14709 " [self windowDidLoad:window];\n" 14710 " } else {\n" 14711 " [self errorLoadingWindow];\n" 14712 " }\n" 14713 " }];", 14714 format("[[SessionService sharedService]\n" 14715 "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 14716 " if (window) {\n" 14717 " [self windowDidLoad:window];\n" 14718 " } else {\n" 14719 " [self errorLoadingWindow];\n" 14720 " }\n" 14721 "}];", 14722 ZeroColumn)); 14723 verifyFormat("[myObject doSomethingWith:arg1\n" 14724 " firstBlock:^(Foo *a) {\n" 14725 " // ...\n" 14726 " int i;\n" 14727 " }\n" 14728 " secondBlock:^(Bar *b) {\n" 14729 " // ...\n" 14730 " int i;\n" 14731 " }\n" 14732 " thirdBlock:^Foo(Bar *b) {\n" 14733 " // ...\n" 14734 " int i;\n" 14735 " }];", 14736 ZeroColumn); 14737 verifyFormat("f(^{\n" 14738 " @autoreleasepool {\n" 14739 " if (a) {\n" 14740 " g();\n" 14741 " }\n" 14742 " }\n" 14743 "});", 14744 ZeroColumn); 14745 verifyFormat("void (^largeBlock)(void) = ^{\n" 14746 " // ...\n" 14747 "};", 14748 ZeroColumn); 14749 14750 ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always; 14751 EXPECT_EQ("void (^largeBlock)(void) = ^{ int i; };", 14752 format("void (^largeBlock)(void) = ^{ int i; };", ZeroColumn)); 14753 ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Never; 14754 EXPECT_EQ("void (^largeBlock)(void) = ^{\n" 14755 " int i;\n" 14756 "};", 14757 format("void (^largeBlock)(void) = ^{ int i; };", ZeroColumn)); 14758 } 14759 14760 TEST_F(FormatTest, SupportsCRLF) { 14761 EXPECT_EQ("int a;\r\n" 14762 "int b;\r\n" 14763 "int c;\r\n", 14764 format("int a;\r\n" 14765 " int b;\r\n" 14766 " int c;\r\n", 14767 getLLVMStyle())); 14768 EXPECT_EQ("int a;\r\n" 14769 "int b;\r\n" 14770 "int c;\r\n", 14771 format("int a;\r\n" 14772 " int b;\n" 14773 " int c;\r\n", 14774 getLLVMStyle())); 14775 EXPECT_EQ("int a;\n" 14776 "int b;\n" 14777 "int c;\n", 14778 format("int a;\r\n" 14779 " int b;\n" 14780 " int c;\n", 14781 getLLVMStyle())); 14782 EXPECT_EQ("\"aaaaaaa \"\r\n" 14783 "\"bbbbbbb\";\r\n", 14784 format("\"aaaaaaa bbbbbbb\";\r\n", getLLVMStyleWithColumns(10))); 14785 EXPECT_EQ("#define A \\\r\n" 14786 " b; \\\r\n" 14787 " c; \\\r\n" 14788 " d;\r\n", 14789 format("#define A \\\r\n" 14790 " b; \\\r\n" 14791 " c; d; \r\n", 14792 getGoogleStyle())); 14793 14794 EXPECT_EQ("/*\r\n" 14795 "multi line block comments\r\n" 14796 "should not introduce\r\n" 14797 "an extra carriage return\r\n" 14798 "*/\r\n", 14799 format("/*\r\n" 14800 "multi line block comments\r\n" 14801 "should not introduce\r\n" 14802 "an extra carriage return\r\n" 14803 "*/\r\n")); 14804 EXPECT_EQ("/*\r\n" 14805 "\r\n" 14806 "*/", 14807 format("/*\r\n" 14808 " \r\r\r\n" 14809 "*/")); 14810 14811 FormatStyle style = getLLVMStyle(); 14812 14813 style.DeriveLineEnding = true; 14814 style.UseCRLF = false; 14815 EXPECT_EQ("union FooBarBazQux {\n" 14816 " int foo;\n" 14817 " int bar;\n" 14818 " int baz;\n" 14819 "};", 14820 format("union FooBarBazQux {\r\n" 14821 " int foo;\n" 14822 " int bar;\r\n" 14823 " int baz;\n" 14824 "};", 14825 style)); 14826 style.UseCRLF = true; 14827 EXPECT_EQ("union FooBarBazQux {\r\n" 14828 " int foo;\r\n" 14829 " int bar;\r\n" 14830 " int baz;\r\n" 14831 "};", 14832 format("union FooBarBazQux {\r\n" 14833 " int foo;\n" 14834 " int bar;\r\n" 14835 " int baz;\n" 14836 "};", 14837 style)); 14838 14839 style.DeriveLineEnding = false; 14840 style.UseCRLF = false; 14841 EXPECT_EQ("union FooBarBazQux {\n" 14842 " int foo;\n" 14843 " int bar;\n" 14844 " int baz;\n" 14845 " int qux;\n" 14846 "};", 14847 format("union FooBarBazQux {\r\n" 14848 " int foo;\n" 14849 " int bar;\r\n" 14850 " int baz;\n" 14851 " int qux;\r\n" 14852 "};", 14853 style)); 14854 style.UseCRLF = true; 14855 EXPECT_EQ("union FooBarBazQux {\r\n" 14856 " int foo;\r\n" 14857 " int bar;\r\n" 14858 " int baz;\r\n" 14859 " int qux;\r\n" 14860 "};", 14861 format("union FooBarBazQux {\r\n" 14862 " int foo;\n" 14863 " int bar;\r\n" 14864 " int baz;\n" 14865 " int qux;\n" 14866 "};", 14867 style)); 14868 14869 style.DeriveLineEnding = true; 14870 style.UseCRLF = false; 14871 EXPECT_EQ("union FooBarBazQux {\r\n" 14872 " int foo;\r\n" 14873 " int bar;\r\n" 14874 " int baz;\r\n" 14875 " int qux;\r\n" 14876 "};", 14877 format("union FooBarBazQux {\r\n" 14878 " int foo;\n" 14879 " int bar;\r\n" 14880 " int baz;\n" 14881 " int qux;\r\n" 14882 "};", 14883 style)); 14884 style.UseCRLF = true; 14885 EXPECT_EQ("union FooBarBazQux {\n" 14886 " int foo;\n" 14887 " int bar;\n" 14888 " int baz;\n" 14889 " int qux;\n" 14890 "};", 14891 format("union FooBarBazQux {\r\n" 14892 " int foo;\n" 14893 " int bar;\r\n" 14894 " int baz;\n" 14895 " int qux;\n" 14896 "};", 14897 style)); 14898 } 14899 14900 TEST_F(FormatTest, MunchSemicolonAfterBlocks) { 14901 verifyFormat("MY_CLASS(C) {\n" 14902 " int i;\n" 14903 " int j;\n" 14904 "};"); 14905 } 14906 14907 TEST_F(FormatTest, ConfigurableContinuationIndentWidth) { 14908 FormatStyle TwoIndent = getLLVMStyleWithColumns(15); 14909 TwoIndent.ContinuationIndentWidth = 2; 14910 14911 EXPECT_EQ("int i =\n" 14912 " longFunction(\n" 14913 " arg);", 14914 format("int i = longFunction(arg);", TwoIndent)); 14915 14916 FormatStyle SixIndent = getLLVMStyleWithColumns(20); 14917 SixIndent.ContinuationIndentWidth = 6; 14918 14919 EXPECT_EQ("int i =\n" 14920 " longFunction(\n" 14921 " arg);", 14922 format("int i = longFunction(arg);", SixIndent)); 14923 } 14924 14925 TEST_F(FormatTest, WrappedClosingParenthesisIndent) { 14926 FormatStyle Style = getLLVMStyle(); 14927 verifyFormat("int Foo::getter(\n" 14928 " //\n" 14929 ") const {\n" 14930 " return foo;\n" 14931 "}", 14932 Style); 14933 verifyFormat("void Foo::setter(\n" 14934 " //\n" 14935 ") {\n" 14936 " foo = 1;\n" 14937 "}", 14938 Style); 14939 } 14940 14941 TEST_F(FormatTest, SpacesInAngles) { 14942 FormatStyle Spaces = getLLVMStyle(); 14943 Spaces.SpacesInAngles = true; 14944 14945 verifyFormat("static_cast< int >(arg);", Spaces); 14946 verifyFormat("template < typename T0, typename T1 > void f() {}", Spaces); 14947 verifyFormat("f< int, float >();", Spaces); 14948 verifyFormat("template <> g() {}", Spaces); 14949 verifyFormat("template < std::vector< int > > f() {}", Spaces); 14950 verifyFormat("std::function< void(int, int) > fct;", Spaces); 14951 verifyFormat("void inFunction() { std::function< void(int, int) > fct; }", 14952 Spaces); 14953 14954 Spaces.Standard = FormatStyle::LS_Cpp03; 14955 Spaces.SpacesInAngles = true; 14956 verifyFormat("A< A< int > >();", Spaces); 14957 14958 Spaces.SpacesInAngles = false; 14959 verifyFormat("A<A<int> >();", Spaces); 14960 14961 Spaces.Standard = FormatStyle::LS_Cpp11; 14962 Spaces.SpacesInAngles = true; 14963 verifyFormat("A< A< int > >();", Spaces); 14964 14965 Spaces.SpacesInAngles = false; 14966 verifyFormat("A<A<int>>();", Spaces); 14967 } 14968 14969 TEST_F(FormatTest, SpaceAfterTemplateKeyword) { 14970 FormatStyle Style = getLLVMStyle(); 14971 Style.SpaceAfterTemplateKeyword = false; 14972 verifyFormat("template<int> void foo();", Style); 14973 } 14974 14975 TEST_F(FormatTest, TripleAngleBrackets) { 14976 verifyFormat("f<<<1, 1>>>();"); 14977 verifyFormat("f<<<1, 1, 1, s>>>();"); 14978 verifyFormat("f<<<a, b, c, d>>>();"); 14979 EXPECT_EQ("f<<<1, 1>>>();", format("f <<< 1, 1 >>> ();")); 14980 verifyFormat("f<param><<<1, 1>>>();"); 14981 verifyFormat("f<1><<<1, 1>>>();"); 14982 EXPECT_EQ("f<param><<<1, 1>>>();", format("f< param > <<< 1, 1 >>> ();")); 14983 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 14984 "aaaaaaaaaaa<<<\n 1, 1>>>();"); 14985 verifyFormat("aaaaaaaaaaaaaaa<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaa>\n" 14986 " <<<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaaaaaa>>>();"); 14987 } 14988 14989 TEST_F(FormatTest, MergeLessLessAtEnd) { 14990 verifyFormat("<<"); 14991 EXPECT_EQ("< < <", format("\\\n<<<")); 14992 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 14993 "aaallvm::outs() <<"); 14994 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 14995 "aaaallvm::outs()\n <<"); 14996 } 14997 14998 TEST_F(FormatTest, HandleUnbalancedImplicitBracesAcrossPPBranches) { 14999 std::string code = "#if A\n" 15000 "#if B\n" 15001 "a.\n" 15002 "#endif\n" 15003 " a = 1;\n" 15004 "#else\n" 15005 "#endif\n" 15006 "#if C\n" 15007 "#else\n" 15008 "#endif\n"; 15009 EXPECT_EQ(code, format(code)); 15010 } 15011 15012 TEST_F(FormatTest, HandleConflictMarkers) { 15013 // Git/SVN conflict markers. 15014 EXPECT_EQ("int a;\n" 15015 "void f() {\n" 15016 " callme(some(parameter1,\n" 15017 "<<<<<<< text by the vcs\n" 15018 " parameter2),\n" 15019 "||||||| text by the vcs\n" 15020 " parameter2),\n" 15021 " parameter3,\n" 15022 "======= text by the vcs\n" 15023 " parameter2, parameter3),\n" 15024 ">>>>>>> text by the vcs\n" 15025 " otherparameter);\n", 15026 format("int a;\n" 15027 "void f() {\n" 15028 " callme(some(parameter1,\n" 15029 "<<<<<<< text by the vcs\n" 15030 " parameter2),\n" 15031 "||||||| text by the vcs\n" 15032 " parameter2),\n" 15033 " parameter3,\n" 15034 "======= text by the vcs\n" 15035 " parameter2,\n" 15036 " parameter3),\n" 15037 ">>>>>>> text by the vcs\n" 15038 " otherparameter);\n")); 15039 15040 // Perforce markers. 15041 EXPECT_EQ("void f() {\n" 15042 " function(\n" 15043 ">>>> text by the vcs\n" 15044 " parameter,\n" 15045 "==== text by the vcs\n" 15046 " parameter,\n" 15047 "==== text by the vcs\n" 15048 " parameter,\n" 15049 "<<<< text by the vcs\n" 15050 " parameter);\n", 15051 format("void f() {\n" 15052 " function(\n" 15053 ">>>> text by the vcs\n" 15054 " parameter,\n" 15055 "==== text by the vcs\n" 15056 " parameter,\n" 15057 "==== text by the vcs\n" 15058 " parameter,\n" 15059 "<<<< text by the vcs\n" 15060 " parameter);\n")); 15061 15062 EXPECT_EQ("<<<<<<<\n" 15063 "|||||||\n" 15064 "=======\n" 15065 ">>>>>>>", 15066 format("<<<<<<<\n" 15067 "|||||||\n" 15068 "=======\n" 15069 ">>>>>>>")); 15070 15071 EXPECT_EQ("<<<<<<<\n" 15072 "|||||||\n" 15073 "int i;\n" 15074 "=======\n" 15075 ">>>>>>>", 15076 format("<<<<<<<\n" 15077 "|||||||\n" 15078 "int i;\n" 15079 "=======\n" 15080 ">>>>>>>")); 15081 15082 // FIXME: Handle parsing of macros around conflict markers correctly: 15083 EXPECT_EQ("#define Macro \\\n" 15084 "<<<<<<<\n" 15085 "Something \\\n" 15086 "|||||||\n" 15087 "Else \\\n" 15088 "=======\n" 15089 "Other \\\n" 15090 ">>>>>>>\n" 15091 " End int i;\n", 15092 format("#define Macro \\\n" 15093 "<<<<<<<\n" 15094 " Something \\\n" 15095 "|||||||\n" 15096 " Else \\\n" 15097 "=======\n" 15098 " Other \\\n" 15099 ">>>>>>>\n" 15100 " End\n" 15101 "int i;\n")); 15102 } 15103 15104 TEST_F(FormatTest, DisableRegions) { 15105 EXPECT_EQ("int i;\n" 15106 "// clang-format off\n" 15107 " int j;\n" 15108 "// clang-format on\n" 15109 "int k;", 15110 format(" int i;\n" 15111 " // clang-format off\n" 15112 " int j;\n" 15113 " // clang-format on\n" 15114 " int k;")); 15115 EXPECT_EQ("int i;\n" 15116 "/* clang-format off */\n" 15117 " int j;\n" 15118 "/* clang-format on */\n" 15119 "int k;", 15120 format(" int i;\n" 15121 " /* clang-format off */\n" 15122 " int j;\n" 15123 " /* clang-format on */\n" 15124 " int k;")); 15125 15126 // Don't reflow comments within disabled regions. 15127 EXPECT_EQ("// clang-format off\n" 15128 "// long long long long long long line\n" 15129 "/* clang-format on */\n" 15130 "/* long long long\n" 15131 " * long long long\n" 15132 " * line */\n" 15133 "int i;\n" 15134 "/* clang-format off */\n" 15135 "/* long long long long long long line */\n", 15136 format("// clang-format off\n" 15137 "// long long long long long long line\n" 15138 "/* clang-format on */\n" 15139 "/* long long long long long long line */\n" 15140 "int i;\n" 15141 "/* clang-format off */\n" 15142 "/* long long long long long long line */\n", 15143 getLLVMStyleWithColumns(20))); 15144 } 15145 15146 TEST_F(FormatTest, DoNotCrashOnInvalidInput) { 15147 format("? ) ="); 15148 verifyNoCrash("#define a\\\n /**/}"); 15149 } 15150 15151 TEST_F(FormatTest, FormatsTableGenCode) { 15152 FormatStyle Style = getLLVMStyle(); 15153 Style.Language = FormatStyle::LK_TableGen; 15154 verifyFormat("include \"a.td\"\ninclude \"b.td\"", Style); 15155 } 15156 15157 TEST_F(FormatTest, ArrayOfTemplates) { 15158 EXPECT_EQ("auto a = new unique_ptr<int>[10];", 15159 format("auto a = new unique_ptr<int > [ 10];")); 15160 15161 FormatStyle Spaces = getLLVMStyle(); 15162 Spaces.SpacesInSquareBrackets = true; 15163 EXPECT_EQ("auto a = new unique_ptr<int>[ 10 ];", 15164 format("auto a = new unique_ptr<int > [10];", Spaces)); 15165 } 15166 15167 TEST_F(FormatTest, ArrayAsTemplateType) { 15168 EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[10]>;", 15169 format("auto a = unique_ptr < Foo < Bar>[ 10]> ;")); 15170 15171 FormatStyle Spaces = getLLVMStyle(); 15172 Spaces.SpacesInSquareBrackets = true; 15173 EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[ 10 ]>;", 15174 format("auto a = unique_ptr < Foo < Bar>[10]> ;", Spaces)); 15175 } 15176 15177 TEST_F(FormatTest, NoSpaceAfterSuper) { verifyFormat("__super::FooBar();"); } 15178 15179 TEST(FormatStyle, GetStyleWithEmptyFileName) { 15180 llvm::vfs::InMemoryFileSystem FS; 15181 auto Style1 = getStyle("file", "", "Google", "", &FS); 15182 ASSERT_TRUE((bool)Style1); 15183 ASSERT_EQ(*Style1, getGoogleStyle()); 15184 } 15185 15186 TEST(FormatStyle, GetStyleOfFile) { 15187 llvm::vfs::InMemoryFileSystem FS; 15188 // Test 1: format file in the same directory. 15189 ASSERT_TRUE( 15190 FS.addFile("/a/.clang-format", 0, 15191 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM"))); 15192 ASSERT_TRUE( 15193 FS.addFile("/a/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;"))); 15194 auto Style1 = getStyle("file", "/a/.clang-format", "Google", "", &FS); 15195 ASSERT_TRUE((bool)Style1); 15196 ASSERT_EQ(*Style1, getLLVMStyle()); 15197 15198 // Test 2.1: fallback to default. 15199 ASSERT_TRUE( 15200 FS.addFile("/b/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;"))); 15201 auto Style2 = getStyle("file", "/b/test.cpp", "Mozilla", "", &FS); 15202 ASSERT_TRUE((bool)Style2); 15203 ASSERT_EQ(*Style2, getMozillaStyle()); 15204 15205 // Test 2.2: no format on 'none' fallback style. 15206 Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS); 15207 ASSERT_TRUE((bool)Style2); 15208 ASSERT_EQ(*Style2, getNoStyle()); 15209 15210 // Test 2.3: format if config is found with no based style while fallback is 15211 // 'none'. 15212 ASSERT_TRUE(FS.addFile("/b/.clang-format", 0, 15213 llvm::MemoryBuffer::getMemBuffer("IndentWidth: 2"))); 15214 Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS); 15215 ASSERT_TRUE((bool)Style2); 15216 ASSERT_EQ(*Style2, getLLVMStyle()); 15217 15218 // Test 2.4: format if yaml with no based style, while fallback is 'none'. 15219 Style2 = getStyle("{}", "a.h", "none", "", &FS); 15220 ASSERT_TRUE((bool)Style2); 15221 ASSERT_EQ(*Style2, getLLVMStyle()); 15222 15223 // Test 3: format file in parent directory. 15224 ASSERT_TRUE( 15225 FS.addFile("/c/.clang-format", 0, 15226 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: Google"))); 15227 ASSERT_TRUE(FS.addFile("/c/sub/sub/sub/test.cpp", 0, 15228 llvm::MemoryBuffer::getMemBuffer("int i;"))); 15229 auto Style3 = getStyle("file", "/c/sub/sub/sub/test.cpp", "LLVM", "", &FS); 15230 ASSERT_TRUE((bool)Style3); 15231 ASSERT_EQ(*Style3, getGoogleStyle()); 15232 15233 // Test 4: error on invalid fallback style 15234 auto Style4 = getStyle("file", "a.h", "KungFu", "", &FS); 15235 ASSERT_FALSE((bool)Style4); 15236 llvm::consumeError(Style4.takeError()); 15237 15238 // Test 5: error on invalid yaml on command line 15239 auto Style5 = getStyle("{invalid_key=invalid_value}", "a.h", "LLVM", "", &FS); 15240 ASSERT_FALSE((bool)Style5); 15241 llvm::consumeError(Style5.takeError()); 15242 15243 // Test 6: error on invalid style 15244 auto Style6 = getStyle("KungFu", "a.h", "LLVM", "", &FS); 15245 ASSERT_FALSE((bool)Style6); 15246 llvm::consumeError(Style6.takeError()); 15247 15248 // Test 7: found config file, error on parsing it 15249 ASSERT_TRUE( 15250 FS.addFile("/d/.clang-format", 0, 15251 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM\n" 15252 "InvalidKey: InvalidValue"))); 15253 ASSERT_TRUE( 15254 FS.addFile("/d/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;"))); 15255 auto Style7 = getStyle("file", "/d/.clang-format", "LLVM", "", &FS); 15256 ASSERT_FALSE((bool)Style7); 15257 llvm::consumeError(Style7.takeError()); 15258 15259 // Test 8: inferred per-language defaults apply. 15260 auto StyleTd = getStyle("file", "x.td", "llvm", "", &FS); 15261 ASSERT_TRUE((bool)StyleTd); 15262 ASSERT_EQ(*StyleTd, getLLVMStyle(FormatStyle::LK_TableGen)); 15263 } 15264 15265 TEST_F(ReplacementTest, FormatCodeAfterReplacements) { 15266 // Column limit is 20. 15267 std::string Code = "Type *a =\n" 15268 " new Type();\n" 15269 "g(iiiii, 0, jjjjj,\n" 15270 " 0, kkkkk, 0, mm);\n" 15271 "int bad = format ;"; 15272 std::string Expected = "auto a = new Type();\n" 15273 "g(iiiii, nullptr,\n" 15274 " jjjjj, nullptr,\n" 15275 " kkkkk, nullptr,\n" 15276 " mm);\n" 15277 "int bad = format ;"; 15278 FileID ID = Context.createInMemoryFile("format.cpp", Code); 15279 tooling::Replacements Replaces = toReplacements( 15280 {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 6, 15281 "auto "), 15282 tooling::Replacement(Context.Sources, Context.getLocation(ID, 3, 10), 1, 15283 "nullptr"), 15284 tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 3), 1, 15285 "nullptr"), 15286 tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 13), 1, 15287 "nullptr")}); 15288 15289 format::FormatStyle Style = format::getLLVMStyle(); 15290 Style.ColumnLimit = 20; // Set column limit to 20 to increase readibility. 15291 auto FormattedReplaces = formatReplacements(Code, Replaces, Style); 15292 EXPECT_TRUE(static_cast<bool>(FormattedReplaces)) 15293 << llvm::toString(FormattedReplaces.takeError()) << "\n"; 15294 auto Result = applyAllReplacements(Code, *FormattedReplaces); 15295 EXPECT_TRUE(static_cast<bool>(Result)); 15296 EXPECT_EQ(Expected, *Result); 15297 } 15298 15299 TEST_F(ReplacementTest, SortIncludesAfterReplacement) { 15300 std::string Code = "#include \"a.h\"\n" 15301 "#include \"c.h\"\n" 15302 "\n" 15303 "int main() {\n" 15304 " return 0;\n" 15305 "}"; 15306 std::string Expected = "#include \"a.h\"\n" 15307 "#include \"b.h\"\n" 15308 "#include \"c.h\"\n" 15309 "\n" 15310 "int main() {\n" 15311 " return 0;\n" 15312 "}"; 15313 FileID ID = Context.createInMemoryFile("fix.cpp", Code); 15314 tooling::Replacements Replaces = toReplacements( 15315 {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 0, 15316 "#include \"b.h\"\n")}); 15317 15318 format::FormatStyle Style = format::getLLVMStyle(); 15319 Style.SortIncludes = true; 15320 auto FormattedReplaces = formatReplacements(Code, Replaces, Style); 15321 EXPECT_TRUE(static_cast<bool>(FormattedReplaces)) 15322 << llvm::toString(FormattedReplaces.takeError()) << "\n"; 15323 auto Result = applyAllReplacements(Code, *FormattedReplaces); 15324 EXPECT_TRUE(static_cast<bool>(Result)); 15325 EXPECT_EQ(Expected, *Result); 15326 } 15327 15328 TEST_F(FormatTest, FormatSortsUsingDeclarations) { 15329 EXPECT_EQ("using std::cin;\n" 15330 "using std::cout;", 15331 format("using std::cout;\n" 15332 "using std::cin;", 15333 getGoogleStyle())); 15334 } 15335 15336 TEST_F(FormatTest, UTF8CharacterLiteralCpp03) { 15337 format::FormatStyle Style = format::getLLVMStyle(); 15338 Style.Standard = FormatStyle::LS_Cpp03; 15339 // cpp03 recognize this string as identifier u8 and literal character 'a' 15340 EXPECT_EQ("auto c = u8 'a';", format("auto c = u8'a';", Style)); 15341 } 15342 15343 TEST_F(FormatTest, UTF8CharacterLiteralCpp11) { 15344 // u8'a' is a C++17 feature, utf8 literal character, LS_Cpp11 covers 15345 // all modes, including C++11, C++14 and C++17 15346 EXPECT_EQ("auto c = u8'a';", format("auto c = u8'a';")); 15347 } 15348 15349 TEST_F(FormatTest, DoNotFormatLikelyXml) { 15350 EXPECT_EQ("<!-- ;> -->", format("<!-- ;> -->", getGoogleStyle())); 15351 EXPECT_EQ(" <!-- >; -->", format(" <!-- >; -->", getGoogleStyle())); 15352 } 15353 15354 TEST_F(FormatTest, StructuredBindings) { 15355 // Structured bindings is a C++17 feature. 15356 // all modes, including C++11, C++14 and C++17 15357 verifyFormat("auto [a, b] = f();"); 15358 EXPECT_EQ("auto [a, b] = f();", format("auto[a, b] = f();")); 15359 EXPECT_EQ("const auto [a, b] = f();", format("const auto[a, b] = f();")); 15360 EXPECT_EQ("auto const [a, b] = f();", format("auto const[a, b] = f();")); 15361 EXPECT_EQ("auto const volatile [a, b] = f();", 15362 format("auto const volatile[a, b] = f();")); 15363 EXPECT_EQ("auto [a, b, c] = f();", format("auto [ a , b,c ] = f();")); 15364 EXPECT_EQ("auto &[a, b, c] = f();", 15365 format("auto &[ a , b,c ] = f();")); 15366 EXPECT_EQ("auto &&[a, b, c] = f();", 15367 format("auto &&[ a , b,c ] = f();")); 15368 EXPECT_EQ("auto const &[a, b] = f();", format("auto const&[a, b] = f();")); 15369 EXPECT_EQ("auto const volatile &&[a, b] = f();", 15370 format("auto const volatile &&[a, b] = f();")); 15371 EXPECT_EQ("auto const &&[a, b] = f();", 15372 format("auto const && [a, b] = f();")); 15373 EXPECT_EQ("const auto &[a, b] = f();", 15374 format("const auto & [a, b] = f();")); 15375 EXPECT_EQ("const auto volatile &&[a, b] = f();", 15376 format("const auto volatile &&[a, b] = f();")); 15377 EXPECT_EQ("volatile const auto &&[a, b] = f();", 15378 format("volatile const auto &&[a, b] = f();")); 15379 EXPECT_EQ("const auto &&[a, b] = f();", 15380 format("const auto && [a, b] = f();")); 15381 15382 // Make sure we don't mistake structured bindings for lambdas. 15383 FormatStyle PointerMiddle = getLLVMStyle(); 15384 PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle; 15385 verifyFormat("auto [a1, b]{A * i};", getGoogleStyle()); 15386 verifyFormat("auto [a2, b]{A * i};", getLLVMStyle()); 15387 verifyFormat("auto [a3, b]{A * i};", PointerMiddle); 15388 verifyFormat("auto const [a1, b]{A * i};", getGoogleStyle()); 15389 verifyFormat("auto const [a2, b]{A * i};", getLLVMStyle()); 15390 verifyFormat("auto const [a3, b]{A * i};", PointerMiddle); 15391 verifyFormat("auto const& [a1, b]{A * i};", getGoogleStyle()); 15392 verifyFormat("auto const &[a2, b]{A * i};", getLLVMStyle()); 15393 verifyFormat("auto const & [a3, b]{A * i};", PointerMiddle); 15394 verifyFormat("auto const&& [a1, b]{A * i};", getGoogleStyle()); 15395 verifyFormat("auto const &&[a2, b]{A * i};", getLLVMStyle()); 15396 verifyFormat("auto const && [a3, b]{A * i};", PointerMiddle); 15397 15398 EXPECT_EQ("for (const auto &&[a, b] : some_range) {\n}", 15399 format("for (const auto && [a, b] : some_range) {\n}")); 15400 EXPECT_EQ("for (const auto &[a, b] : some_range) {\n}", 15401 format("for (const auto & [a, b] : some_range) {\n}")); 15402 EXPECT_EQ("for (const auto [a, b] : some_range) {\n}", 15403 format("for (const auto[a, b] : some_range) {\n}")); 15404 EXPECT_EQ("auto [x, y](expr);", format("auto[x,y] (expr);")); 15405 EXPECT_EQ("auto &[x, y](expr);", format("auto & [x,y] (expr);")); 15406 EXPECT_EQ("auto &&[x, y](expr);", format("auto && [x,y] (expr);")); 15407 EXPECT_EQ("auto const &[x, y](expr);", 15408 format("auto const & [x,y] (expr);")); 15409 EXPECT_EQ("auto const &&[x, y](expr);", 15410 format("auto const && [x,y] (expr);")); 15411 EXPECT_EQ("auto [x, y]{expr};", format("auto[x,y] {expr};")); 15412 EXPECT_EQ("auto const &[x, y]{expr};", 15413 format("auto const & [x,y] {expr};")); 15414 EXPECT_EQ("auto const &&[x, y]{expr};", 15415 format("auto const && [x,y] {expr};")); 15416 15417 format::FormatStyle Spaces = format::getLLVMStyle(); 15418 Spaces.SpacesInSquareBrackets = true; 15419 verifyFormat("auto [ a, b ] = f();", Spaces); 15420 verifyFormat("auto &&[ a, b ] = f();", Spaces); 15421 verifyFormat("auto &[ a, b ] = f();", Spaces); 15422 verifyFormat("auto const &&[ a, b ] = f();", Spaces); 15423 verifyFormat("auto const &[ a, b ] = f();", Spaces); 15424 } 15425 15426 TEST_F(FormatTest, FileAndCode) { 15427 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.cc", "")); 15428 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.m", "")); 15429 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.mm", "")); 15430 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "")); 15431 EXPECT_EQ(FormatStyle::LK_ObjC, 15432 guessLanguage("foo.h", "@interface Foo\n@end\n")); 15433 EXPECT_EQ( 15434 FormatStyle::LK_ObjC, 15435 guessLanguage("foo.h", "#define TRY(x, y) @try { x; } @finally { y; }")); 15436 EXPECT_EQ(FormatStyle::LK_ObjC, 15437 guessLanguage("foo.h", "#define AVAIL(x) @available(x, *))")); 15438 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.h", "@class Foo;")); 15439 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo", "")); 15440 EXPECT_EQ(FormatStyle::LK_ObjC, 15441 guessLanguage("foo", "@interface Foo\n@end\n")); 15442 EXPECT_EQ(FormatStyle::LK_ObjC, 15443 guessLanguage("foo.h", "int DoStuff(CGRect rect);\n")); 15444 EXPECT_EQ( 15445 FormatStyle::LK_ObjC, 15446 guessLanguage("foo.h", 15447 "#define MY_POINT_MAKE(x, y) CGPointMake((x), (y));\n")); 15448 EXPECT_EQ( 15449 FormatStyle::LK_Cpp, 15450 guessLanguage("foo.h", "#define FOO(...) auto bar = [] __VA_ARGS__;")); 15451 } 15452 15453 TEST_F(FormatTest, GuessLanguageWithCpp11AttributeSpecifiers) { 15454 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[noreturn]];")); 15455 EXPECT_EQ(FormatStyle::LK_ObjC, 15456 guessLanguage("foo.h", "array[[calculator getIndex]];")); 15457 EXPECT_EQ(FormatStyle::LK_Cpp, 15458 guessLanguage("foo.h", "[[noreturn, deprecated(\"so sorry\")]];")); 15459 EXPECT_EQ( 15460 FormatStyle::LK_Cpp, 15461 guessLanguage("foo.h", "[[noreturn, deprecated(\"gone, sorry\")]];")); 15462 EXPECT_EQ(FormatStyle::LK_ObjC, 15463 guessLanguage("foo.h", "[[noreturn foo] bar];")); 15464 EXPECT_EQ(FormatStyle::LK_Cpp, 15465 guessLanguage("foo.h", "[[clang::fallthrough]];")); 15466 EXPECT_EQ(FormatStyle::LK_ObjC, 15467 guessLanguage("foo.h", "[[clang:fallthrough] foo];")); 15468 EXPECT_EQ(FormatStyle::LK_Cpp, 15469 guessLanguage("foo.h", "[[gsl::suppress(\"type\")]];")); 15470 EXPECT_EQ(FormatStyle::LK_Cpp, 15471 guessLanguage("foo.h", "[[using clang: fallthrough]];")); 15472 EXPECT_EQ(FormatStyle::LK_ObjC, 15473 guessLanguage("foo.h", "[[abusing clang:fallthrough] bar];")); 15474 EXPECT_EQ(FormatStyle::LK_Cpp, 15475 guessLanguage("foo.h", "[[using gsl: suppress(\"type\")]];")); 15476 EXPECT_EQ( 15477 FormatStyle::LK_Cpp, 15478 guessLanguage("foo.h", "for (auto &&[endpoint, stream] : streams_)")); 15479 EXPECT_EQ( 15480 FormatStyle::LK_Cpp, 15481 guessLanguage("foo.h", 15482 "[[clang::callable_when(\"unconsumed\", \"unknown\")]]")); 15483 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[foo::bar, ...]]")); 15484 } 15485 15486 TEST_F(FormatTest, GuessLanguageWithCaret) { 15487 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^);")); 15488 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^, Bar);")); 15489 EXPECT_EQ(FormatStyle::LK_ObjC, 15490 guessLanguage("foo.h", "int(^)(char, float);")); 15491 EXPECT_EQ(FormatStyle::LK_ObjC, 15492 guessLanguage("foo.h", "int(^foo)(char, float);")); 15493 EXPECT_EQ(FormatStyle::LK_ObjC, 15494 guessLanguage("foo.h", "int(^foo[10])(char, float);")); 15495 EXPECT_EQ(FormatStyle::LK_ObjC, 15496 guessLanguage("foo.h", "int(^foo[kNumEntries])(char, float);")); 15497 EXPECT_EQ( 15498 FormatStyle::LK_ObjC, 15499 guessLanguage("foo.h", "int(^foo[(kNumEntries + 10)])(char, float);")); 15500 } 15501 15502 TEST_F(FormatTest, FormatsInlineAsmSymbolicNames) { 15503 // ASM symbolic names are identifiers that must be surrounded by [] without 15504 // space in between: 15505 // https://gcc.gnu.org/onlinedocs/gcc/Extended-Asm.html#InputOperands 15506 15507 // Example from https://bugs.llvm.org/show_bug.cgi?id=45108. 15508 verifyFormat(R"(// 15509 asm volatile("mrs %x[result], FPCR" : [result] "=r"(result)); 15510 )"); 15511 15512 // A list of several ASM symbolic names. 15513 verifyFormat(R"(asm("mov %[e], %[d]" : [d] "=rm"(d), [e] "rm"(*e));)"); 15514 15515 // ASM symbolic names in inline ASM with inputs and outputs. 15516 verifyFormat(R"(// 15517 asm("cmoveq %1, %2, %[result]" 15518 : [result] "=r"(result) 15519 : "r"(test), "r"(new), "[result]"(old)); 15520 )"); 15521 15522 // ASM symbolic names in inline ASM with no outputs. 15523 verifyFormat(R"(asm("mov %[e], %[d]" : : [d] "=rm"(d), [e] "rm"(*e));)"); 15524 } 15525 15526 TEST_F(FormatTest, GuessedLanguageWithInlineAsmClobbers) { 15527 EXPECT_EQ(FormatStyle::LK_Cpp, 15528 guessLanguage("foo.h", "void f() {\n" 15529 " asm (\"mov %[e], %[d]\"\n" 15530 " : [d] \"=rm\" (d)\n" 15531 " [e] \"rm\" (*e));\n" 15532 "}")); 15533 EXPECT_EQ(FormatStyle::LK_Cpp, 15534 guessLanguage("foo.h", "void f() {\n" 15535 " _asm (\"mov %[e], %[d]\"\n" 15536 " : [d] \"=rm\" (d)\n" 15537 " [e] \"rm\" (*e));\n" 15538 "}")); 15539 EXPECT_EQ(FormatStyle::LK_Cpp, 15540 guessLanguage("foo.h", "void f() {\n" 15541 " __asm (\"mov %[e], %[d]\"\n" 15542 " : [d] \"=rm\" (d)\n" 15543 " [e] \"rm\" (*e));\n" 15544 "}")); 15545 EXPECT_EQ(FormatStyle::LK_Cpp, 15546 guessLanguage("foo.h", "void f() {\n" 15547 " __asm__ (\"mov %[e], %[d]\"\n" 15548 " : [d] \"=rm\" (d)\n" 15549 " [e] \"rm\" (*e));\n" 15550 "}")); 15551 EXPECT_EQ(FormatStyle::LK_Cpp, 15552 guessLanguage("foo.h", "void f() {\n" 15553 " asm (\"mov %[e], %[d]\"\n" 15554 " : [d] \"=rm\" (d),\n" 15555 " [e] \"rm\" (*e));\n" 15556 "}")); 15557 EXPECT_EQ(FormatStyle::LK_Cpp, 15558 guessLanguage("foo.h", "void f() {\n" 15559 " asm volatile (\"mov %[e], %[d]\"\n" 15560 " : [d] \"=rm\" (d)\n" 15561 " [e] \"rm\" (*e));\n" 15562 "}")); 15563 } 15564 15565 TEST_F(FormatTest, GuessLanguageWithChildLines) { 15566 EXPECT_EQ(FormatStyle::LK_Cpp, 15567 guessLanguage("foo.h", "#define FOO ({ std::string s; })")); 15568 EXPECT_EQ(FormatStyle::LK_ObjC, 15569 guessLanguage("foo.h", "#define FOO ({ NSString *s; })")); 15570 EXPECT_EQ( 15571 FormatStyle::LK_Cpp, 15572 guessLanguage("foo.h", "#define FOO ({ foo(); ({ std::string s; }) })")); 15573 EXPECT_EQ( 15574 FormatStyle::LK_ObjC, 15575 guessLanguage("foo.h", "#define FOO ({ foo(); ({ NSString *s; }) })")); 15576 } 15577 15578 TEST_F(FormatTest, TypenameMacros) { 15579 std::vector<std::string> TypenameMacros = {"STACK_OF", "LIST", "TAILQ_ENTRY"}; 15580 15581 // Test case reported in https://bugs.llvm.org/show_bug.cgi?id=30353 15582 FormatStyle Google = getGoogleStyleWithColumns(0); 15583 Google.TypenameMacros = TypenameMacros; 15584 verifyFormat("struct foo {\n" 15585 " int bar;\n" 15586 " TAILQ_ENTRY(a) bleh;\n" 15587 "};", 15588 Google); 15589 15590 FormatStyle Macros = getLLVMStyle(); 15591 Macros.TypenameMacros = TypenameMacros; 15592 15593 verifyFormat("STACK_OF(int) a;", Macros); 15594 verifyFormat("STACK_OF(int) *a;", Macros); 15595 verifyFormat("STACK_OF(int const *) *a;", Macros); 15596 verifyFormat("STACK_OF(int *const) *a;", Macros); 15597 verifyFormat("STACK_OF(int, string) a;", Macros); 15598 verifyFormat("STACK_OF(LIST(int)) a;", Macros); 15599 verifyFormat("STACK_OF(LIST(int)) a, b;", Macros); 15600 verifyFormat("for (LIST(int) *a = NULL; a;) {\n}", Macros); 15601 verifyFormat("STACK_OF(int) f(LIST(int) *arg);", Macros); 15602 15603 Macros.PointerAlignment = FormatStyle::PAS_Left; 15604 verifyFormat("STACK_OF(int)* a;", Macros); 15605 verifyFormat("STACK_OF(int*)* a;", Macros); 15606 } 15607 15608 TEST_F(FormatTest, AmbersandInLamda) { 15609 // Test case reported in https://bugs.llvm.org/show_bug.cgi?id=41899 15610 FormatStyle AlignStyle = getLLVMStyle(); 15611 AlignStyle.PointerAlignment = FormatStyle::PAS_Left; 15612 verifyFormat("auto lambda = [&a = a]() { a = 2; };", AlignStyle); 15613 AlignStyle.PointerAlignment = FormatStyle::PAS_Right; 15614 verifyFormat("auto lambda = [&a = a]() { a = 2; };", AlignStyle); 15615 } 15616 15617 TEST_F(FormatTest, SpacesInConditionalStatement) { 15618 FormatStyle Spaces = getLLVMStyle(); 15619 Spaces.SpacesInConditionalStatement = true; 15620 verifyFormat("for ( int i = 0; i; i++ )\n continue;", Spaces); 15621 verifyFormat("if ( !a )\n return;", Spaces); 15622 verifyFormat("if ( a )\n return;", Spaces); 15623 verifyFormat("if constexpr ( a )\n return;", Spaces); 15624 verifyFormat("switch ( a )\ncase 1:\n return;", Spaces); 15625 verifyFormat("while ( a )\n return;", Spaces); 15626 verifyFormat("while ( (a && b) )\n return;", Spaces); 15627 verifyFormat("do {\n} while ( 1 != 0 );", Spaces); 15628 verifyFormat("try {\n} catch ( const std::exception & ) {\n}", Spaces); 15629 // Check that space on the left of "::" is inserted as expected at beginning 15630 // of condition. 15631 verifyFormat("while ( ::func() )\n return;", Spaces); 15632 } 15633 15634 TEST_F(FormatTest, AlternativeOperators) { 15635 // Test case for ensuring alternate operators are not 15636 // combined with their right most neighbour. 15637 verifyFormat("int a and b;"); 15638 verifyFormat("int a and_eq b;"); 15639 verifyFormat("int a bitand b;"); 15640 verifyFormat("int a bitor b;"); 15641 verifyFormat("int a compl b;"); 15642 verifyFormat("int a not b;"); 15643 verifyFormat("int a not_eq b;"); 15644 verifyFormat("int a or b;"); 15645 verifyFormat("int a xor b;"); 15646 verifyFormat("int a xor_eq b;"); 15647 verifyFormat("return this not_eq bitand other;"); 15648 verifyFormat("bool operator not_eq(const X bitand other)"); 15649 15650 verifyFormat("int a and 5;"); 15651 verifyFormat("int a and_eq 5;"); 15652 verifyFormat("int a bitand 5;"); 15653 verifyFormat("int a bitor 5;"); 15654 verifyFormat("int a compl 5;"); 15655 verifyFormat("int a not 5;"); 15656 verifyFormat("int a not_eq 5;"); 15657 verifyFormat("int a or 5;"); 15658 verifyFormat("int a xor 5;"); 15659 verifyFormat("int a xor_eq 5;"); 15660 15661 verifyFormat("int a compl(5);"); 15662 verifyFormat("int a not(5);"); 15663 15664 /* FIXME handle alternate tokens 15665 * https://en.cppreference.com/w/cpp/language/operator_alternative 15666 // alternative tokens 15667 verifyFormat("compl foo();"); // ~foo(); 15668 verifyFormat("foo() <%%>;"); // foo(); 15669 verifyFormat("void foo() <%%>;"); // void foo(){} 15670 verifyFormat("int a <:1:>;"); // int a[1];[ 15671 verifyFormat("%:define ABC abc"); // #define ABC abc 15672 verifyFormat("%:%:"); // ## 15673 */ 15674 } 15675 15676 TEST_F(FormatTest, STLWhileNotDefineChed) { 15677 verifyFormat("#if defined(while)\n" 15678 "#define while EMIT WARNING C4005\n" 15679 "#endif // while"); 15680 } 15681 15682 TEST_F(FormatTest, OperatorSpacing) { 15683 FormatStyle Style = getLLVMStyle(); 15684 Style.PointerAlignment = FormatStyle::PAS_Right; 15685 verifyFormat("Foo::operator*();", Style); 15686 verifyFormat("Foo::operator void *();", Style); 15687 verifyFormat("Foo::operator void **();", Style); 15688 verifyFormat("Foo::operator()(void *);", Style); 15689 verifyFormat("Foo::operator*(void *);", Style); 15690 verifyFormat("Foo::operator*();", Style); 15691 verifyFormat("Foo::operator**();", Style); 15692 verifyFormat("Foo::operator&();", Style); 15693 verifyFormat("Foo::operator<int> *();", Style); 15694 verifyFormat("Foo::operator<Foo> *();", Style); 15695 verifyFormat("Foo::operator<int> **();", Style); 15696 verifyFormat("Foo::operator<Foo> **();", Style); 15697 verifyFormat("Foo::operator<int> &();", Style); 15698 verifyFormat("Foo::operator<Foo> &();", Style); 15699 verifyFormat("Foo::operator<int> &&();", Style); 15700 verifyFormat("Foo::operator<Foo> &&();", Style); 15701 verifyFormat("operator*(int (*)(), class Foo);", Style); 15702 15703 verifyFormat("Foo::operator&();", Style); 15704 verifyFormat("Foo::operator void &();", Style); 15705 verifyFormat("Foo::operator()(void &);", Style); 15706 verifyFormat("Foo::operator&(void &);", Style); 15707 verifyFormat("Foo::operator&();", Style); 15708 verifyFormat("operator&(int (&)(), class Foo);", Style); 15709 15710 verifyFormat("Foo::operator&&();", Style); 15711 verifyFormat("Foo::operator**();", Style); 15712 verifyFormat("Foo::operator void &&();", Style); 15713 verifyFormat("Foo::operator()(void &&);", Style); 15714 verifyFormat("Foo::operator&&(void &&);", Style); 15715 verifyFormat("Foo::operator&&();", Style); 15716 verifyFormat("operator&&(int(&&)(), class Foo);", Style); 15717 verifyFormat("operator const nsTArrayRight<E> &()", Style); 15718 verifyFormat("[[nodiscard]] operator const nsTArrayRight<E, Allocator> &()", 15719 Style); 15720 verifyFormat("operator void **()", Style); 15721 verifyFormat("operator const FooRight<Object> &()", Style); 15722 verifyFormat("operator const FooRight<Object> *()", Style); 15723 verifyFormat("operator const FooRight<Object> **()", Style); 15724 15725 Style.PointerAlignment = FormatStyle::PAS_Left; 15726 verifyFormat("Foo::operator*();", Style); 15727 verifyFormat("Foo::operator**();", Style); 15728 verifyFormat("Foo::operator void*();", Style); 15729 verifyFormat("Foo::operator void**();", Style); 15730 verifyFormat("Foo::operator/*comment*/ void*();", Style); 15731 verifyFormat("Foo::operator/*a*/ const /*b*/ void*();", Style); 15732 verifyFormat("Foo::operator/*a*/ volatile /*b*/ void*();", Style); 15733 verifyFormat("Foo::operator()(void*);", Style); 15734 verifyFormat("Foo::operator*(void*);", Style); 15735 verifyFormat("Foo::operator*();", Style); 15736 verifyFormat("Foo::operator<int>*();", Style); 15737 verifyFormat("Foo::operator<Foo>*();", Style); 15738 verifyFormat("Foo::operator<int>**();", Style); 15739 verifyFormat("Foo::operator<Foo>**();", Style); 15740 verifyFormat("Foo::operator<int>&();", Style); 15741 verifyFormat("Foo::operator<Foo>&();", Style); 15742 verifyFormat("Foo::operator<int>&&();", Style); 15743 verifyFormat("Foo::operator<Foo>&&();", Style); 15744 verifyFormat("operator*(int (*)(), class Foo);", Style); 15745 15746 verifyFormat("Foo::operator&();", Style); 15747 verifyFormat("Foo::operator void&();", Style); 15748 verifyFormat("Foo::operator/*comment*/ void&();", Style); 15749 verifyFormat("Foo::operator/*a*/ const /*b*/ void&();", Style); 15750 verifyFormat("Foo::operator/*a*/ volatile /*b*/ void&();", Style); 15751 verifyFormat("Foo::operator()(void&);", Style); 15752 verifyFormat("Foo::operator&(void&);", Style); 15753 verifyFormat("Foo::operator&();", Style); 15754 verifyFormat("operator&(int (&)(), class Foo);", Style); 15755 15756 verifyFormat("Foo::operator&&();", Style); 15757 verifyFormat("Foo::operator void&&();", Style); 15758 verifyFormat("Foo::operator/*comment*/ void&&();", Style); 15759 verifyFormat("Foo::operator/*a*/ const /*b*/ void&&();", Style); 15760 verifyFormat("Foo::operator/*a*/ volatile /*b*/ void&&();", Style); 15761 verifyFormat("Foo::operator()(void&&);", Style); 15762 verifyFormat("Foo::operator&&(void&&);", Style); 15763 verifyFormat("Foo::operator&&();", Style); 15764 verifyFormat("operator&&(int(&&)(), class Foo);", Style); 15765 verifyFormat("operator const nsTArrayLeft<E>&()", Style); 15766 verifyFormat("[[nodiscard]] operator const nsTArrayLeft<E, Allocator>&()", 15767 Style); 15768 verifyFormat("operator void**()", Style); 15769 verifyFormat("operator const FooLeft<Object>&()", Style); 15770 verifyFormat("operator const FooLeft<Object>*()", Style); 15771 verifyFormat("operator const FooLeft<Object>**()", Style); 15772 15773 // PR45107 15774 verifyFormat("operator Vector<String>&();", Style); 15775 verifyFormat("operator const Vector<String>&();", Style); 15776 verifyFormat("operator foo::Bar*();", Style); 15777 verifyFormat("operator const Foo<X>::Bar<Y>*();", Style); 15778 verifyFormat("operator/*a*/ const /*b*/ Foo /*c*/<X> /*d*/ ::Bar<Y>*();", 15779 Style); 15780 15781 Style.PointerAlignment = FormatStyle::PAS_Middle; 15782 verifyFormat("Foo::operator*();", Style); 15783 verifyFormat("Foo::operator void *();", Style); 15784 verifyFormat("Foo::operator()(void *);", Style); 15785 verifyFormat("Foo::operator*(void *);", Style); 15786 verifyFormat("Foo::operator*();", Style); 15787 verifyFormat("operator*(int (*)(), class Foo);", Style); 15788 15789 verifyFormat("Foo::operator&();", Style); 15790 verifyFormat("Foo::operator void &();", Style); 15791 verifyFormat("Foo::operator()(void &);", Style); 15792 verifyFormat("Foo::operator&(void &);", Style); 15793 verifyFormat("Foo::operator&();", Style); 15794 verifyFormat("operator&(int (&)(), class Foo);", Style); 15795 15796 verifyFormat("Foo::operator&&();", Style); 15797 verifyFormat("Foo::operator void &&();", Style); 15798 verifyFormat("Foo::operator()(void &&);", Style); 15799 verifyFormat("Foo::operator&&(void &&);", Style); 15800 verifyFormat("Foo::operator&&();", Style); 15801 verifyFormat("operator&&(int(&&)(), class Foo);", Style); 15802 } 15803 15804 } // namespace 15805 } // namespace format 15806 } // namespace clang 15807